@things-factory/figure-ui 10.1.129 → 10.1.141

package/test/joint-frames.test.ts

@@ -13,6 +13,7 @@ import { jointAxisUnit, jointAxisWord } from '../client/modeller/joint-axis.ts'
 import { alignOf, endPlaceKeyOf, fasteningOf, fixedJointOf, motionFormOf, motionFormRefusalOf, motionJoint, motionOf, rowAxesOf, rowBlockOf } from '../client/modeller/links.ts'
 import { jointDragOf } from '../client/modeller/joint-drag.ts'
 import { jointFanOf } from '../client/modeller/joint-fan.ts'
+import { revisionOf } from './revision-of.ts'
 
 type Dynamic = any
 const set = (asset: FigureAsset, joint: Dynamic) => applyFigureAuthoring(asset, { kind: 'set-joint', joint } as FigureAuthoringAction)
@@ -71,7 +72,7 @@ const frameOf = (j: Dynamic, keepType = true) => ({
 
 /** The fastening form's 붙이기, as figure-links builds it from what `fasteningOf` reads; nothing where it writes none. */
 function fasteningSave(asset: FigureAsset, part: string): FigureAuthoringAction | null {
-  const f = fasteningOf(asset, part) as Dynamic
+  const f = fasteningOf(revisionOf(asset), part) as Dynamic
   if (!f || f.atOrigin) return null
   const aim = f.toPlane ? ('plane' as const) : { part: f.target, face: f.targetFace }
   const align = alignOf(asset, part, aim, f.align, f.alignMm, !!f.twist, f.alignInput)
@@ -200,10 +201,10 @@ test('placed by an origin: said as the origin, no row offered, and the fastening
   const asset = framed()
   assert.equal(endPlaceKeyOf(jointOf(asset, 'tool').body0), 'figure.label.joint-origin')
   assert.equal(endPlaceKeyOf(jointOf(asset, 'link').body0), 'figure.label.face-top')
-  assert.equal((fasteningOf(asset, 'tool') as Dynamic).atOrigin, true)
-  assert.equal((fasteningOf(asset, 'cap') as Dynamic).atOrigin, true)
-  assert.equal((fasteningOf(asset, 'cap') as Dynamic).face, 'centre')
-  assert.equal((fasteningOf(asset, 'link') as Dynamic).atOrigin, undefined)
+  assert.equal((fasteningOf(revisionOf(asset), 'tool') as Dynamic).atOrigin, true)
+  assert.equal((fasteningOf(revisionOf(asset), 'cap') as Dynamic).atOrigin, true)
+  assert.equal((fasteningOf(revisionOf(asset), 'cap') as Dynamic).face, 'centre')
+  assert.equal((fasteningOf(revisionOf(asset), 'link') as Dynamic).atOrigin, undefined)
   assert.equal(fasteningSave(asset, 'tool'), null)
   assert.deepEqual(rowAxesOf(asset, 'cap'), [])
   assert.equal(rowBlockOf(asset, 'cap'), 'at-origin')
@@ -265,12 +266,12 @@ test('a fan stands about a vector axis, as it does about the same token', frames
   a = box(a, 'arm', 400, 50, 50, 125)
   a = set(a, { id: 'base', type: 'fixed', body0: { plane: 'mounting-plane' }, body1: { part: 'base', face: 'bottom' } })
   const arm = (axis: unknown) => set(a, { id: 'arm', type: 'revolute', body0: { part: 'base', face: 'top' }, body1: { part: 'arm', face: 'bottom' }, axis, lowerLimit: -45, upperLimit: 90 })
-  const token = jointFanOf(arm('Y'), 'arm') as never as { pose: { t: number[]; r: number[][] } }
-  const vector = jointFanOf(arm({ x: 0, y: 2, z: 0 }), 'arm') as never as { pose: { t: number[]; r: number[][] } }
+  const token = jointFanOf(revisionOf(arm('Y')), 'arm') as never as { pose: { t: number[]; r: number[][] } }
+  const vector = jointFanOf(revisionOf(arm({ x: 0, y: 2, z: 0 })), 'arm') as never as { pose: { t: number[]; r: number[][] } }
   assert.ok(token && vector, 'a fan for both')
   const off = (p: number[][], q: number[][]) => Math.max(...p.flatMap((row, i) => row.map((v, j) => Math.abs(v - q[i]![j]!))))
   assert.ok(off(token.pose.r, vector.pose.r) < 1e-9 && off([token.pose.t], [vector.pose.t]) < 1e-9)
-  const tilted = jointFanOf(arm({ x: 0, y: 3, z: 4 }), 'arm') as never as { pose: { r: number[][] } }
+  const tilted = jointFanOf(revisionOf(arm({ x: 0, y: 3, z: 4 })), 'arm') as never as { pose: { r: number[][] } }
   assert.ok(tilted, 'a tilted axis has a fan too')
   /* The fan lies in its local X–Z: its local Y is the axis. */
   const normal = [0, 1, 2].map(i => tilted.pose.r[i]![1]!)

package/test/links.test.ts

@@ -11,6 +11,7 @@ import { addFigureBox, addFigurePrimitive, applyFigureAuthoring, createFigureAss
 import type { FigureAsset } from '@hatiolab/figure-model'
 
 import { acceptsOf, canFasten, canFollow, dimensionNow, instanceRangeOf, proportionToFollow, rangeDiffers, rangeWith, turnsAboutAJoint, valueNow, fastenedTo, followableAxes, followOf, hasInstanceSize, positionIsShare, holdsThings, motionOf, placeFacesOf, placeIdFor, placesOn, positionsWorkedOut } from '../client/modeller/links.ts'
+import { revisionOf } from './revision-of.ts'
 
 const pair = (): FigureAsset => {
   let asset = createFigureAsset('Pair')
@@ -91,7 +92,7 @@ test('편집기는 세 칸의 명령을 세션의 이력 하나로 돌리고,
 test('떼면 지금 크기로 고정한다 — 따르던 값을 잃지 않는다', () => {
   const links = read('../client/modeller/figure-links.ts')
   assert.ok(links.includes("this.command({ kind: 'unlink-dimension', part: this.partId, axis, mm: Math.max(1, Math.round(current)) })"))
-  assert.ok(links.includes('const current = dimensionNow(asset, this.partId, axis) ?? this.dims?.[AXES.indexOf(axis)] ?? 100'))
+  assert.ok(links.includes('const current = dimensionNow(this.revision!, this.partId, axis) ?? boxOf(this.revision!, this.partId)?.dims[AXES.indexOf(axis)] ?? 100'))
 })
 
 test('세 칸의 말은 다섯 말 모두에 있다', () => {
@@ -170,8 +171,8 @@ const sizedPair = () => {
 
 test('비례 — 인스턴스 크기의 몫을 따르는 치수는 비례로 읽고, 「남은 만큼 채우기」는 비례가 아니다', () => {
   const asset = sizedPair()
-  assert.equal(dimensionNow(asset, 'flange', 'y'), 10, '원기둥의 Y 는 길이')
-  assert.equal(dimensionNow(asset, 'flange', 'x'), 20, '원기둥의 X 는 반지름')
+  assert.equal(dimensionNow(revisionOf(asset), 'flange', 'y'), 10, '원기둥의 Y 는 길이')
+  assert.equal(dimensionNow(revisionOf(asset), 'flange', 'x'), 20, '원기둥의 X 는 반지름')
   const share = applyFigureAuthoring(asset, { kind: 'link-dimension', part: 'flange', axis: 'y', source: { of: 'instance', axis: 'y' }, times: 0.1 })
   assert.deepEqual(followOf(share, 'flange', 'y'), { of: 'instance', axis: 'y', times: 0.1 })
 
@@ -259,10 +260,10 @@ test('한 비율로 커지는 도형 — 자기 숫자인 길이를 세고, 한
   asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...lamp, type: 'prismatic', axis: 'Y', lowerLimit: 0, upperLimit: 50, state: { id: 'rise' } } })
   asset = applyFigureAuthoring(asset, { kind: 'follow-size-in-proportion' })
   assert.deepEqual(proportionToFollow(asset), { count: 0, kept: ['lamp.motion'] }, '다 따르고, mm 로 움직이는 것만 남는다')
-  assert.equal(Math.round(valueNow(asset, 'lamp.dimension.x.value')! * 1e6) / 1e6, 60, '따르게 해도 지금 크기는 그대로')
+  assert.equal(Math.round(valueNow(revisionOf(asset), 'lamp.dimension.x.value')! * 1e6) / 1e6, 60, '따르게 해도 지금 크기는 그대로')
   const editor = read('../client/modeller/editor.ts')
   assert.ok(editor.includes("this.linkCommand({ kind: 'follow-size-in-proportion' })"))
-  assert.ok(editor.includes("?? valueNow(asset, layout?.args[4])"), '길이를 따르는 간격도 숫자로 보인다')
+  assert.ok(editor.includes("?? valueNow(shown, layout?.args[4])"), '길이를 따르는 간격도 숫자로 보인다')
 })
 
 test('관절이 있는 도형에는 한 비율로 키우기를 권하고, 선언하면 규칙으로 보인다(수석 아키텍트 판정 09-24)', () => {
@@ -311,16 +312,16 @@ test('붙여도 제자리 — 폼은 지금 서 있는 자리를 가운데서
   asset = addFigureBox(asset, { id: 'leaf', size: { x: 1400, y: 2200, z: 40 }, position: { x: 250, y: 1100, z: 100 } })
   const where = (a: FigureAsset) => compileFigureAsset(a).evaluate().geometry.find(g => g.id === 'leaf')!.pose.t.map(v => Math.round(v))
   for (const target of ['plane', { part: 'frame', face: 'top' }] as const) {
-    const kept = placeKeptOf(asset, 'leaf', target)
+    const kept = placeKeptOf(revisionOf(asset), 'leaf', target)
     const align = alignOf(asset, 'leaf', target, kept.align, kept.alignMm)
     const to = target === 'plane' ? { plane: 'mounting-plane' as const } : target
     const fastened = applyFigureAuthoring(asset, { kind: 'attach', part: 'leaf', face: 'bottom', to, ...(align ? { align } : {}) } as never)
     const [before, after] = [where(asset), where(fastened)]
     assert.deepEqual([after[0], after[2]], [before[0], before[2]], `${JSON.stringify(target)}: 앞뒤·좌우는 그대로`)
   }
-  assert.deepEqual(placeKeptOf(asset, 'leaf', { part: 'frame', face: 'top' }), { align: { x: 'mm', z: 'mm' }, alignMm: { x: -50, z: 100 }, alignInput: {} })
+  assert.deepEqual(placeKeptOf(revisionOf(asset), 'leaf', { part: 'frame', face: 'top' }), { align: { x: 'mm', z: 'mm' }, alignMm: { x: -50, z: 100 }, alignInput: {} })
   const centred = addFigureBox(createFigureAsset('C'), { id: 'a', size: { x: 10, y: 10, z: 10 }, position: { x: 0, y: 5, z: 0 } })
-  assert.deepEqual(placeKeptOf(centred, 'a', 'plane'), { align: {}, alignMm: {}, alignInput: {} }, '가운데 있던 것은 가운데로')
+  assert.deepEqual(placeKeptOf(revisionOf(centred), 'a', 'plane'), { align: {}, alignMm: {}, alignInput: {} }, '가운데 있던 것은 가운데로')
 
   /* The form fills it in whenever the aim changes, and does not offer a part that hangs from this one. */
   const { hangsFrom } = await import('../client/modeller/links.ts')
@@ -648,17 +649,17 @@ test('붙이기 칸은 부품 제 붙임으로 열린다 — 가운데로 붙은
   asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'bed', face: 'bottom', to: { plane: 'mounting-plane' } })
   asset = addFigurePrimitive(asset, { id: 'roller', kind: 'cylinder', dimensions: { radius: 40, length: 560 }, position: { x: 0, y: 0, z: 0 }, rotation: { x: 90, y: 0, z: 0 } })
   asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'roller', face: 'centre', to: { part: 'bed', face: 'top' }, gap: 40, align: { x: 'min' } })
-  const roller = fasteningOf(asset, 'roller')!
+  const roller = fasteningOf(revisionOf(asset), 'roller')!
   assert.equal(roller.face, 'centre')
   assert.equal(roller.target, 'bed')
   assert.equal(roller.targetFace, 'top')
   assert.equal(roller.gap, 40)
   assert.equal(roller.align.x, 'min', '기록의 정렬')
-  const bed = fasteningOf(asset, 'bed')!
+  const bed = fasteningOf(revisionOf(asset), 'bed')!
   assert.deepEqual([bed.face, bed.toPlane], ['bottom', true])
-  assert.equal(fasteningOf(addFigureBox(createFigureAsset('Loose'), { id: 'b', size: { x: 1, y: 1, z: 1 }, position: { x: 0, y: 0, z: 0 } }), 'b'), null, '안 붙은 부품은 기본값으로')
+  assert.equal(fasteningOf(revisionOf(addFigureBox(createFigureAsset('Loose'), { id: 'b', size: { x: 1, y: 1, z: 1 }, position: { x: 0, y: 0, z: 0 } })), 'b'), null, '안 붙은 부품은 기본값으로')
   const panel = readFileSync(fileURLToPath(new URL('../client/modeller/figure-links.ts', import.meta.url)), 'utf8')
-  assert.ok(panel.includes('fasteningOf(this.asset, this.partId)'), '부품을 고르면 제 붙임으로 연다')
+  assert.ok(panel.includes('fasteningOf(this.revision, this.partId)'), '부품을 고르면 제 붙임으로 연다')
   assert.ok(panel.includes("...(f.toPlane ? [] : (['centre'] as const))"), '내 면에 가운데가 있다')
 })
 

package/test/live.test.ts

@@ -11,6 +11,7 @@ import { addFigureBox, applyFigureAuthoring, compileFigureAsset, createFigureAss
 
 import { liveOverridesOf, liveOverSession, livePartsOf, NOTHING_LIVE, scrubbed, scrubStep } from '../client/modeller/live.ts'
 import { moving } from './joints.ts'
+import { revisionOf } from './revision-of.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 
@@ -74,7 +75,7 @@ test('속성창 숫자 칸은 치는 동안 알리고, 이름표를 끌 수 있
   assert.ok(editor.includes('@input=${(e: Event) => this.typing(field as never, e)}'))
   assert.ok(editor.includes('@pointerdown=${(e: PointerEvent) => this.scrub(group.cells[axis] as never, e, unavailable)}'))
   for (const event of ['@state-live=', '@states-live=', '@part-live=']) assert.ok(editor.includes(event), event)
-  assert.ok(editor.includes('liveOverSession(asset as FigureAsset, this.currentInputs(), this.live)'), '캔버스는 세션 위에 끄는 값을 그린다 (행동은 아래 시험)')
+  assert.ok(editor.includes('liveOverSession(shown, this.live)'), '캔버스는 세션 위에 끄는 값을 그린다 (행동은 아래 시험)')
   const run = editor.slice(editor.indexOf('  private run(action'), editor.indexOf('  private hold('))
   assert.ok(run.includes('this.live = NOTHING_LIVE'), '기록하거나 거절되면 끄는 값을 버린다')
   const material = read('../client/modeller/figure-material-panel.ts')
@@ -107,10 +108,9 @@ test('끄는 동안은 세션이 지금 든 자세 위에 그린다 — 다른
   asset = addFigureBox(asset, { id: 'arm', size: { x: 100, y: 20, z: 20 }, position: { x: 400, y: 110, z: 0 } })
   asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'arm', face: 'bottom', to: { part: 'post', face: 'top' }, align: { x: 'min' } })
   asset = moving(asset, 'arm', { kind: 'turn', axis: 'y', id: 'swing', min: -180, max: 180 })
-  const current = { ...asset.designInputs, ...asset.stateDefaults, swing: 90 }
   const armAt = (parts: { id: string; pose: { t: number[] } }[]) => parts.find(p => p.id === 'arm')!.pose.t.map(v => Math.round(v))
   const committed = armAt(compileFigureAsset({ ...asset, stateDefaults: { ...asset.stateDefaults, swing: 90 } }).evaluate().geometry as never)
-  const dragging = armAt(liveOverSession(asset, current, { values: { shift: 30 } }) as never)
+  const dragging = armAt(liveOverSession(revisionOf(asset, { swing: 90 }), { values: { shift: 30 } }) as never)
   assert.deepEqual(dragging, committed, '사용자 2026-09-24: 「조작을 끝내면 완전히 다른 위치로 된다」 — swing 90 이 끄는 동안에도 남는다')
   const overSaved = armAt(livePartsOf(asset, { values: { shift: 30 } }) as never)
   assert.notDeepEqual(overSaved, committed, '전제: 저장된 기본값 위에 그리면 swing 이 0 으로 돌아간다')

package/test/parts-wiring.test.ts

@@ -29,7 +29,7 @@ test('복제 · 순서 · 삭제는 figure-model 의 부품 편집으로, 세션
 })
 
 test('작업대에서 가린 부품은 캔버스에서 빠지고, 다른 도형을 열면 풀린다', () => {
-  assert.ok(editor.includes('.parts=${this.drawnParts(view.geometry, asset)}'))
+  assert.ok(editor.includes('.parts=${this.drawnParts(view.geometry, live)}'))
   const drawn = editor.slice(editor.indexOf('  private drawnParts('), editor.indexOf('  private hold('))
   assert.ok(drawn.includes('parts.filter(body => !this.hiddenParts.has('), '끄는 값을 그릴 때도 가린 부품은 빠진다')
   const reset = editor.slice(editor.indexOf('protected willUpdate'), editor.indexOf('private run('))

package/test/properties.test.ts

@@ -13,6 +13,7 @@ import { addFigureBox, applyFigureAuthoring, createFigureAsset, inspectFigureAss
 
 import { tagsOf, figureFigureFacts } from '../client/modeller/figure-facts.ts'
 import { occupancyFromParts } from '../client/modeller/occupancy.ts'
+import { revisionOf } from './revision-of.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 const probe = () => {
@@ -20,7 +21,7 @@ const probe = () => {
   asset = addFigureBox(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
   return asset
 }
-const facts = (asset: ReturnType<typeof probe>) => figureFigureFacts(serializeFigureAsset(asset))
+const facts = (asset: ReturnType<typeof probe>) => figureFigureFacts(revisionOf(asset))
 
 test('탭이 읽는 사실 — 선언 전에는 배치 기준도 장착면도 「없음」이다', () => {
   const read = facts(probe())
@@ -33,7 +34,7 @@ test('탭이 읽는 사실 — 선언 전에는 배치 기준도 장착면도
 
 test('배치 기준을 고르면 그 기준으로 공간을 선언한다 — 판정도 풀린다', () => {
   const source = serializeFigureAsset(probe())
-  const declared = applyFigureAuthoring(parseFigureAsset(source), occupancyFromParts(source, 'ceiling'))
+  const declared = applyFigureAuthoring(parseFigureAsset(source), occupancyFromParts(parseFigureAsset(source), 'ceiling'))
 
   assert.equal(facts(declared).placement, 'ceiling')
   assert.equal(facts(declared).declared, true)
@@ -42,7 +43,7 @@ test('배치 기준을 고르면 그 기준으로 공간을 선언한다 — 판
 
 test('장착면을 정하면 탭이 그 부품과 면을 다시 읽고, 해제하면 없어진다', () => {
   const source = serializeFigureAsset(probe())
-  const declared = applyFigureAuthoring(parseFigureAsset(source), occupancyFromParts(source))
+  const declared = applyFigureAuthoring(parseFigureAsset(source), occupancyFromParts(parseFigureAsset(source)))
   const mounted = applyFigureAuthoring(declared, { kind: 'set-mounting-face', part: 'body', face: 'bottom' })
 
   assert.deepEqual(facts(mounted).mounting, { part: 'body', face: 'bottom' })
@@ -84,7 +85,7 @@ test('발행한 뒤에도 행의 타입이 남는다 — 새로 짜면 잠긴
 
 test('속성 탭의 말은 다섯 말 모두에 있다', () => {
   const tab = read('../client/modeller/figure-properties.ts')
-  assert.ok(tab.includes('occupancyFromParts(this.source, placement)'), '고른 배치 기준으로 선언한다')
+  assert.ok(tab.includes('occupancyFromParts(this.revision.asset, placement)'), '고른 배치 기준으로 선언한다')
   const keys = [...tab.matchAll(/'(figure\.[a-z.-]*[a-z])'/g)].map(m => m[1])
   for (const face of ['left', 'right', 'bottom', 'top', 'back', 'front']) keys.push(`figure.label.face-${face}`)
   for (const one of ['floor', 'ceiling', 'center']) keys.push(`figure.label.placement-${one}`)
@@ -100,7 +101,7 @@ test('장착면은 도형이 평면에 닿는 부품으로 권한다 — 다리
   let asset = fm.addFigureBox(fm.createFigureAsset('Conveyor'), { id: 'bed', size: { x: 3000, y: 700, z: 800 }, position: { x: 0, y: 1050, z: 0 } })
   asset = fm.addFigureBox(asset, { id: 'leg', size: { x: 60, y: 700, z: 60 }, position: { x: -1400, y: 350, z: -300 } })
   asset = fm.applyFigureAuthoring(asset, { kind: 'attach', part: 'leg', face: 'top', to: { part: 'bed', face: 'bottom' }, align: { x: 'min', z: 'min' } })
-  const facts = figureFigureFacts(fm.serializeFigureAsset(asset))
+  const facts = figureFigureFacts(revisionOf(asset))
   assert.deepEqual(facts.suggested, { part: 'leg', face: 'bottom' })
   assert.equal(facts.parts[0], 'bed', '목록의 첫 부품은 바닥이다')
   const panel = readFileSync(fileURLToPath(new URL('../client/modeller/figure-properties.ts', import.meta.url)), 'utf8')

package/test/release-panel.test.ts

@@ -32,7 +32,7 @@ test('새로 만든 도형의 「공간 선언 없음」을 「부품에 맞추
   asset = addFigureBox(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
   assert.deepEqual(codes(asset), ['OCCUPANCY_UNDECLARED'], '전제: 선언 없는 도형은 막힌다')
 
-  const fitted = applyFigureAuthoring(asset, occupancyFromParts(serializeFigureAsset(asset)))
+  const fitted = applyFigureAuthoring(asset, occupancyFromParts(asset))
 
   assert.deepEqual(codes(fitted), [])
   assert.equal(fitted.placement ?? 'floor', 'floor', '처음 선언하는 도형은 바닥에 선다')
@@ -46,7 +46,7 @@ test('선언한 공간을 넘은 부품도 같은 한 번으로 풀리고, 배
   asset = addFigureBox(asset, { id: 'arm', size: { x: 100, y: 100, z: 100 }, position: { x: 900, y: 50, z: 0 } })
   assert.ok(codes(asset).includes('PART_OUTSIDE_OCCUPANCY'), '전제: 넘은 부품은 막힌다')
 
-  const fitted = applyFigureAuthoring(asset, occupancyFromParts(serializeFigureAsset(asset)))
+  const fitted = applyFigureAuthoring(asset, occupancyFromParts(asset))
 
   assert.deepEqual(codes(fitted), [])
   assert.equal(fitted.placement, 'center', '이미 선언된 배치 기준을 바꾸지 않는다')
@@ -61,7 +61,7 @@ test('모델러가 발행 패널을 걸고, 패널이 내는 셋을 받는다',
   for (const event of ['fit-base-to-parts', 'figure-released', 'figure-reverted']) {
     assert.ok(page.includes(`@${event}=`), `패널이 내는 ${event} 를 받는 자리가 없다 — 눌러도 아무 일이 없다`)
   }
-  assert.ok(/occupancyFromParts\(this\.session\.source\(\)\)/.test(page), '「부품에 맞추기」가 공간 선언으로 이어진다')
+  assert.ok(/occupancyFromParts\(shown\.asset\)/.test(page), '「부품에 맞추기」가 공간 선언으로 이어진다')
   /* 없으면 셸이 페이지를 내용 폭(편집기 660 + 패널 320)으로 세워 패널이 오른쪽 밖으로 나간다 — 945 px 에서 봤다. */
   assert.ok(/:host \{[^}]*overflow: hidden/.test(page), '페이지가 주어진 폭 안에 든다')
 })

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

@@ -7,6 +7,7 @@ import { createFigureProductSession } from '../client/modeller/product-session.j
 import { resizeRefusalOf } from '../client/modeller/refusals.js'
 import { resizeAxesOf } from '../client/modeller/links.js'
 import { groupFields } from '../client/modeller/fields.js'
+import { revisionOf } from './revision-of.ts'
 
 /*
  * ADR-0097: the modeller's "follow the size and keep where the figure is placed" is figure-model's plan, applied through
@@ -43,8 +44,9 @@ for (const mode of ['floor', 'ceiling', 'wall', 'center'] as const) {
     await session.open('ux')
     assert.equal(session.source(), after)
     /* At twice the height the kept face is where it was. */
-    const asset = parseFigureAsset(session.source())
-    asset.designInputs['size.y'] = asset.designInputs['size.y']! * 2
+    /* A parsed asset is sealed (figure-model ADR-0119): the doubled height goes into a copy, which is compiled afresh. */
+    const parsed = parseFigureAsset(session.source())
+    const asset = { ...parsed, designInputs: { ...parsed.designInputs, 'size.y': parsed.designInputs['size.y']! * 2 } }
     const g = compileFigureAsset(asset).evaluate().geometry.find(g => g.id === 'box')! as unknown as { pose: { t: number[] }; shape: { dimensions: Record<string, number> } }
     const y = g.pose.t[1]!, h = g.shape.dimensions.length!
     if (mode === 'floor') assert.equal(y - h / 2, 0)
@@ -144,7 +146,7 @@ test('the part component carries the face a size drag keeps, for each placement'
     assert.equal(componentOf(body, {}, { width: 1000, height: 1000 })!.scaleAnchor, undefined, 'none given, none set')
   }
   const editor = readFileSync(new URL('../client/modeller/editor.ts', import.meta.url), 'utf-8')
-  assert.ok(editor.includes('.anchors=${this.anchorsOf(asset as FigureAsset | undefined)}'))
+  assert.ok(editor.includes('.anchors=${this.anchorsOf(asset)}'))
 })
 
 /* Designer 2026-09-27 (acceptance round 2): what the screen shows for a part a rule places, and what it withholds. */
@@ -194,7 +196,7 @@ test('"open attachment settings" opens this part\'s fastening, as it is now, and
   let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 20, y: 150, z: 30 } })
   a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
   const kept = applyFigureProposal(a, planFigureResize(a, { part: 'box', gap: 'keep' }).steps)
-  const form = fasteningOf(kept, 'box')!
+  const form = fasteningOf(revisionOf(kept), 'box')!
   assert.equal(form.toPlane, true, 'on the plane')
   assert.equal(form.face, 'bottom')
   assert.equal(form.gap, 100, 'the gap it keeps')
@@ -202,7 +204,7 @@ test('"open attachment settings" opens this part\'s fastening, as it is now, and
   const editor = readFileSync(new URL('../client/modeller/editor.ts', import.meta.url), 'utf-8')
   assert.ok(links.includes('@click=${() => this.openFastening(asset)}'))
   const open = links.slice(links.indexOf('  private async openFastening('), links.indexOf('  /**\n   * What holds the part, said as its state'))
-  assert.ok(open.includes('const own = fasteningOf(asset, this.partId)'), 'the form is loaded from the fastening it has now')
+  assert.ok(open.includes('const own = fasteningOf(this.revision!, this.partId)'), 'the form is loaded from the fastening it has now')
   assert.ok(open.includes("querySelector<HTMLElement>('section[fastening]')"), 'the fastening section is what comes into view')
   assert.ok(!editor.includes("@open-fastening=${() => (this.tab = 'capability')}"), 'it does not switch to the capability tab')
   assert.ok(links.includes('<section fastening ?spotlit=${this.spotlit}'))
@@ -217,7 +219,7 @@ test('the fastening form keeps a place that follows a position field, and fasten
   let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 200, y: 50, z: 150 } })
   a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
   const kept = applyFigureProposal(a, planFigureResize(a, { part: 'box' }).steps)
-  const form = fasteningOf(kept, 'box')!
+  const form = fasteningOf(revisionOf(kept), 'box')!
   assert.deepEqual([form.align.x, form.alignInput.x, form.align.z, form.alignInput.z], ['input', 'box.position.x', 'input', 'box.position.z'])
   const align = alignOf(kept, 'box', 'plane', form.align, form.alignMm, false, form.alignInput)
   const again = applyFigureAuthoring(kept, { kind: 'attach', part: 'box', face: 'bottom', to: { plane: 'mounting-plane' }, ...(align ? { align } : {}), replace: true } as never)

package/test/revision-of.ts

@@ -0,0 +1,22 @@
+/*
+ * A figure as the modeller holds it at one version: opened in an editor workspace, the values given set on it (a pose
+ * turned with the controls, a design value typed), and read as the product session reads it.
+ */
+import { createFigureEditorWorkspace, serializeFigureAsset } from '@hatiolab/figure-model'
+import type { FigureAsset } from '@hatiolab/figure-model'
+
+import { revisionFromView, type FigureRevision } from '../client/modeller/revision.ts'
+
+export function revisionOf(asset: FigureAsset, values: Record<string, number> = {}): FigureRevision {
+  const w = createFigureEditorWorkspace()
+  const opened = w.open(serializeFigureAsset(asset))
+  const context = opened.context!
+  const changes = Object.entries(values).flatMap(([id, value]) => {
+    const field = opened.fields.find(f => f.id === id)
+    if (!field) throw Error(`no input ${id}`)
+    return field.value === value ? [] : [{ kind: field.role === 'state' ? ('set-state' as const) : ('set-design' as const), input: id, unit: field.unit, value }]
+  })
+  if (changes.length) w.apply({ context, origin: 'ui', expectedRevision: 0, changes })
+  const view = w.read() as Parameters<typeof revisionFromView>[0]
+  return revisionFromView(view, () => w.export({ context }).text)
+}

package/test/revision.test.ts

@@ -0,0 +1,172 @@
+/*
+ * The figure on screen at one version (`revision.ts`): one object per version, from the product session, and everything
+ * the modeller works out from it kept with it. Its asset is the kernel's (ADR-0119 decision 6), so the screen's questions
+ * of it are answered without compiling or evaluating the figure again.
+ *
+ * The budgets are counts of whole-figure work (figure-model `measureFigureWork`), not times: the same on every machine.
+ * Selecting a part asks every question below; before the version was one object, a selection on the forklift compiled
+ * it twice and evaluated it three times on top of the session's own work (2026-10-10).
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+import { addFigureBox, applyFigureAuthoring, createFigureAsset, figureFaceOverhangOf, figurePartFaceOf, figurePlaneAlignChanges, figureRoomOnlyInputsOf, figureRowOf, figureScaleAnchorOf, measureFigureWork, serializeFigureAsset } from '@hatiolab/figure-model'
+import type { FigureAsset } from '@hatiolab/figure-model'
+
+import { createFigureProductSession } from '../client/modeller/product-session.ts'
+import { derivedHeld, derivedOf, type FigureRevision } from '../client/modeller/revision.ts'
+import { alignChanges, boxOf, canMirror, gridStepOf } from '../client/modeller/align.ts'
+import { jointFanOf } from '../client/modeller/joint-fan.ts'
+import { fasteningOf, measureNow, partSummaryOf, placeKeptOf } from '../client/modeller/links.ts'
+import { faceViewOf, myFaceFor } from '../client/modeller/fasten-geometry.ts'
+import { motionEndsOf } from '../client/modeller/motion-ends.ts'
+import { figureFigureFacts } from '../client/modeller/figure-facts.ts'
+import { gizmoReachOf } from '../client/modeller/gizmo.ts'
+import { moving } from './joints.ts'
+import { revisionOf } from './revision-of.ts'
+
+const arm = readFileSync(fileURLToPath(new URL('./fixtures/robot-arm-6dof.json', import.meta.url)), 'utf8')
+
+async function opened(source: string) {
+  const session = createFigureProductSession({ load: async id => ({ id, source }), save: async request => ({ id: request.id ?? 'saved', source: request.source }) })
+  await session.open('probe')
+  return session
+}
+
+test('one version is one object, from the session; another version is another, and undo is another again', async () => {
+  const session = await opened(arm)
+  const first = session.revisionNow()!
+  assert.equal(session.revisionNow(), first)
+  assert.equal(first.asset, session.read().asset)
+  assert.ok(Object.isFrozen(first.asset))
+  assert.equal(first.text, session.source())
+  const field = first.fields.find(f => f.role !== 'state')!
+  session.apply([{ kind: 'set-design', input: field.id, unit: field.unit, value: field.value + 10 }])
+  const second = session.revisionNow()!
+  assert.notEqual(second, first)
+  assert.equal(second.inputs[field.id], field.value + 10)
+  session.undo()
+  assert.notEqual(session.revisionNow(), first, 'a version made again is a new object')
+  assert.equal(session.revisionNow()!.inputs[field.id], field.value)
+})
+
+test('what is worked out from a version is kept with it, and goes with it', async () => {
+  const session = await opened(arm)
+  const first = session.revisionNow()!
+  let made = 0
+  const ask = (r: FigureRevision) => derivedOf(r, 'probe', () => ++made)
+  assert.equal(ask(first), 1)
+  assert.equal(ask(first), 1)
+  assert.equal(derivedHeld(first, 'probe'), 1)
+  const field = first.fields.find(f => f.role !== 'state')!
+  session.apply([{ kind: 'set-design', input: field.id, unit: field.unit, value: field.value + 10 }])
+  assert.equal(derivedHeld(session.revisionNow()!, 'probe'), undefined)
+  assert.equal(ask(session.revisionNow()!), 2)
+})
+
+test('a version is readable while it is saved, and a save hands out the same text', async () => {
+  const session = await opened(arm)
+  const field = session.revisionNow()!.fields.find(f => f.role !== 'state')!
+  session.apply([{ kind: 'set-design', input: field.id, unit: field.unit, value: field.value + 10 }])
+  const before = session.revisionNow()!
+  const saving = session.save()
+  assert.ok(session.read().saving)
+  assert.equal(session.revisionNow(), before)
+  await saving
+  assert.equal(session.revisionNow()!.text, before.text)
+})
+
+/* Every question a selection asks of the version, as the editor and its panels ask them. */
+function selectionQuestions(shown: FigureRevision, part: string) {
+  const asset = shown.asset
+  const reach = gizmoReachOf(asset as never, part)
+  figureScaleAnchorOf(asset, part)
+  boxOf(shown, part)
+  gridStepOf(shown)
+  jointFanOf(shown, part)
+  partSummaryOf(asset, part, key => key, 'ko')
+  figureRoomOnlyInputsOf(asset, part)
+  for (const axis of ['x', 'y', 'z'] as const) measureNow(shown, part, axis)
+  for (const axis of ['x', 'z'] as const) canMirror(shown, part, axis, reach)
+  figurePlaneAlignChanges(asset, part)
+  figureFaceOverhangOf(asset, part, shown.inputs)
+  figurePartFaceOf(asset, part, 'top', shown.inputs)
+  figureRowOf(asset, part, shown.inputs)
+  fasteningOf(shown, part)
+  placeKeptOf(shown, part, 'plane')
+  myFaceFor(shown, part, 'plane', 'meet')
+  faceViewOf(shown, part, 'plane')
+  figureFigureFacts(shown)
+}
+
+test('selecting a part compiles nothing and evaluates nothing: every question is answered from the version', async () => {
+  const session = await opened(arm)
+  const shown = session.revisionNow()!
+  const parts = shown.geometry.map(g => g.id).filter(id => !id.startsWith('['))
+  const work = measureFigureWork(() => {
+    for (const part of parts) selectionQuestions(session.revisionNow()!, part)
+  })
+  assert.deepEqual([work.compiles, work.evaluations], [0, 0], `${parts.length} parts`)
+})
+
+test('the ends of a motion evaluate the figure at its two ends, and nothing is compiled', () => {
+  const shown = revisionOf(slide())
+  const work = measureFigureWork(() => motionEndsOf(shown, 'carriage'))
+  assert.ok(work.result, 'the carriage slides')
+  assert.deepEqual([work.compiles, work.evaluations], [0, 2])
+})
+
+/* A compile also evaluates the figure once (its stored values must run): three compiles, and the read's evaluation. */
+test('a value changed, read again as the next version, is three compiles at most: the edit, its read and its asset', async () => {
+  const session = await opened(arm)
+  const field = session.revisionNow()!.fields.find(f => f.role !== 'state')!
+  const parts = session.revisionNow()!.geometry.map(g => g.id).filter(id => !id.startsWith('['))
+  const work = measureFigureWork(() => {
+    session.apply([{ kind: 'set-design', input: field.id, unit: field.unit, value: field.value + 10 }])
+    session.read()
+    for (const part of parts) selectionQuestions(session.revisionNow()!, part)
+    session.source()
+  })
+  assert.ok(work.compiles <= 3, `compiles ${work.compiles}`)
+  assert.ok(work.evaluations <= 4, `evaluations ${work.evaluations}`)
+})
+
+/*
+ * The version is read as drawn: the pose set with the controls, which is also what a command sees (the workspace
+ * captures the live inputs before it runs one). Where the pose on screen differs from the saved one, fastening a part
+ * keeps it where it is drawn, and centring centres what is drawn (chief architect's ruling 2026-10-10).
+ */
+function slide(): FigureAsset {
+  let a = addFigureBox(createFigureAsset('Slide'), { id: 'rail', size: { x: 1000, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
+  a = addFigureBox(a, { id: 'carriage', size: { x: 200, y: 100, z: 200 }, position: { x: 0, y: 150, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'carriage', face: 'bottom', to: { part: 'rail', face: 'top' } })
+  a = moving(a, 'carriage', { kind: 'slide', axis: 'x', id: 'travel', min: 0, max: 400 })
+  return addFigureBox(a, { id: 'tag', size: { x: 50, y: 50, z: 50 }, position: { x: 300, y: 225, z: 0 } })
+}
+
+test('fastening keeps a part where it stands against what is drawn: a target moved by its control is met where it is now', () => {
+  const kept = (shown: FigureRevision) => placeKeptOf(shown, 'tag', { part: 'carriage', face: 'top' }).alignMm.x
+  assert.equal(kept(revisionOf(slide())), 300)
+  assert.equal(kept(revisionOf(slide(), { travel: 250 })), 50, 'the carriage drawn 250 along: the tag is 50 past its centre')
+  /* What the attach command then does, from the version as drawn: the tag does not jump. */
+  const shown = revisionOf(slide(), { travel: 250 })
+  const w = createFigureProductSession({ load: async id => ({ id, source: serializeFigureAsset(slide()) }), save: async r => ({ id: 'x', source: r.source }) })
+  return w.open('x').then(() => {
+    w.apply([{ kind: 'set-state', input: 'travel', unit: 'mm', value: 250 }])
+    const before = boxOf(w.revisionNow()!, 'tag')!.centre.x
+    w.command({ kind: 'attach', part: 'tag', face: 'bottom', to: { part: 'carriage', face: 'top' }, align: { x: { mm: placeKeptOf(shown, 'tag', { part: 'carriage', face: 'top' }).alignMm.x! } } })
+    assert.equal(Math.round(boxOf(w.revisionNow()!, 'tag')!.centre.x), Math.round(before))
+  })
+})
+
+test('centring reads the box as drawn', () => {
+  const drawn = revisionOf(slide(), { travel: 250 })
+  const box = boxOf(drawn, 'carriage')!
+  assert.equal(Math.round(box.centre.x), 250)
+  assert.equal(Math.round(boxOf(revisionOf(slide()), 'carriage')!.centre.x), 0)
+  /* The tag stands on its own numbers; centring it goes by where it is drawn, which for it is the same either way. */
+  const changes = alignChanges(drawn, 'tag', gizmoReachOf(drawn.asset as never, 'tag'), 'centre-x')
+  assert.deepEqual(changes.map(c => [c.input, c.value]), [['tag.position.x', 0]])
+})

package/test/section-editor.test.ts

@@ -14,6 +14,7 @@ import type { FigureAsset, FigureEvaluatedShape, FigureSectionPoint } from '@hat
 
 import { apexOver, extentOf, sectionOf as sectionOfWorking, workingIssuesOf as issuesOfWorking, workingOf as workingOfShape, insertAfter, issueWords, issuesOf, markedBy, movePoint, nextPointId, pointLabel, removePoint } from '../client/modeller/section-drawing.ts'
 import { livePartsOf } from '../client/modeller/live.ts'
+import { revisionOf } from './revision-of.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 /* A source file is a big string: a failing assert.match on it spends minutes building the diff and looks hung. */
@@ -162,13 +163,13 @@ test('치는 동안의 명령이 쓴 입력은 명령의 값으로 그린다 —
   const { liveOverSession } = await import('../client/modeller/live.ts')
   const t = triangle()
   const moved = pointsOf(t).map(p => (p.id === 'p3' ? { ...p, x: -30 } : p))
-  const drawn = liveOverSession(t, { ...t.designInputs }, { values: {}, action: { kind: 'set-section', part: 'wedge', points: moved } })!
+  const drawn = liveOverSession(revisionOf(t), { values: {}, action: { kind: 'set-section', part: 'wedge', points: moved } })!
   const wedge = drawn.find(p => p.id === 'wedge') as unknown as { shape: FigureEvaluatedShape }
   assert.equal((wedge.shape.extrusion!.section as { points: FigureSectionPoint[] }).points.find(p => p.id === 'p3')!.x, -30)
   /* Stage 1's corner, typed a second time: the radius drawn is the one typed, not the one applied before. */
   const { addFigureBox } = await import('@hatiolab/figure-model')
   const rounded = applyFigureAuthoring(addFigureBox(createFigureAsset('B'), { id: 'b', size: { x: 400, y: 100, z: 300 }, position: { x: 0, y: 50, z: 0 } }), { kind: 'set-section-corner', part: 'b', corner: 20 })
-  const again = liveOverSession(rounded, { ...rounded.designInputs }, { values: {}, action: { kind: 'set-section-corner', part: 'b', corner: 80 } })!
+  const again = liveOverSession(revisionOf(rounded), { values: {}, action: { kind: 'set-section-corner', part: 'b', corner: 80 } })!
   const b = again.find(p => p.id === 'b') as unknown as { shape: FigureEvaluatedShape }
   assert.deepEqual((b.shape.extrusion!.section as { corner: unknown }).corner, { x: 80, z: 80 })
 })
@@ -327,7 +328,7 @@ test('편집 창에서 끝을 한 점으로: 켜면 점들의 가운데 위에
 })
 
 test('끝면에 붙은 부품이 있으면 한 점으로 모으기를 막고 그 면을 말한다 — 커널의 거절로 판정한다', () => {
-  has(editor, /this\.session\.previewCommand\(\{ kind: 'set-section', part: this\.selected!, apex: apexOver\(drawn\.section\.points, drawn\.axis\) \}\)/)
+  has(editor, /const apex = apexOver\(drawn\.section\.points, drawn\.axis\)[\s\S]*?session\.previewCommand\(\{ kind: 'set-section', part, apex \}\)/)
   has(editor, /\.code === 'FEATURE_MAPPING_REQUIRED'\)/)
   has(editorPanel, /const blocked = !apex && !this\.opened\?\.apex \? this\.pointBlocked : ''/)
   has(editorPanel, /\?disabled=\$\{!!blocked\}/)

package/test/section-panel.test.ts

@@ -24,6 +24,7 @@ import {
 } from '../client/modeller/section-controls.ts'
 import { livePartsOf } from '../client/modeller/live.ts'
 import { editRefusalOf } from '../client/modeller/refusals.ts'
+import { revisionOf } from './revision-of.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 /* A source file is a big string: a failing assert.match on it spends minutes building the diff and looks hung. */
@@ -171,10 +172,10 @@ test('치는 동안 그려진 도형이 칸의 글자를 덮어쓰지 않는다
 test('면마다 벽 두께를 치는 동안에도 그려진다 — 명령이 없앤 입력(한 벽 두께)의 지금 값은 미리보기를 막지 않는다', async () => {
   const { liveOverSession } = await import('../client/modeller/live.ts')
   const tray = applyFigureAuthoring(probe(), { kind: 'set-cavity', part: 'body', cavity: { wall: 30, start: { closed: 30 }, end: 'open' } })
-  /* The editor draws over every value as it stands: the one wall is among them. */
-  const current = { ...tray.designInputs }
-  assert.ok('body.dimension.wall' in current)
-  const drawn = liveOverSession(tray, current, {
+  /* The editor draws over every value of the version as it stands: the one wall is among them. */
+  const shown = revisionOf(tray)
+  assert.ok('body.dimension.wall' in shown.inputs)
+  const drawn = liveOverSession(shown, {
     values: {},
     action: { kind: 'set-cavity', part: 'body', cavity: { wall: { 'x-': 100, 'x+': 30, 'z-': 30, 'z+': 30 }, start: { closed: 30 }, end: 'open' } }
   })

package/test/verdict.test.ts

@@ -62,7 +62,7 @@ test('판정 탭은 발행 패널과 같은 두 판정에 「부품에 맞추기
 
 test('판정과 이력은 편집기의 탭에 서고, 감추되 떼지 않는다', () => {
   const editor = read('../client/modeller/editor.ts')
-  assert.ok(/<figure-verdict[\s\S]*?\.source=\$\{this\.draftSource\(\)\}/.test(page), '편집 중인 원본을 넘긴다')
+  assert.ok(/<figure-verdict[\s\S]*?\.revision=\$\{this\.session\.revisionNow\(\)\}/.test(page), '편집 중인 원본을 넘긴다')
   assert.ok(/<figure-verdict[\s\S]*?\.figureType=/.test(page), '타입을 바꾸면 다시 판정한다')
   assert.ok(/<figure-verdict\s+slot="verdict"/.test(page) && /<figure-history-panel\s+slot="history"/.test(page))
   assert.ok(editor.includes(`<div panel flush ?off=\${tab !== 'verdict'}><slot name="verdict"></slot></div>`), '고르지 않은 탭은 감춘다 — 판정은 마지막 답을 지킨다')