@things-factory/figure-ui 10.1.74 → 10.1.76

package/test/{v3-links.test.ts → links.test.ts}

@@ -1,5 +1,5 @@
 /*
- * **V3 부품이 무엇에 묶여 있나 — 크기 따르기 · 붙이기 · 움직임** (2026-09-24).
+ * **부품이 무엇에 묶여 있나 — 크기 따르기 · 붙이기 · 움직임** (2026-09-24).
  *
  * 세 칸이 보여 주는 것은 figure-model 명령이 남긴 그래프를 거꾸로 읽은 것이다. 명령을 실제로 적용한 뒤 읽어서,
  * 화면이 명령과 같은 말을 하는지 잰다.
@@ -7,15 +7,15 @@
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { addV3Box, addV3Primitive, applyV3Authoring, createV3Asset } from '@hatiolab/figure-model'
-import type { V3Asset } from '@hatiolab/figure-model'
+import { addFigureBox, addFigurePrimitive, applyFigureAuthoring, createFigureAsset } from '@hatiolab/figure-model'
+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/v3-links.ts'
+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'
 
-const pair = (): V3Asset => {
-  let asset = createV3Asset('Pair')
-  asset = addV3Box(asset, { id: 'plate', size: { x: 600, y: 100, z: 400 }, position: { x: 0, y: 50, z: 0 } })
-  asset = addV3Box(asset, { id: 'block', size: { x: 200, y: 60, z: 120 }, position: { x: 0, y: 130, z: 0 } })
+const pair = (): FigureAsset => {
+  let asset = createFigureAsset('Pair')
+  asset = addFigureBox(asset, { id: 'plate', size: { x: 600, y: 100, z: 400 }, position: { x: 0, y: 50, z: 0 } })
+  asset = addFigureBox(asset, { id: 'block', size: { x: 200, y: 60, z: 120 }, position: { x: 0, y: 130, z: 0 } })
   const model = asset.document.model
   for (const axis of ['x', 'y', 'z']) {
     model.inputs.push({ id: `size.${axis}`, unit: 'mm', min: 100, max: 20000, role: 'design' } as never)
@@ -27,23 +27,23 @@ const pair = (): V3Asset => {
 test('크기 — 제 치수 · 인스턴스 크기 · 다른 부품의 치수를 가려 읽는다', () => {
   const asset = pair()
   assert.deepEqual(followOf(asset, 'plate', 'x'), { of: 'own' })
-  const byInstance = applyV3Authoring(asset, { kind: 'link-dimension', part: 'plate', axis: 'x', source: { of: 'instance', axis: 'x' } })
+  const byInstance = applyFigureAuthoring(asset, { kind: 'link-dimension', part: 'plate', axis: 'x', source: { of: 'instance', axis: 'x' } })
   assert.deepEqual(followOf(byInstance, 'plate', 'x'), { of: 'instance', axis: 'x', times: 1 })
-  const byPart = applyV3Authoring(byInstance, { kind: 'link-dimension', part: 'block', axis: 'x', source: { of: 'part', part: 'plate', axis: 'x' }, times: 0.5 })
+  const byPart = applyFigureAuthoring(byInstance, { kind: 'link-dimension', part: 'block', axis: 'x', source: { of: 'part', part: 'plate', axis: 'x' }, times: 0.5 })
   assert.deepEqual(followOf(byPart, 'block', 'x'), { of: 'part', part: 'plate', axis: 'x', times: 0.5 }, '배율이 끼어도 원천을 찾고, 배율도 읽는다')
-  const back = applyV3Authoring(byPart, { kind: 'unlink-dimension', part: 'block', axis: 'x', mm: 300 })
+  const back = applyFigureAuthoring(byPart, { kind: 'unlink-dimension', part: 'block', axis: 'x', mm: 300 })
   assert.deepEqual(followOf(back, 'block', 'x'), { of: 'own' }, '떼면 다시 제 치수')
   assert.equal(hasInstanceSize(asset, 'y'), true)
-  assert.equal(hasInstanceSize(createV3Asset('Bare'), 'y'), false)
+  assert.equal(hasInstanceSize(createFigureAsset('Bare'), 'y'), false)
 })
 
 test('붙이기 — 누구에게 붙었나, 붙일 수 있는 모양인가', () => {
   const asset = pair()
   assert.equal(fastenedTo(asset, 'block'), null)
-  const fastened = applyV3Authoring(asset, { kind: 'attach', part: 'block', face: 'bottom', to: { part: 'plate', face: 'top' } })
+  const fastened = applyFigureAuthoring(asset, { kind: 'attach', part: 'block', face: 'bottom', to: { part: 'plate', face: 'top' } })
   assert.equal(fastenedTo(fastened, 'block'), 'plate')
-  assert.equal(fastenedTo(applyV3Authoring(fastened, { kind: 'detach', part: 'block' }), 'block'), null)
-  const withDrum = addV3Primitive(asset, { id: 'drum', kind: 'cylinder', dimensions: { radius: 50, length: 100 }, position: { x: 0, y: 50, z: 0 } })
+  assert.equal(fastenedTo(applyFigureAuthoring(fastened, { kind: 'detach', part: 'block' }), 'block'), null)
+  const withDrum = addFigurePrimitive(asset, { id: 'drum', kind: 'cylinder', dimensions: { radius: 50, length: 100 }, position: { x: 0, y: 50, z: 0 } })
   assert.equal(canFasten(withDrum, 'block'), true)
   assert.equal(canFasten(withDrum, 'drum'), true, '원기둥도 면으로 붙인다(figure-model 0.1.47)')
   assert.equal(canFollow(withDrum, 'drum'), true, '원기둥은 반지름(X)과 길이(Y)를 따를 수 있다')
@@ -62,13 +62,13 @@ test('움직임 — 미끄러짐 · 돌기, 축, 무엇이 모느냐를 읽는
   const turning = moving(asset, 'block', { kind: 'turn', axis: 'y', id: 'swing', min: -90, max: 90, start: 0 })
   assert.deepEqual([motionOf(turning, 'block')!.kind, motionOf(turning, 'block')!.axis], ['turn', 'y'])
   const joint = sliding.joints!.find(j => j.body1.part === 'block')!
-  const still = applyV3Authoring(sliding, { kind: 'set-joint', joint: { id: joint.id, type: 'fixed', body0: joint.body0, body1: joint.body1 } })
+  const still = applyFigureAuthoring(sliding, { kind: 'set-joint', joint: { id: joint.id, type: 'fixed', body0: joint.body0, body1: joint.body1 } })
   assert.equal(motionOf(still, 'block'), undefined, 'a fixed joint does not move')
 })
 
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
-import { choiceOf } from '../client/modeller/v3-links.ts'
+import { choiceOf } from '../client/modeller/links.ts'
 import { moving } from './joints.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
@@ -81,21 +81,21 @@ test('고르개의 값은 지금 따르는 것을 가리킨다', () => {
 })
 
 test('편집기는 세 칸의 명령을 세션의 이력 하나로 돌리고, 만날 수 있는 거절을 사람의 말로 한다', () => {
-  const editor = read('../client/modeller/v3-editor.ts')
-  assert.match(editor, /@v3-command=\$\{\(e: CustomEvent\) => this\.linkCommand\(e\.detail\.action\)\}/)
+  const editor = read('../client/modeller/editor.ts')
+  assert.match(editor, /@command=\$\{\(e: CustomEvent\) => this\.linkCommand\(e\.detail\.action\)\}/)
   assert.match(editor, /this\.session!\.command\(action\)/)
   assert.match(editor, /code === 'DIMENSION_CYCLE'[\s\S]*?figure\.text\.follow-would-loop/)
   assert.match(editor, /code === 'ATTACH_CYCLE'[\s\S]*?figure\.text\.fasten-would-loop/)
 })
 
 test('떼면 지금 크기로 고정한다 — 따르던 값을 잃지 않는다', () => {
-  const links = read('../client/modeller/figure-v3-links.ts')
+  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'))
 })
 
 test('세 칸의 말은 다섯 말 모두에 있다', () => {
-  const links = read('../client/modeller/figure-v3-links.ts')
+  const links = read('../client/modeller/figure-links.ts')
   const keys = [...links.matchAll(/'(figure\.[a-z.-]*[a-z])'/g)].map(m => m[1])
   for (const lang of ['ko', 'en', 'ja', 'zh', 'ms']) {
     const table = JSON.parse(read(`../translations/${lang}.json`))
@@ -106,25 +106,25 @@ test('세 칸의 말은 다섯 말 모두에 있다', () => {
 
 test('도형 크기를 따라 움직이는 자리를 가려 읽고, 여기에 고정하면 사라진다 — 드라이룸 램프의 길', () => {
   let asset = pair()
-  asset = addV3Box(asset, { id: 'lamp', size: { x: 40, y: 20, z: 40 }, position: { x: 0, y: 10, z: 0 } })
+  asset = addFigureBox(asset, { id: 'lamp', size: { x: 40, y: 20, z: 40 }, position: { x: 0, y: 10, z: 0 } })
   const model = asset.document.model
   model.nodes.push({ id: 'lamp.lift', op: 'add@1', args: ['size.y', 'lamp.position.y'], outputs: { value: 'lamp.lift.value' } } as never)
   model.nodes.find(n => n.id === 'lamp.pose')!.args[1] = 'lamp.lift.value'
   assert.deepEqual(positionsWorkedOut(asset, 'lamp'), ['y'])
   assert.deepEqual(positionsWorkedOut(asset, 'plate'), [], '제 숫자로 놓인 부품에는 없다')
-  const fixed = applyV3Authoring(asset, { kind: 'fix-position', part: 'lamp', axis: 'y' })
+  const fixed = applyFigureAuthoring(asset, { kind: 'fix-position', part: 'lamp', axis: 'y' })
   assert.deepEqual(positionsWorkedOut(fixed, 'lamp'), [])
   assert.equal(fixed.designInputs['lamp.position.y'], 110, '지금 자리 그대로 — 100 + 10')
 })
 
 test('자리 — 부품의 면에 둔 집는 자리·놓는 자리를 그 부품에서 읽는다', () => {
   let asset = pair()
-  asset = addV3Primitive(asset, { id: 'drum', kind: 'cylinder', dimensions: { radius: 100, length: 300 }, position: { x: 0, y: 400, z: 0 } } as never)
+  asset = addFigurePrimitive(asset, { id: 'drum', kind: 'cylinder', dimensions: { radius: 100, length: 300 }, position: { x: 0, y: 400, z: 0 } } as never)
   assert.deepEqual(placeFacesOf(asset, 'block'), ['left', 'right', 'bottom', 'top', 'back', 'front'])
   assert.deepEqual(placeFacesOf(asset, 'drum'), [], '둥근 몸에는 자리를 권하지 않는다 — 명령이 거절할 것이다')
 
   assert.equal(placeIdFor(asset, 'block', 'grip'), 'block-grip')
-  asset = applyV3Authoring(asset, { kind: 'add-binding', id: placeIdFor(asset, 'block', 'grip'), label: '집는 자리', role: 'grip', part: 'block', face: 'top', accepts: acceptsOf(' BOX, TOTE,, BOX '), capacity: 2 })
+  asset = applyFigureAuthoring(asset, { kind: 'add-binding', id: placeIdFor(asset, 'block', 'grip'), label: '집는 자리', role: 'grip', part: 'block', face: 'top', accepts: acceptsOf(' BOX, TOTE,, BOX '), capacity: 2 })
   assert.equal(placeIdFor(asset, 'block', 'grip'), 'block-grip-2', '같은 부품에 둘째 자리는 다른 id')
   assert.deepEqual(
     placesOn(asset, 'block').map(p => [p.id, p.role, p.face, p.accepts, p.capacity]),
@@ -141,18 +141,18 @@ test('담는 능력이 없는 도형은 자리가 있어도 보드가 아무것
   asset.document.capabilities.names = ['FlowNode']
   assert.equal(holdsThings(asset), true, 'FlowNode 는 Capacity 를 품는다')
 
-  const links = read('../client/modeller/figure-v3-links.ts')
+  const links = read('../client/modeller/figure-links.ts')
   assert.match(links, /holdsThings\(asset\)/)
   assert.match(links, /kind: 'set-capabilities', names/)
-  const editor = read('../client/modeller/v3-editor.ts')
+  const editor = read('../client/modeller/editor.ts')
   /* A slice and `includes`, not a lazy regex over the whole editor: that hangs when it does not match. */
-  const start = editor.indexOf('<figure-v3-links')
-  const block = editor.slice(start, editor.indexOf('</figure-v3-links>', start))
-  assert.ok(start >= 0 && block.includes('@v3-part-edit=${(e: CustomEvent) => this.run(() => this.session!.edit(e.detail.edit))}'), '자리 절의 능력 선언이 편집기에 닿는다')
+  const start = editor.indexOf('<figure-links')
+  const block = editor.slice(start, editor.indexOf('</figure-links>', start))
+  assert.ok(start >= 0 && block.includes('@part-edit=${(e: CustomEvent) => this.run(() => this.session!.edit(e.detail.edit))}'), '자리 절의 능력 선언이 편집기에 닿는다')
 })
 
 test('받는 종류가 없으면 자리를 만들지 않는다 — 형식에 「아무거나」가 없다', () => {
-  const links = read('../client/modeller/figure-v3-links.ts')
+  const links = read('../client/modeller/figure-links.ts')
   assert.match(links, /\?disabled=\$\{this\.locked \|\| !accepts\.length \|\| !capacityOk\}/)
   assert.deepEqual(acceptsOf(' , ,'), [])
 })
@@ -160,9 +160,9 @@ test('받는 종류가 없으면 자리를 만들지 않는다 — 형식에 「
 /* ── Proportional rules (user 2026-09-24: ROBOT_ARM at twice the size looked broken) ───────────── */
 
 const sizedPair = () => {
-  let asset = createV3Asset('Probe')
-  asset = addV3Box(asset, { id: 'base', size: { x: 200, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
-  asset = addV3Primitive(asset, { id: 'flange', kind: 'cylinder', dimensions: { radius: 20, length: 10 }, position: { x: 0, y: 95, z: 0 } })
+  let asset = createFigureAsset('Probe')
+  asset = addFigureBox(asset, { id: 'base', size: { x: 200, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
+  asset = addFigurePrimitive(asset, { id: 'flange', kind: 'cylinder', dimensions: { radius: 20, length: 10 }, position: { x: 0, y: 95, z: 0 } })
   asset.document.model.inputs.push({ id: 'size.y', unit: 'mm', min: 1, max: 20000, role: 'design' } as never)
   asset.designInputs['size.y'] = 100
   return asset
@@ -172,7 +172,7 @@ test('비례 — 인스턴스 크기의 몫을 따르는 치수는 비례로 읽
   const asset = sizedPair()
   assert.equal(dimensionNow(asset, 'flange', 'y'), 10, '원기둥의 Y 는 길이')
   assert.equal(dimensionNow(asset, 'flange', 'x'), 20, '원기둥의 X 는 반지름')
-  const share = applyV3Authoring(asset, { kind: 'link-dimension', part: 'flange', axis: 'y', source: { of: 'instance', axis: 'y' }, times: 0.1 })
+  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 })
 
   /* A span: the size less what the others take -- a sum, not a share (ROBOT_ARM's tool flange). */
@@ -183,7 +183,7 @@ test('비례 — 인스턴스 크기의 몫을 따르는 치수는 비례로 읽
   m.nodes.push({ id: 'flange.dimension.y', op: 'mul@1', args: ['flange.free.value', m.constants.find(c => c.value === 1)?.id ?? 'k.one'], outputs: { value: 'flange.dimension.y.value' } })
   if (!m.constants.some(c => c.value === 1)) m.constants.push({ id: 'k.one', unit: 'ratio', value: 1 })
   /* Read as what it is since the plus is read (2026-09-25): the size less 90 -- following the size, not a share of it. */
-  assert.deepEqual(followOf(fill as V3Asset, 'flange', 'y'), { of: 'instance', axis: 'y', times: 1, plus: -90 })
+  assert.deepEqual(followOf(fill as FigureAsset, 'flange', 'y'), { of: 'instance', axis: 'y', times: 1, plus: -90 })
 
   /* Before any link the shape reads the measure directly; a worked-out one there is not 「고정」 (ROBOT_ARM on :3300). */
   const direct = structuredClone(asset)
@@ -191,23 +191,23 @@ test('비례 — 인스턴스 크기의 몫을 따르는 치수는 비례로 읽
   d.constants.push({ id: 'k.gaps', unit: 'mm', value: -90 })
   d.nodes.push({ id: 'flange.free', op: 'add@1', args: ['size.y', 'k.gaps'], outputs: { value: 'flange.free.value' } })
   d.nodes.find(n => n.id === 'flange.shape')!.args[1] = 'flange.free.value'
-  assert.deepEqual(followOf(direct as V3Asset, 'flange', 'y'), { of: 'expression' })
+  assert.deepEqual(followOf(direct as FigureAsset, 'flange', 'y'), { of: 'expression' })
   assert.deepEqual(followOf(asset, 'flange', 'y'), { of: 'own' }, '제 숫자는 고정')
 })
 
 test('자리를 크기에 비례로 두면 그렇게 읽고, 다시 권하지 않는다', () => {
   let asset = sizedPair()
-  asset = applyV3Authoring(asset, { kind: 'scale-position', part: 'flange', axis: 'y' })
+  asset = applyFigureAuthoring(asset, { kind: 'scale-position', part: 'flange', axis: 'y' })
   assert.equal(positionIsShare(asset, 'flange', 'y'), true)
   assert.equal(positionIsShare(asset, 'base', 'y'), false)
-  const links = read('../client/modeller/figure-v3-links.ts')
+  const links = read('../client/modeller/figure-links.ts')
   assert.ok(links.includes("hasInstanceSize(asset, axis) && !positionIsShare(asset, this.partId, axis)"))
   assert.ok(links.includes("this.command({ kind: 'scale-position', part: this.partId, axis })"))
   assert.ok(links.includes("const times = Math.round((current / size) * 1e6) / 1e6"), '비례는 지금 치수의 몫')
 })
 
 test('놓일 수 있는 크기 — 남은 만큼 채우던 부품을 비례로 바꾸면 다시 재어 넓힌다', () => {
-  assert.equal(instanceRangeOf(createV3Asset('Probe')), undefined, '크기를 선언하지 않은 도형에는 범위가 없다')
+  assert.equal(instanceRangeOf(createFigureAsset('Probe')), undefined, '크기를 선언하지 않은 도형에는 범위가 없다')
   let asset = sizedPair()
   for (const axis of ['x', 'z'] as const) {
     asset.document.model.inputs.push({ id: `size.${axis}`, unit: 'mm', min: 1, max: 20000, role: 'design' } as never)
@@ -220,9 +220,9 @@ test('놓일 수 있는 크기 — 남은 만큼 채우던 부품을 비례로
   assert.deepEqual(range.declared.y, { min: 90, max: 1000 })
   assert.deepEqual(range.measured.y, { min: 1, max: 1000 }, '기본 범위: 1 mm 에서 열 배')
   assert.equal(rangeDiffers(range.declared, range.measured), true)
-  asset = applyV3Authoring(asset, { kind: 'declare-instance-size', range: range.measured, replace: true })
+  asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: range.measured, replace: true })
   assert.equal(rangeDiffers(instanceRangeOf(asset)!.declared, instanceRangeOf(asset)!.measured), false, '다시 재면 같다')
-  const editor = read('../client/modeller/v3-editor.ts')
+  const editor = read('../client/modeller/editor.ts')
   assert.ok(editor.includes("this.linkCommand({ kind: 'declare-instance-size', range: range.measured, replace: true })"))
 })
 
@@ -237,30 +237,30 @@ test('놓일 수 있는 크기 — 저작자가 끝을 적어 좁힌다(갠트
   const next = rangeWith(declared, 'x', 'min', 150)!
   assert.deepEqual(next.x, { min: 150, max: 20000 })
   assert.deepEqual(declared.x, { min: 1, max: 20000 }, '선언된 범위는 그대로')
-  asset = applyV3Authoring(asset, { kind: 'declare-instance-size', range: next, replace: true })
+  asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: next, replace: true })
   assert.deepEqual(instanceRangeOf(asset)!.declared.x, { min: 150, max: 20000 })
-  assert.throws(() => applyV3Authoring(asset, { kind: 'declare-instance-size', range: rangeWith(next, 'x', 'min', 300)!, replace: true }), (e: { code?: string }) => e.code === 'INSTANCE_SIZE_RANGE', '저작한 크기(200)를 벗어나면 거절')
-  const editor = read('../client/modeller/v3-editor.ts')
+  assert.throws(() => applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: rangeWith(next, 'x', 'min', 300)!, replace: true }), (e: { code?: string }) => e.code === 'INSTANCE_SIZE_RANGE', '저작한 크기(200)를 벗어나면 거절')
+  const editor = read('../client/modeller/editor.ts')
   assert.ok(editor.includes("const next = rangeWith(range.declared, axis, bound, (e.target as HTMLInputElement).valueAsNumber)"))
   assert.ok(editor.includes("if (next) this.linkCommand({ kind: 'declare-instance-size', range: next, replace: true })"))
 })
 
 test('한 비율로 커지는 도형 — 자기 숫자인 길이를 세고, 한 번에 따라가게 하며, 무엇이 남는지 이름을 댄다(아키텍트 판정 09-25)', () => {
-  let asset = createV3Asset('Probe')
-  asset = addV3Box(asset, { id: 'base', size: { x: 400, y: 100, z: 400 }, position: { x: 0, y: 0, z: 0 } })
-  asset = addV3Box(asset, { id: 'lamp', size: { x: 60, y: 60, z: 60 }, position: { x: 0, y: 0, z: 0 } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'base', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'lamp', face: 'bottom', to: { part: 'base', face: 'top' }, align: { x: { mm: 120 } } })
-  asset = applyV3Authoring(asset, { kind: 'declare-instance-size', range: { x: { min: 40, max: 4000 }, y: { min: 16, max: 1600 }, z: { min: 40, max: 4000 } } })
+  let asset = createFigureAsset('Probe')
+  asset = addFigureBox(asset, { id: 'base', size: { x: 400, y: 100, z: 400 }, position: { x: 0, y: 0, z: 0 } })
+  asset = addFigureBox(asset, { id: 'lamp', size: { x: 60, y: 60, z: 60 }, position: { x: 0, y: 0, z: 0 } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'base', face: 'bottom', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'lamp', face: 'bottom', to: { part: 'base', face: 'top' }, align: { x: { mm: 120 } } })
+  asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: { x: { min: 40, max: 4000 }, y: { min: 16, max: 1600 }, z: { min: 40, max: 4000 } } })
   assert.equal(proportionToFollow(asset), undefined, '한 비율이 아니면 권하지 않는다')
-  asset = applyV3Authoring(asset, { kind: 'scale-uniformly' })
+  asset = applyFigureAuthoring(asset, { kind: 'scale-uniformly' })
   assert.deepEqual(proportionToFollow(asset), { count: 3 + 3 + 1, kept: [] }, '치수 여섯과 자리 하나')
   const lamp = asset.joints!.find(j => j.id === 'lamp')!
-  asset = applyV3Authoring(asset, { kind: 'set-joint', joint: { ...lamp, type: 'prismatic', axis: 'Y', lowerLimit: 0, upperLimit: 50, state: { id: 'rise' } } })
-  asset = applyV3Authoring(asset, { kind: 'follow-size-in-proportion' })
+  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, '따르게 해도 지금 크기는 그대로')
-  const editor = read('../client/modeller/v3-editor.ts')
+  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])"), '길이를 따르는 간격도 숫자로 보인다')
 })
@@ -270,7 +270,7 @@ test('관절이 있는 도형에는 한 비율로 키우기를 권하고, 선언
   assert.equal(turnsAboutAJoint(asset), false)
   asset = moving(asset, 'flange', { kind: 'turn', axis: 'y', id: 'flange.turn', min: 0, max: 90 })
   assert.equal(turnsAboutAJoint(asset), true)
-  const editor = read('../client/modeller/v3-editor.ts')
+  const editor = read('../client/modeller/editor.ts')
   const rule = editor.slice(editor.indexOf('  private renderSizingRule('), editor.indexOf('  /** Choose a part,'))
   assert.ok(rule.includes("asset.sizing === 'uniform'") && rule.includes("'figure.label.sizing-uniform'"), '선언하면 규칙을 말한다')
   assert.ok(rule.includes("turnsAboutAJoint(asset) ? html`<p hint>${i18next.t('figure.text.sizing-uniform-proposed')}"), '관절이 있으면 권한다')
@@ -279,10 +279,10 @@ test('관절이 있는 도형에는 한 비율로 키우기를 권하고, 선언
 
 
 test('붙일 때 면 위 어디에 — 그 면을 가로지르는 두 축만, 바닥에는 모서리가 없다 (문을 틀 모서리에 달기, 09-25)', async () => {
-  const { alignAxesOf, alignOf } = await import('../client/modeller/v3-links.ts')
-  let two = createV3Asset('Two')
-  two = addV3Box(two, { id: 'jamb', size: { x: 100, y: 2100, z: 150 }, position: { x: 0, y: 1050, z: 0 } })
-  two = addV3Box(two, { id: 'leaf', size: { x: 900, y: 2000, z: 40 }, position: { x: 600, y: 1000, z: 0 } })
+  const { alignAxesOf, alignOf } = await import('../client/modeller/links.ts')
+  let two = createFigureAsset('Two')
+  two = addFigureBox(two, { id: 'jamb', size: { x: 100, y: 2100, z: 150 }, position: { x: 0, y: 1050, z: 0 } })
+  two = addFigureBox(two, { id: 'leaf', size: { x: 900, y: 2000, z: 40 }, position: { x: 600, y: 1000, z: 0 } })
   const right = { part: 'jamb', face: 'right' }
   assert.deepEqual(alignAxesOf(two, 'leaf', right), [{ axis: 'y', edges: true }, { axis: 'z', edges: true }])
   assert.deepEqual(alignAxesOf(two, 'leaf', 'plane'), [{ axis: 'x', edges: false }, { axis: 'z', edges: false }])
@@ -293,63 +293,63 @@ test('붙일 때 면 위 어디에 — 그 면을 가로지르는 두 축만,
   assert.equal(alignOf(two, 'leaf', { part: 'jamb', face: 'top' }, {}, {}), undefined)
 
   /* What the form sends is what hangs the part on the edge: the door's pivot is on the jamb's front edge line. */
-  let asset = createV3Asset('Door')
-  asset = addV3Box(asset, { id: 'jamb', size: { x: 100, y: 2100, z: 150 }, position: { x: 0, y: 1050, z: 0 } })
-  asset = addV3Box(asset, { id: 'leaf', size: { x: 900, y: 2000, z: 40 }, position: { x: 600, y: 1000, z: 0 } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'jamb', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'leaf', face: 'left', to: { part: 'jamb', face: 'right' }, align: alignOf(asset, 'leaf', { part: 'jamb', face: 'right' }, { y: 'min', z: 'max' }, {}) })
-  const { compileV3Asset } = await import('@hatiolab/figure-model')
-  const leaf = compileV3Asset(asset).evaluate().geometry.find(g => g.id === 'leaf')!
+  let asset = createFigureAsset('Door')
+  asset = addFigureBox(asset, { id: 'jamb', size: { x: 100, y: 2100, z: 150 }, position: { x: 0, y: 1050, z: 0 } })
+  asset = addFigureBox(asset, { id: 'leaf', size: { x: 900, y: 2000, z: 40 }, position: { x: 600, y: 1000, z: 0 } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'jamb', face: 'bottom', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'leaf', face: 'left', to: { part: 'jamb', face: 'right' }, align: alignOf(asset, 'leaf', { part: 'jamb', face: 'right' }, { y: 'min', z: 'max' }, {}) })
+  const { compileFigureAsset } = await import('@hatiolab/figure-model')
+  const leaf = compileFigureAsset(asset).evaluate().geometry.find(g => g.id === 'leaf')!
   assert.deepEqual(leaf.pose.t.map(Math.round), [500, 1000, 55], '문짝 아래가 문틀 아래에, 앞이 문틀 앞에')
 })
 
 test('붙여도 제자리 — 폼은 지금 서 있는 자리를 가운데서 거리로 채운다 (문짝이 문틀 앞 100 mm 에서 가운데로 옮겨졌다, 09-26)', async () => {
-  const { alignOf, placeKeptOf } = await import('../client/modeller/v3-links.ts')
-  const { compileV3Asset } = await import('@hatiolab/figure-model')
-  let asset = createV3Asset('Door')
-  asset = addV3Box(asset, { id: 'frame', size: { x: 1600, y: 100, z: 150 }, position: { x: 300, y: 50, z: 0 } })
-  asset = addV3Box(asset, { id: 'leaf', size: { x: 1400, y: 2200, z: 40 }, position: { x: 250, y: 1100, z: 100 } })
-  const where = (a: V3Asset) => compileV3Asset(a).evaluate().geometry.find(g => g.id === 'leaf')!.pose.t.map(v => Math.round(v))
+  const { alignOf, placeKeptOf } = await import('../client/modeller/links.ts')
+  const { compileFigureAsset } = await import('@hatiolab/figure-model')
+  let asset = createFigureAsset('Door')
+  asset = addFigureBox(asset, { id: 'frame', size: { x: 1600, y: 100, z: 150 }, position: { x: 300, y: 50, z: 0 } })
+  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 align = alignOf(asset, 'leaf', target, kept.align, kept.alignMm)
     const to = target === 'plane' ? { plane: 'mounting-plane' as const } : target
-    const fastened = applyV3Authoring(asset, { kind: 'attach', part: 'leaf', face: 'bottom', to, ...(align ? { align } : {}) } as never)
+    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 } })
-  const centred = addV3Box(createV3Asset('C'), { id: 'a', size: { x: 10, y: 10, z: 10 }, position: { x: 0, y: 5, z: 0 } })
+  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: {} }, '가운데 있던 것은 가운데로')
 
   /* 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/v3-links.ts')
-  let row = addV3Box(createV3Asset('Row'), { id: 'plate', size: { x: 1000, y: 50, z: 400 }, position: { x: 0, y: 700, z: 0 } })
-  row = addV3Box(row, { id: 'roller', size: { x: 60, y: 60, z: 400 }, position: { x: 0, y: 760, z: 0 } })
-  row = addV3Box(row, { id: 'cap', size: { x: 20, y: 20, z: 20 }, position: { x: 0, y: 800, z: 0 } })
-  row = applyV3Authoring(row, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'plate', face: 'top' } })
-  row = applyV3Authoring(row, { kind: 'attach', part: 'cap', face: 'bottom', to: { part: 'roller', face: 'top' } })
+  const { hangsFrom } = await import('../client/modeller/links.ts')
+  let row = addFigureBox(createFigureAsset('Row'), { id: 'plate', size: { x: 1000, y: 50, z: 400 }, position: { x: 0, y: 700, z: 0 } })
+  row = addFigureBox(row, { id: 'roller', size: { x: 60, y: 60, z: 400 }, position: { x: 0, y: 760, z: 0 } })
+  row = addFigureBox(row, { id: 'cap', size: { x: 20, y: 20, z: 20 }, position: { x: 0, y: 800, z: 0 } })
+  row = applyFigureAuthoring(row, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'plate', face: 'top' } })
+  row = applyFigureAuthoring(row, { kind: 'attach', part: 'cap', face: 'bottom', to: { part: 'roller', face: 'top' } })
   assert.deepEqual([hangsFrom(row, 'roller', 'plate'), hangsFrom(row, 'cap', 'plate'), hangsFrom(row, 'plate', 'roller')], [true, true, false])
-  const form = read('../client/modeller/figure-v3-links.ts')
+  const form = read('../client/modeller/figure-links.ts')
   assert.equal(form.match(/this\.aimAt\(asset, \{ \.\.\.f, (toPlane|target|targetFace):/g)?.length, 3, '바닥 · 상대 부품 · 상대 면을 바꿀 때마다')
   assert.ok(form.includes('!hangsFrom(asset, one, this.partId)'))
 })
 
 test('따라 움직이는 관절 — 같은 방식으로 움직이고 제 조작값이 있는 관절만 고르고, 기록에는 배율과 더하기만 (집게 두 손가락, 09-25)', async () => {
-  const { leadersFor, motionJoint } = await import('../client/modeller/v3-links.ts')
-  const { compileV3Asset } = await import('@hatiolab/figure-model')
-  let asset = createV3Asset('Gripper')
-  asset = addV3Box(asset, { id: 'palm', size: { x: 240, y: 70, z: 160 }, position: { x: 0, y: 35, z: 0 } })
-  for (const id of ['left', 'right']) asset = addV3Box(asset, { id, size: { x: 30, y: 140, z: 100 }, position: { x: 0, y: 200, z: 0 } })
-  asset = addV3Box(asset, { id: 'wrist', size: { x: 60, y: 60, z: 60 }, position: { x: 0, y: 400, z: 0 } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'palm', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'left', face: 'bottom', to: { part: 'palm', face: 'top' }, align: { x: 'min' } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'right', face: 'bottom', to: { part: 'palm', face: 'top' }, align: { x: 'max' } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'wrist', face: 'top', to: { part: 'palm', face: 'bottom' } })
+  const { leadersFor, motionJoint } = await import('../client/modeller/links.ts')
+  const { compileFigureAsset } = await import('@hatiolab/figure-model')
+  let asset = createFigureAsset('Gripper')
+  asset = addFigureBox(asset, { id: 'palm', size: { x: 240, y: 70, z: 160 }, position: { x: 0, y: 35, z: 0 } })
+  for (const id of ['left', 'right']) asset = addFigureBox(asset, { id, size: { x: 30, y: 140, z: 100 }, position: { x: 0, y: 200, z: 0 } })
+  asset = addFigureBox(asset, { id: 'wrist', size: { x: 60, y: 60, z: 60 }, position: { x: 0, y: 400, z: 0 } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'palm', face: 'bottom', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'left', face: 'bottom', to: { part: 'palm', face: 'top' }, align: { x: 'min' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'right', face: 'bottom', to: { part: 'palm', face: 'top' }, align: { x: 'max' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'wrist', face: 'top', to: { part: 'palm', face: 'bottom' } })
   const form = { kind: 'slide' as const, axis: 'x' as const, id: 'grip', min: 0, max: 60, follow: '', multiplier: 1, offset: 0 }
   const jointOf = (part: string) => asset.joints!.find(j => j.body1.part === part)!
-  asset = applyV3Authoring(asset, { kind: 'set-joint', joint: motionJoint(jointOf('left'), form, 'left') })
-  asset = applyV3Authoring(asset, { kind: 'set-joint', joint: motionJoint(jointOf('wrist'), { ...form, kind: 'turn', axis: 'y', id: 'twist', min: -90, max: 90 }, 'wrist') })
+  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: motionJoint(jointOf('left'), form, 'left') })
+  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: motionJoint(jointOf('wrist'), { ...form, kind: 'turn', axis: 'y', id: 'twist', min: -90, max: 90 }, 'wrist') })
 
   assert.deepEqual(leadersFor(asset, 'right', 'slide').map(j => j.id), ['left'], '미끄러지는 관절은 미끄러지는 관절을 따른다')
   assert.deepEqual(leadersFor(asset, 'right', 'turn').map(j => j.id), ['wrist'])
@@ -359,28 +359,28 @@ test('따라 움직이는 관절 — 같은 방식으로 움직이고 제 조작
   assert.deepEqual(follower.mimic, { joint: 'left', multiplier: -1 })
   assert.equal(follower.state, undefined, '따라가는 관절은 제 조작값이 없다')
   assert.equal(follower.lowerLimit, undefined)
-  asset = applyV3Authoring(asset, { kind: 'set-joint', joint: follower })
+  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: follower })
   assert.deepEqual(leadersFor(asset, 'wrist', 'slide').map(j => j.id), ['left'], '따라가는 관절은 앞장서지 않는다')
 
-  const x = (id: string, grip: number) => Math.round(compileV3Asset(asset).evaluate({ grip }).geometry.find(g => g.id === id)!.pose.t[0]!)
+  const x = (id: string, grip: number) => Math.round(compileFigureAsset(asset).evaluate({ grip }).geometry.find(g => g.id === id)!.pose.t[0]!)
   assert.equal(x('left', 40) - x('left', 0), 40)
   assert.equal(x('right', 40) - x('right', 0), -40, '오른손은 거울로 따라 닫힌다')
-  const { motionOf } = await import('../client/modeller/v3-links.ts')
+  const { motionOf } = await import('../client/modeller/links.ts')
   assert.deepEqual(motionOf(asset, 'right')?.follows, { joint: 'left', multiplier: -1 }, '화면은 무엇을 따르는지 읽는다')
 })
 
 test('면은 도형이 정한다 — 문틀(portal)은 바깥 여섯에 개구부 셋, 공은 없음, 원뿔대는 위아래뿐 (2026-09-25)', async () => {
-  const { facesOf, faceAxisOf, canFasten, alignAxesOf } = await import('../client/modeller/v3-links.ts')
-  let asset = createV3Asset('Doorway')
-  asset = addV3Primitive(asset, {
+  const { facesOf, faceAxisOf, canFasten, alignAxesOf } = await import('../client/modeller/links.ts')
+  let asset = createFigureAsset('Doorway')
+  asset = addFigurePrimitive(asset, {
     id: 'frame',
     kind: 'portal',
     dimensions: { width: 1100, height: 2200, depth: 150, jamb: 100, head: 100 },
     position: { x: 0, y: 0, z: 0 }
   })
-  asset = addV3Primitive(asset, { id: 'ball', kind: 'sphere', dimensions: { radiusX: 50, radiusY: 50, radiusZ: 50 }, position: { x: 0, y: 0, z: 0 } })
-  asset = addV3Primitive(asset, { id: 'cone', kind: 'frustum', dimensions: { radiusTop: 20, radiusBottom: 60, height: 100 }, position: { x: 0, y: 0, z: 0 } })
-  asset = addV3Box(asset, { id: 'leaf', size: { x: 890, y: 2095, z: 40 }, position: { x: 0, y: 0, z: 0 } })
+  asset = addFigurePrimitive(asset, { id: 'ball', kind: 'sphere', dimensions: { radiusX: 50, radiusY: 50, radiusZ: 50 }, position: { x: 0, y: 0, z: 0 } })
+  asset = addFigurePrimitive(asset, { id: 'cone', kind: 'frustum', dimensions: { radiusTop: 20, radiusBottom: 60, height: 100 }, position: { x: 0, y: 0, z: 0 } })
+  asset = addFigureBox(asset, { id: 'leaf', size: { x: 890, y: 2095, z: 40 }, position: { x: 0, y: 0, z: 0 } })
   assert.deepEqual(facesOf(asset, 'frame'), ['left', 'right', 'bottom', 'top', 'back', 'front', 'opening-left', 'opening-right', 'opening-top'])
   assert.equal(faceAxisOf(asset, 'frame', 'opening-top'), 'y')
   assert.deepEqual(facesOf(asset, 'ball'), [])
@@ -392,25 +392,25 @@ test('면은 도형이 정한다 — 문틀(portal)은 바깥 여섯에 개구
 })
 
 test('되풀이는 붙어 있고 움직이지 않고 아무것도 매달지 않은 부품에 — 붙인 면을 가로지르는 축으로 (빈틈 B, 2026-09-25)', async () => {
-  const { rowAxesOf, rowOf } = await import('../client/modeller/v3-links.ts')
-  let asset = createV3Asset('Conveyor')
-  asset = addV3Box(asset, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 0, z: 0 } })
-  asset = addV3Box(asset, { id: 'slat', size: { x: 60, y: 20, z: 560 }, position: { x: 0, y: 0, z: 0 } })
+  const { rowAxesOf, rowOf } = await import('../client/modeller/links.ts')
+  let asset = createFigureAsset('Conveyor')
+  asset = addFigureBox(asset, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 0, z: 0 } })
+  asset = addFigureBox(asset, { id: 'slat', size: { x: 60, y: 20, z: 560 }, position: { x: 0, y: 0, z: 0 } })
   assert.deepEqual(rowAxesOf(asset, 'slat'), [], '붙지 않은 부품은 되풀이를 권하지 않는다')
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'frame', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'slat', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'frame', face: 'bottom', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'slat', face: 'bottom', to: { part: 'frame', face: 'top' } })
   assert.deepEqual(rowAxesOf(asset, 'frame'), [], '바닥에 선 부품은 채울 길이가 없다')
   assert.deepEqual(rowAxesOf(asset, 'slat'), ['x', 'z'], '윗면을 가로지르는 두 축')
-  asset = applyV3Authoring(asset, { kind: 'make-repeat', part: 'slat', axis: 'x', pitch: 100 })
+  asset = applyFigureAuthoring(asset, { kind: 'make-repeat', part: 'slat', axis: 'x', pitch: 100 })
   assert.deepEqual(rowOf(asset, 'slat'), { axis: 'X', pitch: 100 })
   assert.deepEqual(rowAxesOf(asset, 'slat'), [], '이미 되풀이면 다시 권하지 않는다')
 })
 
 test('비튼 부품에는 모서리 맞춤을 내놓지도 보내지도 않는다 — 가운데서 거리만 (빈틈 F, 2026-09-25)', async () => {
-  const { alignAxesOf, alignOf } = await import('../client/modeller/v3-links.ts')
-  let asset = createV3Asset('Fan')
-  asset = addV3Box(asset, { id: 'hub', size: { x: 120, y: 120, z: 80 }, position: { x: 0, y: 0, z: 0 } })
-  asset = addV3Box(asset, { id: 'blade', size: { x: 300, y: 60, z: 8 }, position: { x: 0, y: 0, z: 0 } })
+  const { alignAxesOf, alignOf } = await import('../client/modeller/links.ts')
+  let asset = createFigureAsset('Fan')
+  asset = addFigureBox(asset, { id: 'hub', size: { x: 120, y: 120, z: 80 }, position: { x: 0, y: 0, z: 0 } })
+  asset = addFigureBox(asset, { id: 'blade', size: { x: 300, y: 60, z: 8 }, position: { x: 0, y: 0, z: 0 } })
   const front = { part: 'hub', face: 'front' }
   assert.deepEqual(alignAxesOf(asset, 'blade', front, true), [{ axis: 'x', edges: false }, { axis: 'y', edges: false }])
   assert.deepEqual(alignOf(asset, 'blade', front, { x: 'max', y: 'mm' }, { y: 50 }, true), { y: { mm: 50 } }, '끝 맞춤은 빠지고 거리만 간다')
@@ -418,58 +418,58 @@ test('비튼 부품에는 모서리 맞춤을 내놓지도 보내지도 않는
 })
 
 test('모델러에서 만든 도형은 부품에서 재어 도형 크기를 선언한다 — 그 뒤에야 부품이 도형 크기를 따를 수 있다 (사용자 09-25)', async () => {
-  const { instanceRangeToDeclare, instanceRangeOf, hasInstanceSize } = await import('../client/modeller/v3-links.ts')
-  const { compileV3Asset } = await import('@hatiolab/figure-model')
-  let asset = createV3Asset('Conveyor')
+  const { instanceRangeToDeclare, instanceRangeOf, hasInstanceSize } = await import('../client/modeller/links.ts')
+  const { compileFigureAsset } = await import('@hatiolab/figure-model')
+  let asset = createFigureAsset('Conveyor')
   assert.equal(instanceRangeToDeclare(asset), undefined, '부품이 없으면 잴 것이 없다')
-  asset = addV3Box(asset, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 0, z: 0 } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'frame', face: 'bottom', to: { plane: 'mounting-plane' } })
+  asset = addFigureBox(asset, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 0, z: 0 } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'frame', face: 'bottom', to: { plane: 'mounting-plane' } })
   assert.equal(hasInstanceSize(asset, 'x'), false, '새 도형에는 도형 크기가 없다')
   const toDeclare = instanceRangeToDeclare(asset)!
   assert.deepEqual(toDeclare.at, { x: 2000, y: 100, z: 600 }, '지금 부품의 크기가 선언할 크기')
-  asset = applyV3Authoring(asset, { kind: 'declare-instance-size', range: toDeclare.range, at: toDeclare.at })
+  asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: toDeclare.range, at: toDeclare.at })
   assert.ok(instanceRangeOf(asset), '선언 뒤에는 놓일 수 있는 크기가 보인다')
   assert.equal(instanceRangeToDeclare(asset), undefined, '이미 있으면 다시 권하지 않는다')
   assert.equal(hasInstanceSize(asset, 'x'), true, '부품이 도형 크기를 따르는 선택이 열린다')
-  asset = applyV3Authoring(asset, { kind: 'link-dimension', part: 'frame', axis: 'x', source: { of: 'instance', axis: 'x' } } as never)
-  const at = (size: number) => (compileV3Asset({ ...asset, designInputs: { ...asset.designInputs, 'size.x': size } }).evaluate().geometry.find(g => g.id === 'frame')!.shape.dimensions as { width: number }).width
+  asset = applyFigureAuthoring(asset, { kind: 'link-dimension', part: 'frame', axis: 'x', source: { of: 'instance', axis: 'x' } } as never)
+  const at = (size: number) => (compileFigureAsset({ ...asset, designInputs: { ...asset.designInputs, 'size.x': size } }).evaluate().geometry.find(g => g.id === 'frame')!.shape.dimensions as { width: number }).width
   assert.equal(at(3000), 3000, '보드가 3000 으로 놓으면 틀도 3000')
 })
 
 test('따르는 치수의 더하기를 읽는다 — 문짝 폭 = 개구부 − 틈 (사이징, 2026-09-25)', async () => {
-  const { followOf, choiceOf } = await import('../client/modeller/v3-links.ts')
-  let asset = createV3Asset('Door')
-  asset = addV3Box(asset, { id: 'head', size: { x: 1100, y: 100, z: 150 }, position: { x: 0, y: 0, z: 0 } })
-  asset = addV3Box(asset, { id: 'leaf', size: { x: 890, y: 2095, z: 40 }, position: { x: 0, y: 0, z: 0 } })
-  asset = applyV3Authoring(asset, { kind: 'link-dimension', part: 'leaf', axis: 'x', source: { of: 'part', part: 'head', axis: 'x' }, plus: -210 })
+  const { followOf, choiceOf } = await import('../client/modeller/links.ts')
+  let asset = createFigureAsset('Door')
+  asset = addFigureBox(asset, { id: 'head', size: { x: 1100, y: 100, z: 150 }, position: { x: 0, y: 0, z: 0 } })
+  asset = addFigureBox(asset, { id: 'leaf', size: { x: 890, y: 2095, z: 40 }, position: { x: 0, y: 0, z: 0 } })
+  asset = applyFigureAuthoring(asset, { kind: 'link-dimension', part: 'leaf', axis: 'x', source: { of: 'part', part: 'head', axis: 'x' }, plus: -210 })
   assert.deepEqual(followOf(asset, 'leaf', 'x'), { of: 'part', part: 'head', axis: 'x', plus: -210 })
   assert.equal(choiceOf(followOf(asset, 'leaf', 'x')), 'part:head:x', '선택은 그대로 — 더하기는 따로')
-  const { compileV3Asset } = await import('@hatiolab/figure-model')
+  const { compileFigureAsset } = await import('@hatiolab/figure-model')
   const wide = { ...asset, designInputs: { ...asset.designInputs, 'head.size.x': 1500 } }
-  assert.equal((compileV3Asset(wide).evaluate().geometry.find(g => g.id === 'leaf')!.shape.dimensions as { width: number }).width, 1290, '상인방 1500 이면 문짝 1290')
-  asset = applyV3Authoring(asset, { kind: 'declare-instance-size', range: { x: { min: 500, max: 5000 }, y: { min: 500, max: 5000 }, z: { min: 50, max: 500 } }, at: { x: 1100, y: 2200, z: 150 } })
-  asset = applyV3Authoring(asset, { kind: 'link-dimension', part: 'head', axis: 'x', source: { of: 'instance', axis: 'x' }, times: 0.5, plus: 20 })
+  assert.equal((compileFigureAsset(wide).evaluate().geometry.find(g => g.id === 'leaf')!.shape.dimensions as { width: number }).width, 1290, '상인방 1500 이면 문짝 1290')
+  asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: { x: { min: 500, max: 5000 }, y: { min: 500, max: 5000 }, z: { min: 50, max: 500 } }, at: { x: 1100, y: 2200, z: 150 } })
+  asset = applyFigureAuthoring(asset, { kind: 'link-dimension', part: 'head', axis: 'x', source: { of: 'instance', axis: 'x' }, times: 0.5, plus: 20 })
   assert.deepEqual(followOf(asset, 'head', 'x'), { of: 'instance', axis: 'x', times: 0.5, plus: 20 })
 })
 
 test('미끄러짐의 이동 거리가 부품 길이를 따른다 — 레일이 길어지면 브리지가 끝까지 간다 (사이징, 2026-09-25)', async () => {
-  const { motionJoint, motionOf } = await import('../client/modeller/v3-links.ts')
-  const { compileV3Asset } = await import('@hatiolab/figure-model')
-  let asset = createV3Asset('Gantry')
-  asset = addV3Box(asset, { id: 'rail', size: { x: 3000, y: 120, z: 120 }, position: { x: 0, y: 0, z: 0 } })
-  asset = addV3Box(asset, { id: 'bridge', size: { x: 160, y: 160, z: 1300 }, position: { x: 0, y: 0, z: 0 } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'rail', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'bridge', face: 'bottom', to: { part: 'rail', face: 'top' }, align: { x: 'min' } })
+  const { motionJoint, motionOf } = await import('../client/modeller/links.ts')
+  const { compileFigureAsset } = await import('@hatiolab/figure-model')
+  let asset = createFigureAsset('Gantry')
+  asset = addFigureBox(asset, { id: 'rail', size: { x: 3000, y: 120, z: 120 }, position: { x: 0, y: 0, z: 0 } })
+  asset = addFigureBox(asset, { id: 'bridge', size: { x: 160, y: 160, z: 1300 }, position: { x: 0, y: 0, z: 0 } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'rail', face: 'bottom', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'bridge', face: 'bottom', to: { part: 'rail', face: 'top' }, align: { x: 'min' } })
   const joint = asset.joints!.find(j => j.body1.part === 'bridge')!
   const form = { kind: 'slide' as const, axis: 'x' as const, id: 'x', min: 0, max: 500, follow: '', multiplier: 1, offset: 0, travel: 'rail:x', travelPlus: -160 }
   const record = motionJoint(joint, form, 'bridge')
   assert.deepEqual(record.travel, { source: { of: 'part', part: 'rail', axis: 'x' }, plus: -160 })
   assert.equal(record.lowerLimit, undefined, '거리는 레일이 정한다 — mm 범위는 없다')
-  asset = applyV3Authoring(asset, { kind: 'set-joint', joint: record })
+  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: record })
   assert.deepEqual(motionOf(asset, 'bridge')?.travel, { part: 'rail', axis: 'x', plus: -160 }, '화면은 무엇을 따르는지 읽는다')
   const end = (railLength: number) => {
     const a = { ...asset, designInputs: { ...asset.designInputs, 'rail.size.x': railLength } }
-    const g = (id: string) => compileV3Asset(a).evaluate({ x: 1 }).geometry.find(x => x.id === id)! as unknown as { pose: { t: number[] }; shape: { dimensions: { width: number } } }
+    const g = (id: string) => compileFigureAsset(a).evaluate({ x: 1 }).geometry.find(x => x.id === id)! as unknown as { pose: { t: number[] }; shape: { dimensions: { width: number } } }
     return Math.round(g('bridge').pose.t[0]! + 80 - (g('rail').pose.t[0]! + railLength / 2))
   }
   assert.equal(end(3000), 0, '끝까지(1) 가면 브리지 끝이 레일 끝')
@@ -477,47 +477,47 @@ test('미끄러짐의 이동 거리가 부품 길이를 따른다 — 레일이
 })
 
 test('면 위 거리를 도형 크기 비율로 — 도형이 커지면 그 자리도 비율로 옮긴다 (사이징, 2026-09-25)', async () => {
-  const { alignOf } = await import('../client/modeller/v3-links.ts')
-  const { compileV3Asset } = await import('@hatiolab/figure-model')
-  let asset = createV3Asset('Panel')
-  asset = addV3Box(asset, { id: 'panel', size: { x: 1000, y: 800, z: 40 }, position: { x: 0, y: 0, z: 0 } })
-  asset = addV3Box(asset, { id: 'lamp', size: { x: 60, y: 60, z: 30 }, position: { x: 0, y: 0, z: 0 } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'panel', face: 'bottom', to: { plane: 'mounting-plane' } })
+  const { alignOf } = await import('../client/modeller/links.ts')
+  const { compileFigureAsset } = await import('@hatiolab/figure-model')
+  let asset = createFigureAsset('Panel')
+  asset = addFigureBox(asset, { id: 'panel', size: { x: 1000, y: 800, z: 40 }, position: { x: 0, y: 0, z: 0 } })
+  asset = addFigureBox(asset, { id: 'lamp', size: { x: 60, y: 60, z: 30 }, position: { x: 0, y: 0, z: 0 } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'panel', face: 'bottom', to: { plane: 'mounting-plane' } })
   const front = { part: 'panel', face: 'front' }
   assert.deepEqual(alignOf(asset, 'lamp', front, { x: 'share' }, { x: 300 }), undefined, '도형 크기가 없으면 비율을 보낼 수 없다')
-  asset = applyV3Authoring(asset, { kind: 'declare-instance-size', range: { x: { min: 200, max: 5000 }, y: { min: 200, max: 5000 }, z: { min: 10, max: 500 } }, at: { x: 1000, y: 800, z: 40 } })
-  asset = applyV3Authoring(asset, { kind: 'link-dimension', part: 'panel', axis: 'x', source: { of: 'instance', axis: 'x' } })
+  asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: { x: { min: 200, max: 5000 }, y: { min: 200, max: 5000 }, z: { min: 10, max: 500 } }, at: { x: 1000, y: 800, z: 40 } })
+  asset = applyFigureAuthoring(asset, { kind: 'link-dimension', part: 'panel', axis: 'x', source: { of: 'instance', axis: 'x' } })
   const align = alignOf(asset, 'lamp', front, { x: 'share' }, { x: 300 })!
   assert.deepEqual(align, { x: { mm: { from: { of: 'instance', axis: 'x' }, times: 0.3 } } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'lamp', face: 'back', to: front, align })
-  const x = (size: number) => Math.round(compileV3Asset({ ...asset, designInputs: { ...asset.designInputs, 'size.x': size } }).evaluate().geometry.find(g => g.id === 'lamp')!.pose.t[0]!)
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'lamp', face: 'back', to: front, align })
+  const x = (size: number) => Math.round(compileFigureAsset({ ...asset, designInputs: { ...asset.designInputs, 'size.x': size } }).evaluate().geometry.find(g => g.id === 'lamp')!.pose.t[0]!)
   assert.equal(x(1000), 300)
   assert.equal(x(2000), 600, '도형이 두 배면 거리도 두 배')
 })
 
 test('선언할 크기는 부품이 쉬고 있을 때의 크기 — 문짝이 도는 자리까지 재지 않는다 (2026-09-25)', async () => {
-  const { instanceRangeToDeclare } = await import('../client/modeller/v3-links.ts')
-  let asset = createV3Asset('Door')
-  asset = addV3Box(asset, { id: 'jamb', size: { x: 100, y: 2100, z: 150 }, position: { x: 0, y: 0, z: 0 } })
-  asset = addV3Box(asset, { id: 'leaf', size: { x: 890, y: 2095, z: 40 }, position: { x: 0, y: 0, z: 0 } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'jamb', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'leaf', face: 'left', to: { part: 'jamb', face: 'right' }, align: { y: 'min', z: 'max' }, gap: 5 })
+  const { instanceRangeToDeclare } = await import('../client/modeller/links.ts')
+  let asset = createFigureAsset('Door')
+  asset = addFigureBox(asset, { id: 'jamb', size: { x: 100, y: 2100, z: 150 }, position: { x: 0, y: 0, z: 0 } })
+  asset = addFigureBox(asset, { id: 'leaf', size: { x: 890, y: 2095, z: 40 }, position: { x: 0, y: 0, z: 0 } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'jamb', face: 'bottom', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'leaf', face: 'left', to: { part: 'jamb', face: 'right' }, align: { y: 'min', z: 'max' }, gap: 5 })
   const j = asset.joints!.find(o => o.id === 'leaf')!
-  asset = applyV3Authoring(asset, { kind: 'set-joint', joint: { ...j, type: 'revolute', axis: 'Y', lowerLimit: -90, upperLimit: 0, state: { id: 'open' } } })
+  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...j, type: 'revolute', axis: 'Y', lowerLimit: -90, upperLimit: 0, state: { id: 'open' } } })
   assert.deepEqual(instanceRangeToDeclare(asset)!.at, { x: 995, y: 2100, z: 150 })
 })
 
 test('바닥에 선 부품도 도형 크기를 선언한 도형이면 도형의 옆면에 맞출 수 있다 (2026-09-25)', async () => {
-  const { alignAxesOf, alignOf } = await import('../client/modeller/v3-links.ts')
-  let asset = addV3Box(createV3Asset('Gate'), { id: 'post', size: { x: 100, y: 2000, z: 150 }, position: { x: 0, y: 0, z: 0 } })
+  const { alignAxesOf, alignOf } = await import('../client/modeller/links.ts')
+  let asset = addFigureBox(createFigureAsset('Gate'), { id: 'post', size: { x: 100, y: 2000, z: 150 }, position: { x: 0, y: 0, z: 0 } })
   assert.deepEqual(alignAxesOf(asset, 'post', 'plane'), [{ axis: 'x', edges: false }, { axis: 'z', edges: false }], '크기가 없으면 옆면도 없다')
-  asset = applyV3Authoring(asset, { kind: 'declare-instance-size', range: { x: { min: 200, max: 5000 }, y: { min: 500, max: 5000 }, z: { min: 50, max: 500 } }, at: { x: 1100, y: 2000, z: 150 } })
+  asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: { x: { min: 200, max: 5000 }, y: { min: 500, max: 5000 }, z: { min: 50, max: 500 } }, at: { x: 1100, y: 2000, z: 150 } })
   assert.deepEqual(alignAxesOf(asset, 'post', 'plane'), [{ axis: 'x', edges: true }, { axis: 'z', edges: true }])
   assert.deepEqual(alignOf(asset, 'post', 'plane', { x: 'min' }, {}), { x: 'min' })
 })
 
 test('움직임은 그 자리에서 고친다 — 폼에 지금 관절을 채우고, 그대로 보내면 같은 관절이다 (2026-09-25)', async () => {
-  const { motionFormOf, motionJoint } = await import('../client/modeller/v3-links.ts')
+  const { motionFormOf, motionJoint } = await import('../client/modeller/links.ts')
   const base = { id: 'j', body0: { part: 'a', face: 'top' as const }, body1: { part: 'b', face: 'bottom' as const } }
   const joints = [
     { ...base, type: 'prismatic' as const, axis: 'Z' as const, lowerLimit: 0, upperLimit: 2500, state: { id: 'extend' } },
@@ -537,28 +537,28 @@ test('움직임은 그 자리에서 고친다 — 폼에 지금 관절을 채우
 })
 
 test('바닥에 선 부품도 무엇에 붙어 있는지 읽는다 — 그래야 옮겨 붙일 수 있다 (문설주, 2026-09-25)', async () => {
-  const { heldBy } = await import('../client/modeller/v3-links.ts')
-  let asset = createV3Asset('Door')
-  asset = addV3Box(asset, { id: 'jamb', size: { x: 100, y: 2100, z: 150 }, position: { x: 0, y: 0, z: 0 } })
-  asset = addV3Box(asset, { id: 'head', size: { x: 1100, y: 100, z: 150 }, position: { x: 0, y: 0, z: 0 } })
+  const { heldBy } = await import('../client/modeller/links.ts')
+  let asset = createFigureAsset('Door')
+  asset = addFigureBox(asset, { id: 'jamb', size: { x: 100, y: 2100, z: 150 }, position: { x: 0, y: 0, z: 0 } })
+  asset = addFigureBox(asset, { id: 'head', size: { x: 1100, y: 100, z: 150 }, position: { x: 0, y: 0, z: 0 } })
   assert.equal(heldBy(asset, 'jamb'), null)
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'jamb', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'head', face: 'bottom', to: { part: 'jamb', face: 'top' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'jamb', face: 'bottom', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'head', face: 'bottom', to: { part: 'jamb', face: 'top' } })
   assert.deepEqual(heldBy(asset, 'jamb'), { plane: true }, '장착 평면')
   assert.deepEqual(heldBy(asset, 'head'), { part: 'jamb' })
   /* What the form then sends: a fastening that replaces the one there. */
-  assert.doesNotThrow(() => applyV3Authoring(asset, { kind: 'attach', part: 'jamb', face: 'bottom', to: { plane: 'mounting-plane' }, align: { x: { mm: -500 } }, replace: !!heldBy(asset, 'jamb') }))
+  assert.doesNotThrow(() => applyFigureAuthoring(asset, { kind: 'attach', part: 'jamb', face: 'bottom', to: { plane: 'mounting-plane' }, align: { x: { mm: -500 } }, replace: !!heldBy(asset, 'jamb') }))
 })
 
 test('벽 배치 — 장착 평면은 Z = 0, 등으로 붙이고 가로질러 X · Y 로 맞춘다(사용자 · 아키텍트 09-25)', async () => {
-  const { mountingPlaneOf, alignAxesOf } = await import('../client/modeller/v3-links.ts')
-  let a = addV3Box(createV3Asset('Lamp'), { id: 'plate', size: { x: 200, y: 300, z: 20 }, position: { x: 0, y: 0, z: 0 } })
+  const { mountingPlaneOf, alignAxesOf } = await import('../client/modeller/links.ts')
+  let a = addFigureBox(createFigureAsset('Lamp'), { id: 'plate', size: { x: 200, y: 300, z: 20 }, position: { x: 0, y: 0, z: 0 } })
   assert.deepEqual(mountingPlaneOf(a), { normal: 'y', faces: ['bottom', 'top'] }, '배치 선언 전에는 바닥')
-  a = applyV3Authoring(a, { kind: 'declare-occupancy', proposal: (await import('@hatiolab/figure-model')).proposeV3Occupancy(a), placement: 'wall' as never })
+  a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: (await import('@hatiolab/figure-model')).proposeFigureOccupancy(a), placement: 'wall' as never })
   assert.deepEqual(mountingPlaneOf(a), { normal: 'z', faces: ['back'] })
   assert.deepEqual(alignAxesOf(a, 'plate', 'plane').map(x => x.axis), ['x', 'y'])
-  const form = read('../client/modeller/figure-v3-links.ts')
-  assert.ok(form.includes('(!f.toPlane || plane.faces.includes(face as V3Face))'), '평면에 붙일 때는 평면이 받는 면만')
+  const form = read('../client/modeller/figure-links.ts')
+  assert.ok(form.includes('(!f.toPlane || plane.faces.includes(face as FigureFace))'), '평면에 붙일 때는 평면이 받는 면만')
 })
 
 test('부품 칸의 두 제목이 같은 말이 아니다 — 자리 숫자는 「위치와 크기」, 붙이기 칸은 「붙이기」 (09-26)', () => {
@@ -572,22 +572,22 @@ test('부품 칸의 두 제목이 같은 말이 아니다 — 자리 숫자는
  * 고르는 칸이 없었다(09-26 기준 측정).
  */
 test('보이는 때 — 명령이 남긴 것을 읽고, 폼은 그 명령을 낸다', async () => {
-  const { shownWhenOf, visibilityControlsOf } = await import('../client/modeller/v3-links.ts')
-  const { editV3Part } = await import('@hatiolab/figure-model')
-  let asset = createV3Asset('Gate')
-  asset = addV3Box(asset, { id: 'frame', size: { x: 1200, y: 60, z: 200 }, position: { x: 0, y: 30, z: 0 } })
-  asset = addV3Box(asset, { id: 'door', size: { x: 1000, y: 2000, z: 40 }, position: { x: 0, y: 1060, z: 0 } })
-  asset = addV3Box(asset, { id: 'lamp', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 2200, z: 0 } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'frame', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'door', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  const { shownWhenOf, visibilityControlsOf } = await import('../client/modeller/links.ts')
+  const { editFigurePart } = await import('@hatiolab/figure-model')
+  let asset = createFigureAsset('Gate')
+  asset = addFigureBox(asset, { id: 'frame', size: { x: 1200, y: 60, z: 200 }, position: { x: 0, y: 30, z: 0 } })
+  asset = addFigureBox(asset, { id: 'door', size: { x: 1000, y: 2000, z: 40 }, position: { x: 0, y: 1060, z: 0 } })
+  asset = addFigureBox(asset, { id: 'lamp', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 2200, z: 0 } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'frame', face: 'bottom', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'door', face: 'bottom', to: { part: 'frame', face: 'top' } })
   assert.deepEqual(visibilityControlsOf(asset), [], '조작값이 없으면 고를 것도 없다')
   asset = moving(asset, 'door', { kind: 'slide', axis: 'x', id: 'gate-open', min: 0, max: 900 })
   assert.deepEqual(visibilityControlsOf(asset).map(c => [c.id, c.min, c.max, c.unit]), [['gate-open', 0, 900, 'mm']])
   assert.equal(shownWhenOf(asset, 'lamp'), null, '늘 보인다')
-  const shown = editV3Part(asset, { kind: 'set-visibility', target: 'lamp', shownWhen: { input: 'gate-open', atLeast: 9 } })
+  const shown = editFigurePart(asset, { kind: 'set-visibility', target: 'lamp', shownWhen: { input: 'gate-open', atLeast: 9 } })
   assert.deepEqual(shownWhenOf(shown, 'lamp'), { input: 'gate-open', atLeast: 9 })
-  assert.equal(shownWhenOf(editV3Part(shown, { kind: 'set-visibility', target: 'lamp', shownWhen: null }), 'lamp'), null)
-  const form = read('../client/modeller/figure-v3-links.ts')
+  assert.equal(shownWhenOf(editFigurePart(shown, { kind: 'set-visibility', target: 'lamp', shownWhen: null }), 'lamp'), null)
+  const form = read('../client/modeller/figure-links.ts')
   const section = form.slice(form.indexOf('  private renderShown('), form.indexOf('  private renderMotion('))
   assert.ok(section.includes("kind: 'set-visibility'"), '폼은 그 명령을 낸다')
   assert.ok(form.includes('${this.renderShown(asset)}'), '움직임 칸에')
@@ -595,10 +595,10 @@ test('보이는 때 — 명령이 남긴 것을 읽고, 폼은 그 명령을 낸
 
 /* 문틀은 폭 · 높이 · 깊이로 — 상자처럼 크기를 따르고, 손잡이로 키운다 (figure-model portal-profile@2, 09-26). */
 test('팔레트의 문틀은 문 크기로 서고, 세 축 모두 크기를 따를 수 있고, 손잡이로 키울 수 있다', async () => {
-  const { paletteRecipe } = await import('../client/modeller/v3-palette.ts')
-  const { gizmoReachOf } = await import('../client/modeller/v3-gizmo.ts')
-  const { addV3Primitive: add } = await import('@hatiolab/figure-model')
-  const asset = add(createV3Asset('Frame'), paletteRecipe('portal', 'frame'))
+  const { paletteRecipe } = await import('../client/modeller/palette.ts')
+  const { gizmoReachOf } = await import('../client/modeller/gizmo.ts')
+  const { addFigurePrimitive: add } = await import('@hatiolab/figure-model')
+  const asset = add(createFigureAsset('Frame'), paletteRecipe('portal', 'frame'))
   assert.deepEqual(followableAxes(asset, 'frame'), ['x', 'y', 'z'])
   const reach = gizmoReachOf(asset as never, 'frame')
   assert.equal(reach.scale, true)
@@ -608,11 +608,11 @@ test('팔레트의 문틀은 문 크기로 서고, 세 축 모두 크기를 따
 
 /* 크기를 따라감 한 번 — 치수 칸의 단추 하나, 크기를 대신 정했으면 한 줄로 말한다 (ADR 판정 Q1, 09-26). */
 test('치수 칸 — 「도형 크기를 따라감」 단추는 follow-size 한 번, 다 따르면 사라진다; 크기를 대신 정하면 한 줄', () => {
-  const form = read('../client/modeller/figure-v3-links.ts')
+  const form = read('../client/modeller/figure-links.ts')
   const dims = form.slice(form.indexOf('  private renderDimensions('), form.indexOf('  private renderDimensions(') + 1200)
   assert.ok(dims.includes("this.command({ kind: 'follow-size', part: this.partId })"))
   assert.ok(dims.includes("followOf(asset, this.partId, axis).of === 'instance'"), '다 따르면 단추가 없다')
-  const editor = read('../client/modeller/v3-editor.ts')
+  const editor = read('../client/modeller/editor.ts')
   assert.ok(editor.includes("if (action.kind === 'follow-size' && !hadSize)"), '크기를 대신 정했을 때만')
   assert.ok(editor.includes('<div role="status" class="notice">'))
   const ko = JSON.parse(read('../translations/ko.json'))
@@ -621,10 +621,10 @@ test('치수 칸 — 「도형 크기를 따라감」 단추는 follow-size 한
 
 /* 통 — 속 빈 상자를 팔레트에서, 세 축 모두 크기를 따르고, 손잡이로 키우고, 안쪽 면에 붙인다 (G4, 09-26). */
 test('팔레트의 통은 통의 크기로 서고, 세 축 모두 크기를 따를 수 있고, 손잡이로 키울 수 있다', async () => {
-  const { paletteRecipe } = await import('../client/modeller/v3-palette.ts')
-  const { gizmoReachOf } = await import('../client/modeller/v3-gizmo.ts')
-  const { addV3Primitive: add } = await import('@hatiolab/figure-model')
-  const asset = add(createV3Asset('Tote'), paletteRecipe('hollow-box' as never, 'tote'))
+  const { paletteRecipe } = await import('../client/modeller/palette.ts')
+  const { gizmoReachOf } = await import('../client/modeller/gizmo.ts')
+  const { addFigurePrimitive: add } = await import('@hatiolab/figure-model')
+  const asset = add(createFigureAsset('Tote'), paletteRecipe('hollow-box' as never, 'tote'))
   assert.deepEqual(followableAxes(asset, 'tote'), ['x', 'y', 'z'])
   assert.deepEqual(gizmoReachOf(asset as never, 'tote').sizes, ['tote.dimension.width', 'tote.dimension.height', 'tote.dimension.depth'])
   const ko = JSON.parse(read('../translations/ko.json'))
@@ -635,13 +635,13 @@ test('팔레트의 통은 통의 크기로 서고, 세 축 모두 크기를 따
  * The fastening form opens on the part's own fastening (walk 1, 2026-09-26): a roller fastened by its centre was shown
  * as fastened by its bottom, and fastening again from there broke its turning in place.
  */
-import { fasteningOf } from '../client/modeller/v3-links.ts'
+import { fasteningOf } from '../client/modeller/links.ts'
 
 test('붙이기 칸은 부품 제 붙임으로 열린다 — 가운데로 붙은 롤러는 가운데 · 상대 · 간격 그대로', () => {
-  let asset = addV3Box(createV3Asset('Rollers'), { id: 'bed', size: { x: 2000, y: 400, z: 600 }, position: { x: 0, y: 200, z: 0 } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'bed', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = addV3Primitive(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 = applyV3Authoring(asset, { kind: 'attach', part: 'roller', face: 'centre', to: { part: 'bed', face: 'top' }, gap: 40, align: { x: 'min' } })
+  let asset = addFigureBox(createFigureAsset('Rollers'), { id: 'bed', size: { x: 2000, y: 400, z: 600 }, position: { x: 0, y: 200, z: 0 } })
+  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')!
   assert.equal(roller.face, 'centre')
   assert.equal(roller.target, 'bed')
@@ -650,8 +650,8 @@ test('붙이기 칸은 부품 제 붙임으로 열린다 — 가운데로 붙은
   assert.equal(roller.align.x, 'min', '기록의 정렬')
   const bed = fasteningOf(asset, 'bed')!
   assert.deepEqual([bed.face, bed.toPlane], ['bottom', true])
-  assert.equal(fasteningOf(addV3Box(createV3Asset('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-v3-links.ts', import.meta.url)), 'utf8')
+  assert.equal(fasteningOf(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("...(f.toPlane ? [] : (['centre'] as const))"), '내 면에 가운데가 있다')
 })