@things-factory/figure-ui 10.1.75 → 10.1.76

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

@@ -7,7 +7,7 @@ import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 
-import { groupFields, ownerOf, partLabelOf, repeatOf } from '../client/modeller/v3-fields.ts'
+import { groupFields, ownerOf, partLabelOf, repeatOf } from '../client/modeller/fields.ts'
 
 const f = (id: string, value = 1, unit = 'mm') => ({ id, unit, value, role: 'design' })
 
@@ -30,7 +30,7 @@ test('도형은 크기(size.x · y · z)가 세 칸 한 줄', () => {
 })
 
 test('오른쪽 칸은 한 벌의 규격 — 요소마다 제 제목 · 칸 · 단추 규칙을 두지 않는다', () => {
-  for (const file of ['v3-editor', 'figure-v3-properties', 'figure-v3-links', 'figure-v3-material', 'figure-v3-controls', 'figure-v3-clips', 'figure-v3-capability']) {
+  for (const file of ['editor', 'figure-properties', 'figure-links', 'figure-material-panel', 'figure-controls', 'figure-clips', 'figure-capability-panel']) {
     const source = readFileSync(fileURLToPath(new URL(`../client/modeller/${file}.ts`, import.meta.url)), 'utf8')
     assert.ok(source.includes('SidePanelStyles'), `${file} 가 공용 규격을 쓴다`)
     const styles = source.slice(source.indexOf('static styles'), source.indexOf('`]', source.indexOf('static styles')))
@@ -40,10 +40,10 @@ test('오른쪽 칸은 한 벌의 규격 — 요소마다 제 제목 · 칸 ·
 
 test('긴 설명은 제목 옆 「?」 로 연다 — 늘 펼쳐 두지 않는다', () => {
   for (const [file, key] of [
-    ['figure-v3-links', 'figure.text.motion-explained'],
-    ['figure-v3-links', 'figure.text.place-explained'],
-    ['figure-v3-links', 'figure.text.fastening-explained'],
-    ['figure-v3-clips', 'figure.text.clips-explained']
+    ['figure-links', 'figure.text.motion-explained'],
+    ['figure-links', 'figure.text.place-explained'],
+    ['figure-links', 'figure.text.fastening-explained'],
+    ['figure-clips', 'figure.text.clips-explained']
   ]) {
     const source = readFileSync(fileURLToPath(new URL(`../client/modeller/${file}.ts`, import.meta.url)), 'utf8')
     assert.ok(source.includes(`this.help.button('${key}')`) && source.includes(`this.help.hint('${key}')`), `${file}: ${key}`)
@@ -56,7 +56,7 @@ test('되풀이한 부품은 되풀이의 이름과 몇 번째인지로 읽는
   assert.equal(partLabelOf('["roller.repeat",2,"mark.placed"]'), 'mark 3', '줄의 부품에 붙은 것은 제 이름으로 (ADR-0093, 2026-09-26)')
   assert.equal(partLabelOf('deck'), 'deck', '보통 부품은 제 이름')
   assert.equal(partLabelOf('[not json'), '[not json')
-  const parts = readFileSync(fileURLToPath(new URL('../client/modeller/figure-v3-parts.ts', import.meta.url)), 'utf8')
+  const parts = readFileSync(fileURLToPath(new URL('../client/modeller/figure-parts.ts', import.meta.url)), 'utf8')
   assert.ok(parts.includes('>${partLabelOf(part.id)}'), '목록이 이 이름으로 그린다')
 })
 
@@ -67,7 +67,7 @@ test('되풀이한 부품의 속성 이름 칸도 사람의 이름이고, 몇
   const carried = geometry.concat(Array.from({ length: 16 }, (_, i) => ({ id: JSON.stringify(['roller.repeat', i, 'mark.placed']) })))
   assert.deepEqual(repeatOf('["roller.repeat",14,"roller.value"]', carried), { name: 'roller', count: 16, index: 15 }, '롤러에 붙은 것은 롤러 수에 안 든다')
   assert.deepEqual(repeatOf('["roller.repeat",2,"mark.placed"]', carried), { name: 'mark', count: 16, index: 3 })
-  const editor = readFileSync(fileURLToPath(new URL('../client/modeller/v3-editor.ts', import.meta.url)), 'utf8')
+  const editor = readFileSync(fileURLToPath(new URL('../client/modeller/editor.ts', import.meta.url)), 'utf8')
   assert.ok(editor.includes('.value=${partLabelOf(this.selected)}'), '사용자 2026-09-24: 「부품 이름 ???」')
   assert.ok(editor.includes('?disabled=${unavailable || !!repeatOf(this.selected, view.geometry)?.index}'), '복사본에는 바꿀 제 이름이 없고, 줄의 부품 자신은 이름을 바꿀 수 있다(walk 1, 2026-09-26)')
   assert.equal(repeatOf('roller', geometry)?.index, 0, '줄의 부품 자신은 몇 번째가 아니다')
@@ -79,18 +79,18 @@ test('편집기는 저작한 부품 단위로 고르고 보인다 — 되풀이
   assert.equal(ownerOf('["roller.repeat",2,"mark.placed"]'), 'mark', '롤러에 붙은 표시의 복사본을 누르면 그 표시를 고른다')
   assert.deepEqual(repeatOf('roller', [{ id: '["roller.repeat",0,"roller.value"]' }, { id: '["roller.repeat",1,"roller.value"]' }, { id: 'deck' }]), { name: 'roller', count: 2, index: 0 })
   const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
-  const canvas = read('../client/modeller/v3-canvas.ts')
+  const canvas = read('../client/modeller/canvas.ts')
   assert.ok(canvas.includes('.filter(([name]) => ownerOf(name) === this.selected)'), '사용자 2026-09-24: 「why repeatable parts are not selected?」')
-  const editor = read('../client/modeller/v3-editor.ts')
+  const editor = read('../client/modeller/editor.ts')
   assert.ok(editor.includes('this.selected = id ? ownerOf(id) : id'), '캔버스에서 복사본을 누르면 그 되풀이를 고른다')
   assert.ok(editor.includes('.parts=${this.partRows(view.geometry)}'), '목록은 저작한 부품 한 줄씩')
   assert.ok(editor.includes("this.session!.command({ kind: 'set-repeat', part: this.selected, pitch })"), 'pitch 는 명령으로 정한다')
-  const parts = read('../client/modeller/figure-v3-parts.ts')
+  const parts = read('../client/modeller/figure-parts.ts')
   assert.ok(parts.includes('?disabled=${this.locked || full}'), '등급 한도에 이르면 팔레트가 잠긴다')
 })
 
 test('pitch 는 한 곳에서 하나의 값이고, 늘 set-repeat 로 바꿔 최대 길이가 따라온다', () => {
-  const editor = readFileSync(fileURLToPath(new URL('../client/modeller/v3-editor.ts', import.meta.url)), 'utf8')
+  const editor = readFileSync(fileURLToPath(new URL('../client/modeller/editor.ts', import.meta.url)), 'utf8')
   assert.ok(editor.includes("groupFields(own, this.selected)"), '사용자 2026-09-24: 되풀이의 간격과 형상 치수의 repeat · pitch 가 같은 값으로 두 번 떴다')
   assert.ok(editor.includes("!i.id.startsWith(this.selected + '.repeat.')"))
   const pitch = editor.slice(editor.indexOf('  private setPitch('), editor.indexOf('  /** Choose a part,'))
@@ -104,7 +104,7 @@ test('pitch 는 한 곳에서 하나의 값이고, 늘 set-repeat 로 바꿔 최
 })
 
 test('기즈모로 끈, 규칙이 자리를 정하는 부품은 규칙을 지킨 채 옮겨지고, 관절·붙이기가 정하는 부품은 까닭을 말한다 — 튕겨 돌아가지 않는다', () => {
-  const editor = readFileSync(fileURLToPath(new URL('../client/modeller/v3-editor.ts', import.meta.url)), 'utf8')
+  const editor = readFileSync(fileURLToPath(new URL('../client/modeller/editor.ts', import.meta.url)), 'utf8')
   const moved = editor.slice(editor.indexOf('  private transformed('), editor.indexOf('  /** 맞추기'))
   assert.ok(moved.includes("kind: 'nudge-part',"), '사용자 2026-09-24: 「기즈모 컨트롤도 전혀 작동이 안되는군」')
   assert.ok(moved.includes('...(Object.keys(grow).length ? { grow } : {})'), '크기 끌기도 배율로 — 「되는 듯하다가 다시 원래 크기로 돌아간다」')

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

@@ -1,5 +1,5 @@
 /*
- * The V3 modeller's AI - the framework dock talks about the figure on screen (design/ai/shared-dock.md §3).
+ * The modeller's AI - the framework dock talks about the figure on screen (design/ai/shared-dock.md §3).
  *
  * What this holds: ① a saved figure provides a surface anchored on its row ② the draft is read at the moment of
  * sending, not when the surface was provided ③ an unsaved figure provides nothing - no conversation without a row
@@ -11,7 +11,7 @@ import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import { test } from 'node:test'
 
-const source = readFileSync(fileURLToPath(new URL('../client/pages/figure-v3-modeller-page.ts', import.meta.url)), 'utf8')
+const source = readFileSync(fileURLToPath(new URL('../client/pages/figure-modeller-page.ts', import.meta.url)), 'utf8')
 
 test('a saved figure provides a surface anchored on its row', () => {
   assert.match(source, /provideAssistantSurface\(this, \{/)
@@ -34,7 +34,7 @@ test('the surface is taken back when the page goes inactive or leaves', () => {
 })
 
 test('the dock applies a proposal through the page, on the version the model saw', () => {
-  assert.match(source, /window\.addEventListener\('figure-v3-apply', this\.applyAI\)/)
+  assert.match(source, /window\.addEventListener\('figure-apply', this\.applyAI\)/)
   assert.match(source, /this\.session\.applyProposal\(detail\.steps, detail\.revision, detail\.context\)/)
   assert.match(source, /this\.takeNewFigureProposal\(\)/, 'a new figure opened for a proposal takes its steps')
 })

package/test/{v3-first-save.test.ts → first-save.test.ts}

@@ -5,8 +5,8 @@ import { test } from 'node:test'
 import assert from 'node:assert/strict'
 
 import { placeholderType } from '@hatiolab/figure-model'
-import { firstSaveRefusalOf, releasableType, typeOf } from '../client/modeller/v3-first-save.ts'
-import { createV3ProductSession, type V3ProductStore } from '../client/modeller/v3-product-session.ts'
+import { firstSaveRefusalOf, releasableType, typeOf } from '../client/modeller/first-save.ts'
+import { createFigureProductSession, type FigureProductStore } from '../client/modeller/product-session.ts'
 
 test('치는 대로 타입의 모양이 된다 — 대문자 · 숫자 · 밑줄', () => {
   assert.equal(typeOf(' agv lifter '), 'AGV_LIFTER')
@@ -29,8 +29,8 @@ test('비었거나 이미 쓰는 이름이면 저장하지 않는다', () => {
 
 /** A store that remembers what it was asked. */
 function recording() {
-  const requests: Parameters<V3ProductStore['save']>[0][] = []
-  const store: V3ProductStore = {
+  const requests: Parameters<FigureProductStore['save']>[0][] = []
+  const store: FigureProductStore = {
     load: async id => ({ id, source: saved ?? '' }),
     save: async request => {
       requests.push(request)
@@ -44,7 +44,7 @@ function recording() {
 
 test('타입은 새 도형을 만드는 저장에만 실린다 — 이미 있는 도형의 저장은 타입을 보내지 않는다', async () => {
   const { store, requests } = recording()
-  const session = createV3ProductSession(store)
+  const session = createFigureProductSession(store)
   session.startNew()
   await session.save({ type: 'AGV_LIFTER' })
   assert.equal(requests[0]!.type, 'AGV_LIFTER')
@@ -58,7 +58,7 @@ test('타입은 새 도형을 만드는 저장에만 실린다 — 이미 있는
 
 test('타입을 주지 않으면 싣지 않는다 — 서버가 임시 이름을 붙인다', async () => {
   const { store, requests } = recording()
-  const session = createV3ProductSession(store)
+  const session = createFigureProductSession(store)
   session.startNew()
   await session.save()
   assert.equal('type' in requests[0]!, false)
@@ -66,17 +66,17 @@ test('타입을 주지 않으면 싣지 않는다 — 서버가 임시 이름을
 
 test('저장 전에 적은 타입은 처음 저장의 물음에 실려 온다 — 칸이 막혀 있어 적어도 사라졌다 (09-25)', async () => {
   const { readFileSync } = await import('node:fs')
-  const page = readFileSync(new URL('../client/pages/figure-v3-modeller-page.ts', import.meta.url), 'utf8')
+  const page = readFileSync(new URL('../client/pages/figure-modeller-page.ts', import.meta.url), 'utf8')
   const field = page.slice(page.indexOf('<label slot="type" type-field>'), page.indexOf('</label>', page.indexOf('<label slot="type" type-field>')))
   assert.doesNotMatch(field, /disabled=\$\{!view\.id\}/, '저장 전에도 칸에 적을 수 있다')
   const rename = page.slice(page.indexOf('private renameType'), page.indexOf('private fitToParts'))
   assert.match(rename, /if \(!id\) \{\s*this\.row = \{ \.\.\.this\.row, type: wanted \|\| undefined \}/, '저장 전에는 행 대신 화면이 타입을 쥔다')
-  assert.match(page, /<figure-v3-first-save \.type=\$\{this\.row\.type \?\? ''\}/, '물음은 그 타입으로 열린다')
+  assert.match(page, /<figure-first-save \.type=\$\{this\.row\.type \?\? ''\}/, '물음은 그 타입으로 열린다')
 })
 
 test('처음 저장한 도형은 주소가 제 것이 된다 — 모델러를 다시 열면 새 도형이 열린다 (2026-09-25)', async () => {
   const { readFileSync } = await import('node:fs')
-  const page = readFileSync(new URL('../client/pages/figure-v3-modeller-page.ts', import.meta.url), 'utf8')
+  const page = readFileSync(new URL('../client/pages/figure-modeller-page.ts', import.meta.url), 'utf8')
   const changed = page.slice(page.indexOf('private changed = () => {'), page.indexOf('private async readRow'))
   assert.match(changed, /if \(view\.id && !this\.routeId && !view\.saving\) \{\s*this\.routeId = view\.id\s*navigate\(modellerPathOf\(\{ id: view\.id \}\), true\)/, '저장으로 id 를 얻으면 그 주소로 바꾼다(기록은 덮어쓴다)')
   /* The early return that kept the old figure reads the route id; it now matches only the figure the address names. */
@@ -85,7 +85,7 @@ test('처음 저장한 도형은 주소가 제 것이 된다 — 모델러를
 
 test('다른 도형을 열면 행을 먼저 비운다 — 앞 도형의 타입이 칸에 남지 않는다 (C2, 2026-09-25)', async () => {
   const { readFileSync } = await import('node:fs')
-  const page = readFileSync(new URL('../client/pages/figure-v3-modeller-page.ts', import.meta.url), 'utf8')
+  const page = readFileSync(new URL('../client/pages/figure-modeller-page.ts', import.meta.url), 'utf8')
   const updated = page.slice(page.indexOf('async pageUpdated'), page.indexOf('private askFirstSave'))
   const opening = updated.slice(updated.indexOf('if (id) {'), updated.indexOf('this.session.open(id'))
   assert.match(opening, /this\.row = \{ version: 0 \}/, '열기 전에 행을 비운다')

package/test/fixtures/joint-column.json

@@ -1,8 +1,8 @@
 {
-  "version": "figure-v3-asset-1",
+  "version": "figure-asset-1",
   "name": "COLUMN",
   "document": {
-    "version": "figure-v3-prototype-1",
+    "version": "figure-prototype-1",
     "model": {
       "version": "r3-spatial-1",
       "inputs": [

package/test/fixtures/joint-roller.json

@@ -1,8 +1,8 @@
 {
-  "version": "figure-v3-asset-1",
+  "version": "figure-asset-1",
   "name": "ROLLER",
   "document": {
-    "version": "figure-v3-prototype-1",
+    "version": "figure-prototype-1",
     "model": {
       "version": "r3-spatial-1",
       "inputs": [

package/test/fixtures/robot-arm-6dof.json

@@ -1,8 +1,8 @@
 {
-  "version": "figure-v3-asset-1",
+  "version": "figure-asset-1",
   "name": "ROBOT_ARM_6DOF",
   "document": {
-    "version": "figure-v3-prototype-1",
+    "version": "figure-prototype-1",
     "model": {
       "version": "r3-spatial-1",
       "inputs": [

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

@@ -9,16 +9,16 @@ import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 
-import { addV3Box, addV3Primitive, applyV3Authoring, compileV3Asset, createV3Asset, createV3EditorWorkspace } from '@hatiolab/figure-model'
+import { addFigureBox, addFigurePrimitive, applyFigureAuthoring, compileFigureAsset, createFigureAsset, createFigureEditorWorkspace } from '@hatiolab/figure-model'
 
-import { gizmoChanges, gizmoReachOf } from '../client/modeller/v3-gizmo.ts'
+import { gizmoChanges, gizmoReachOf } from '../client/modeller/gizmo.ts'
 import { moving } from './joints.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 const probe = () => {
-  let asset = createV3Asset('Probe')
-  asset = addV3Box(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
-  asset = addV3Primitive(asset, { id: 'drum', kind: 'cylinder', dimensions: { radius: 50, length: 100 }, position: { x: 0, y: 150, z: 0 } })
+  let asset = createFigureAsset('Probe')
+  asset = addFigureBox(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+  asset = addFigurePrimitive(asset, { id: 'drum', kind: 'cylinder', dimensions: { radius: 50, length: 100 }, position: { x: 0, y: 150, z: 0 } })
   return asset
 }
 const apply = (asset: ReturnType<typeof probe>, changes: ReturnType<typeof gizmoChanges>) => {
@@ -27,7 +27,7 @@ const apply = (asset: ReturnType<typeof probe>, changes: ReturnType<typeof gizmo
   return next
 }
 const pose = (asset: ReturnType<typeof probe>, id: string) =>
-  (compileV3Asset(asset).evaluate().geometry.find(g => (g as { id: string }).id === id) as unknown as { pose: { t: number[]; r: number[][] } }).pose
+  (compileFigureAsset(asset).evaluate().geometry.find(g => (g as { id: string }).id === id) as unknown as { pose: { t: number[]; r: number[][] } }).pose
 
 test('만든 상자는 셋 다, 원기둥도 셋 다 — 원기둥의 크기는 반지름과 길이로', () => {
   assert.deepEqual(gizmoReachOf(probe() as never, 'body'), {
@@ -40,9 +40,9 @@ test('만든 상자는 셋 다, 원기둥도 셋 다 — 원기둥의 크기는
 })
 
 test('편집기의 도형 팔레트로 만든 상자 · 둥근 상자도 크기를 낸다 — 입력 이름이 dimension.* 이다', () => {
-  let asset = createV3Asset('Probe')
-  asset = addV3Primitive(asset, { id: 'box-1', kind: 'box', dimensions: { width: 100, height: 100, depth: 100 }, position: { x: 0, y: 50, z: 0 } })
-  asset = addV3Primitive(asset, { id: 'rb-1', kind: 'rounded-box', dimensions: { width: 100, height: 60, depth: 80, round: 10 }, position: { x: 0, y: 50, z: 0 } })
+  let asset = createFigureAsset('Probe')
+  asset = addFigurePrimitive(asset, { id: 'box-1', kind: 'box', dimensions: { width: 100, height: 100, depth: 100 }, position: { x: 0, y: 50, z: 0 } })
+  asset = addFigurePrimitive(asset, { id: 'rb-1', kind: 'rounded-box', dimensions: { width: 100, height: 60, depth: 80, round: 10 }, position: { x: 0, y: 50, z: 0 } })
   const box = gizmoReachOf(asset as never, 'box-1')
   assert.equal(box.scale, true, '편집기에서 만든 상자를 키울 수 없었다 (2026-09-24, :3300)')
   const changes = gizmoChanges('rb-1', gizmoReachOf(asset as never, 'rb-1'), { scale: [2, 1, 0.5] }, asset.designInputs)
@@ -51,9 +51,9 @@ test('편집기의 도형 팔레트로 만든 상자 · 둥근 상자도 크기
 
 test('다른 부품에 붙인 부품은 옮기지 않는다 — 다음 평가가 제자리로 돌려놓을 것을 움직이지 않는다', () => {
   /* attach takes box-shaped parts only. */
-  const lidded = addV3Box(probe(), { id: 'lid', size: { x: 100, y: 20, z: 100 }, position: { x: 0, y: 300, z: 0 } })
+  const lidded = addFigureBox(probe(), { id: 'lid', size: { x: 100, y: 20, z: 100 }, position: { x: 0, y: 300, z: 0 } })
   assert.equal(gizmoReachOf(lidded as never, 'lid').translate, true, '전제: 붙이기 전에는 옮길 수 있다')
-  const fastened = applyV3Authoring(lidded, { kind: 'attach', part: 'lid', face: 'bottom', to: { part: 'body', face: 'top' } })
+  const fastened = applyFigureAuthoring(lidded, { kind: 'attach', part: 'lid', face: 'bottom', to: { part: 'body', face: 'top' } })
   assert.equal(gizmoReachOf(fastened as never, 'lid').translate, false)
 })
 
@@ -79,16 +79,16 @@ test('크기는 배율만큼 치수를 바꾸고 1mm 아래로 가지 않는다'
 })
 
 test('끈 것은 세션의 한 걸음이다 — 한 번의 되돌리기로 돌아간다', () => {
-  const workspace = createV3EditorWorkspace() as unknown as Record<string, Function>
+  const workspace = createFigureEditorWorkspace() as unknown as Record<string, Function>
   assert.ok(typeof workspace.apply === 'function')
-  const editor = read('../client/modeller/v3-editor.ts')
+  const editor = read('../client/modeller/editor.ts')
   const moved = editor.slice(editor.indexOf('  private transformed('), editor.indexOf('  /** 맞추기'))
   assert.ok(moved.includes('this.run(() => this.session!.apply(changes))'), 'one apply, one step')
   assert.ok(moved.includes("kind: 'nudge-part',"), 'a nudge is one command, one step')
 })
 
 test('캔버스 — 기즈모 · W E R · 스냅은 씬의 편집 모드가 한다', () => {
-  const canvas = read('../client/modeller/v3-canvas.ts')
+  const canvas = read('../client/modeller/canvas.ts')
   assert.match(canvas, /mode: 1\n/)
   assert.doesNotMatch(canvas, /TransformControls|OrbitControls/)
 })
@@ -102,16 +102,16 @@ test('기즈모의 말은 다섯 말 모두에 있다', () => {
 
 test('떼어 낸 부품은 다시 옮길 수 있다 — 움직임이 있는 부품은 아니다', () => {
   let asset = probe()
-  asset = addV3Box(asset, { id: 'lid', size: { x: 100, y: 20, z: 100 }, position: { x: 0, y: 300, z: 0 } })
-  const fastened = applyV3Authoring(asset, { kind: 'attach', part: 'lid', face: 'bottom', to: { part: 'body', face: 'top' } })
-  const free = applyV3Authoring(fastened, { kind: 'detach', part: 'lid' })
+  asset = addFigureBox(asset, { id: 'lid', size: { x: 100, y: 20, z: 100 }, position: { x: 0, y: 300, z: 0 } })
+  const fastened = applyFigureAuthoring(asset, { kind: 'attach', part: 'lid', face: 'bottom', to: { part: 'body', face: 'top' } })
+  const free = applyFigureAuthoring(fastened, { kind: 'detach', part: 'lid' })
   assert.equal(gizmoReachOf(free as never, 'lid').translate, true)
   const slid = moving(free, 'lid', { kind: 'slide', axis: 'x', id: 'lid-slide', min: 0, max: 100, start: 0 })
-  assert.equal(gizmoReachOf(slid as never, 'lid').translate, false, 'not its own numbers: a drag on a joint edits the joint (v3-joint-drag)')
+  assert.equal(gizmoReachOf(slid as never, 'lid').translate, false, 'not its own numbers: a drag on a joint edits the joint (joint-drag)')
 })
 
 test('끄는 동안은 모아 두고 놓을 때 한 번 적는다 — 크기 기즈모가 편집기와 싸우지 않는다', () => {
-  const canvas = read('../client/modeller/v3-canvas.ts')
+  const canvas = read('../client/modeller/canvas.ts')
   const watch = canvas.slice(canvas.indexOf('  private watchScene()'), canvas.indexOf('  /** Components the gizmo changed'))
   assert.ok(watch.includes('this.pending.set(name, origin!)') && watch.includes('if (!this.pointerDown) this.commitSoon(80)'), '사용자 2026-09-24: 「기즈모 컨트롤 중에 scale은 제대로 작동하지 않는군」')
   assert.ok(!watch.includes("new CustomEvent('part-transformed'"), '움직일 때마다 알리지 않는다')
@@ -120,12 +120,12 @@ test('끄는 동안은 모아 두고 놓을 때 한 번 적는다 — 크기 기
 
 
 test('원기둥 · 구도 크기 기즈모가 먹는다 — 단면은 원으로', async () => {
-  const { addV3Primitive, createV3Asset } = await import('@hatiolab/figure-model')
-  const { paletteRecipe } = await import('../client/modeller/v3-palette.ts')
-  const { gizmoChanges, gizmoReachOf } = await import('../client/modeller/v3-gizmo.ts')
-  let asset = createV3Asset('Round') as any
-  asset = addV3Primitive(asset, paletteRecipe('cylinder', 'drum') as any)
-  asset = addV3Primitive(asset, paletteRecipe('sphere', 'ball') as any)
+  const { addFigurePrimitive, createFigureAsset } = await import('@hatiolab/figure-model')
+  const { paletteRecipe } = await import('../client/modeller/palette.ts')
+  const { gizmoChanges, gizmoReachOf } = await import('../client/modeller/gizmo.ts')
+  let asset = createFigureAsset('Round') as any
+  asset = addFigurePrimitive(asset, paletteRecipe('cylinder', 'drum') as any)
+  asset = addFigurePrimitive(asset, paletteRecipe('sphere', 'ball') as any)
   const values = { ...asset.designInputs }
   const drum = gizmoReachOf(asset, 'drum')
   assert.equal(drum.scale, true, '원기둥도 크기를 받는다')
@@ -144,13 +144,13 @@ test('원기둥 · 구도 크기 기즈모가 먹는다 — 단면은 원으로'
  * 묻혔다(09-26). 돌려 세운 부품은 그 높이가 위아래가 아니라 건드리지 않는다.
  */
 test('높이 칸 — 아랫면을 지킨다, 손잡이처럼', async () => {
-  const { keepBottomChanges } = await import('../client/modeller/v3-gizmo.ts')
-  let asset = createV3Asset('Post')
-  asset = addV3Box(asset, { id: 'post', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
-  asset = addV3Primitive(asset, { id: 'drum', kind: 'cylinder', dimensions: { radius: 50, length: 100 }, position: { x: 0, y: 300, z: 0 } })
-  asset = addV3Primitive(asset, { id: 'roller', kind: 'cylinder', dimensions: { radius: 30, length: 500 }, position: { x: 0, y: 30, z: 0 }, rotation: { x: 90, y: 0, z: 0 } })
+  const { keepBottomChanges } = await import('../client/modeller/gizmo.ts')
+  let asset = createFigureAsset('Post')
+  asset = addFigureBox(asset, { id: 'post', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+  asset = addFigurePrimitive(asset, { id: 'drum', kind: 'cylinder', dimensions: { radius: 50, length: 100 }, position: { x: 0, y: 300, z: 0 } })
+  asset = addFigurePrimitive(asset, { id: 'roller', kind: 'cylinder', dimensions: { radius: 30, length: 500 }, position: { x: 0, y: 30, z: 0 }, rotation: { x: 90, y: 0, z: 0 } })
   const bottom = (a: typeof asset, part: string) => {
-    const g = compileV3Asset(a).evaluate().geometry.find(o => o.id === part)! as unknown as { pose: { t: number[] } }
+    const g = compileFigureAsset(a).evaluate().geometry.find(o => o.id === part)! as unknown as { pose: { t: number[] } }
     return g.pose.t[1]!
   }
   const grow = (part: string, input: string, value: number) => {
@@ -166,12 +166,12 @@ test('높이 칸 — 아랫면을 지킨다, 손잡이처럼', async () => {
   const rollerLength = gizmoReachOf(asset, 'roller').round!.along[0]!
   assert.deepEqual(keepBottomChanges('roller', gizmoReachOf(asset, 'roller'), rollerLength, 800, asset.designInputs), [], '누운 롤러의 길이는 위아래가 아니다')
   assert.deepEqual(keepBottomChanges('post', gizmoReachOf(asset, 'post'), gizmoReachOf(asset, 'post').sizes![0], 800, asset.designInputs), [], '폭은 가운데 그대로')
-  assert.ok(read('../client/modeller/v3-editor.ts').includes('keepBottomChanges('), '숫자 칸이 부른다')
+  assert.ok(read('../client/modeller/editor.ts').includes('keepBottomChanges('), '숫자 칸이 부른다')
 })
 
 /* 손잡이는 키를 몰라도 찾는다 — 도구 막대에 옮기기 · 돌리기 · 크기, 제 숫자로 놓인 부품에만 (09-26). */
 test('도구 막대의 옮기기 · 돌리기 · 크기 — 키와 같은 길, 되쓸 수 있는 것만', () => {
-  const editor = read('../client/modeller/v3-editor.ts')
+  const editor = read('../client/modeller/editor.ts')
   const bar = editor.slice(editor.indexOf('return html`<ox-canvas-bar'), editor.indexOf('</ox-canvas-bar>'))
   assert.ok(bar.includes("this.renderGizmoTools(!unavailable && this.middle === 'edit')"), '편집 중에만')
   const tools = editor.slice(editor.indexOf('  private renderGizmoTools('), editor.indexOf("  /** The modeller's keys"))

package/test/{v3-joint-drag.test.ts → joint-drag.test.ts}

@@ -5,24 +5,24 @@
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { addV3Box, applyV3Authoring, compileV3Asset, createV3Asset } from '@hatiolab/figure-model'
-import type { V3Asset, V3Joint } from '@hatiolab/figure-model'
-import { jointDragOf } from '../client/modeller/v3-joint-drag.ts'
+import { addFigureBox, applyFigureAuthoring, compileFigureAsset, createFigureAsset } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureJoint } from '@hatiolab/figure-model'
+import { jointDragOf } from '../client/modeller/joint-drag.ts'
 
 /** A post on the floor, and a link on its top. */
-function column(joint: Partial<V3Joint>): V3Asset {
-  let asset = createV3Asset('Column')
-  asset = addV3Box(asset, { id: 'post', size: { x: 100, y: 200, z: 100 }, position: { x: 0, y: 100, z: 0 } })
-  asset = addV3Box(asset, { id: 'link', size: { x: 60, y: 300, z: 60 }, position: { x: 0, y: 350, z: 0 } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'post', face: 'bottom', to: { plane: 'mounting-plane' } })
-  return applyV3Authoring(asset, {
+function column(joint: Partial<FigureJoint>): FigureAsset {
+  let asset = createFigureAsset('Column')
+  asset = addFigureBox(asset, { id: 'post', size: { x: 100, y: 200, z: 100 }, position: { x: 0, y: 100, z: 0 } })
+  asset = addFigureBox(asset, { id: 'link', size: { x: 60, y: 300, z: 60 }, position: { x: 0, y: 350, z: 0 } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'post', face: 'bottom', to: { plane: 'mounting-plane' } })
+  return applyFigureAuthoring(asset, {
     kind: 'set-joint',
-    joint: { id: 'bend', type: 'fixed', body0: { part: 'post', face: 'top' }, body1: { part: 'link', face: 'bottom' }, ...joint } as V3Joint
+    joint: { id: 'bend', type: 'fixed', body0: { part: 'post', face: 'top' }, body1: { part: 'link', face: 'bottom' }, ...joint } as FigureJoint
   })
 }
 
-const drawn = (asset: V3Asset, id: string, state: Record<string, number> = {}) =>
-  compileV3Asset(asset).evaluate(state).geometry.find(g => g.id === id) as never as { id: string; pose: { t: number[]; r: number[][] } }
+const drawn = (asset: FigureAsset, id: string, state: Record<string, number> = {}) =>
+  compileFigureAsset(asset).evaluate(state).geometry.find(g => g.id === id) as never as { id: string; pose: { t: number[]; r: number[][] } }
 
 /** The link turned `deg` about Z, as the gizmo would report it (degrees, XYZ). */
 const turnedZ = (deg: number) => [0, 0, deg] as [number, number, number]
@@ -58,7 +58,7 @@ test('고정 관절에 달린 부품을 옮기면 관절이 놓인 자리 —
   const up = jointDragOf(asset, 'link', part as never, { position: [part.pose.t[0]!, part.pose.t[1]! + 25, part.pose.t[2]!] }, {})
   assert.deepEqual(up, { kind: 'joint', joint: { ...asset.joints!.find(j => j.id === 'bend')!, origin: { gap: 25 } } })
   const aside = jointDragOf(asset, 'link', part as never, { position: [part.pose.t[0]! + 30, part.pose.t[1]!, part.pose.t[2]!] }, {})
-  assert.deepEqual((aside as { joint: V3Joint }).joint.origin, { align: { x: { mm: 30 } } })
+  assert.deepEqual((aside as { joint: FigureJoint }).joint.origin, { align: { x: { mm: 30 } } })
 })
 
 test('관계를 끊는 끌기는 거절하고 까닭을 댄다', () => {
@@ -72,16 +72,16 @@ test('관계를 끊는 끌기는 거절하고 까닭을 댄다', () => {
 })
 
 test('관절이 없는 부품은 이 길로 오지 않는다 — 제 숫자를 쓰는 길', () => {
-  let asset = createV3Asset('Free')
-  asset = addV3Box(asset, { id: 'box', size: { x: 10, y: 10, z: 10 }, position: { x: 0, y: 5, z: 0 } })
+  let asset = createFigureAsset('Free')
+  asset = addFigureBox(asset, { id: 'box', size: { x: 10, y: 10, z: 10 }, position: { x: 0, y: 5, z: 0 } })
   assert.equal(jointDragOf(asset, 'box', drawn(asset, 'box') as never, { position: [10, 5, 0] }, {}), null)
 })
 
 test('크기 끌기는 관절이 아니라 부품의 치수 — 따라가는 치수는 두고 제 치수만 쓴다 (사용자 09-25: 「R 모드에서 크기가 변하지 않는다」)', async () => {
-  const { gizmoChanges, gizmoReachOf } = await import('../client/modeller/v3-gizmo.ts')
+  const { gizmoChanges, gizmoReachOf } = await import('../client/modeller/gizmo.ts')
   let asset = column({ type: 'revolute', axis: 'Z', lowerLimit: -90, upperLimit: 90 })
   /* A square section: the link's depth follows its width. */
-  asset = applyV3Authoring(asset, { kind: 'link-dimension', part: 'link', axis: 'z', source: { of: 'part', part: 'link', axis: 'x' } })
+  asset = applyFigureAuthoring(asset, { kind: 'link-dimension', part: 'link', axis: 'z', source: { of: 'part', part: 'link', axis: 'x' } })
   const part = drawn(asset, 'link')
   const scaled = { position: [part.pose.t[0]!, part.pose.t[1]! + 60, part.pose.t[2]!] as [number, number, number], scale: [1, 1.4, 1] as [number, number, number] }
   assert.equal(jointDragOf(asset, 'link', part as never, scaled, {}), null, '관절 자리로 받지 않는다')

package/test/{v3-joint-fan.test.ts → joint-fan.test.ts}

@@ -8,20 +8,20 @@ import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 
-import { addV3Box, applyV3Authoring, compileV3Asset, createV3Asset } from '@hatiolab/figure-model'
-import type { V3Asset } from '@hatiolab/figure-model'
+import { addFigureBox, applyFigureAuthoring, compileFigureAsset, createFigureAsset } from '@hatiolab/figure-model'
+import type { FigureAsset } from '@hatiolab/figure-model'
 
-import { JOINT_FAN, jointFanOf } from '../client/modeller/v3-joint-fan.ts'
+import { JOINT_FAN, jointFanOf } from '../client/modeller/joint-fan.ts'
 import { moving } from './joints.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 
-function arm(): V3Asset {
-  let asset = createV3Asset('Probe')
-  asset = addV3Box(asset, { id: 'base', size: { x: 200, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
-  asset = addV3Box(asset, { id: 'arm', size: { x: 400, y: 50, z: 50 }, position: { x: 200, y: 125, z: 0 } })
+function arm(): FigureAsset {
+  let asset = createFigureAsset('Probe')
+  asset = addFigureBox(asset, { id: 'base', size: { x: 200, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
+  asset = addFigureBox(asset, { id: 'arm', size: { x: 400, y: 50, z: 50 }, position: { x: 200, y: 125, z: 0 } })
   /* On the base's top, level with its left edge: it turns about that edge, at x = -100. */
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'arm', face: 'bottom', to: { part: 'base', face: 'top' }, align: { x: 'min' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'arm', face: 'bottom', to: { part: 'base', face: 'top' }, align: { x: 'min' } })
   return moving(asset, 'arm', { kind: 'turn', axis: 'y', id: 'arm.turn', min: -45, max: 90 })
 }
 const PIVOT = [-100, 100, 0]
@@ -48,7 +48,7 @@ test('a part that turns gets a fan from the lowest value to the highest, where t
   assert.deepEqual(profile[0], { x: 0, y: 0 }, 'not a full turn: the fan starts at the pivot')
 
   const armAt = (deg: number) => {
-    const body = compileV3Asset({ ...asset, stateDefaults: { ...asset.stateDefaults, 'arm.turn': deg } }).evaluate().geometry.find(g => g.id === 'arm')!
+    const body = compileFigureAsset({ ...asset, stateDefaults: { ...asset.stateDefaults, 'arm.turn': deg } }).evaluate().geometry.find(g => g.id === 'arm')!
     return direction((body as unknown as { pose: { t: number[] } }).pose.t)
   }
   const first = direction(world(fan, profile[1]!))
@@ -73,17 +73,17 @@ test('no fan for a part that does not turn, nor for a slide -- a fan in a guesse
   const ofArm = jointFanOf(arm(), 'arm') as unknown as { shape: { profile: unknown[] } }
   assert.deepEqual(onBase?.shape.profile, ofArm.shape.profile)
   assert.equal(jointFanOf(arm(), ''), null)
-  let slider = createV3Asset('Probe')
-  slider = addV3Box(slider, { id: 'block', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+  let slider = createFigureAsset('Probe')
+  slider = addFigureBox(slider, { id: 'block', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
   slider = moving(slider, 'block', { kind: 'slide', axis: 'x', id: 'shift', min: 0, max: 60 })
   assert.equal(jointFanOf(slider, 'block'), null)
 })
 
 test('the editor draws it for the selected part, with the pose in hand; the canvas never lets it be picked', () => {
-  const editor = read('../client/modeller/v3-editor.ts')
-  assert.ok(editor.includes('.fan=${this.fanOf(asset as V3Asset | undefined)}'))
+  const editor = read('../client/modeller/editor.ts')
+  assert.ok(editor.includes('.fan=${this.fanOf(asset as FigureAsset | undefined)}'))
   assert.ok(editor.includes('return jointFanOf(asset, this.selected, { ...this.currentInputs(), ...this.live.values })'), 'the fan reads the pose the session holds')
-  const canvas = read('../client/modeller/v3-canvas.ts')
+  const canvas = read('../client/modeller/canvas.ts')
   assert.ok(canvas.includes('{ ...fan, capturable: false, locked: true }'))
 })
 
@@ -94,8 +94,8 @@ test('the editor draws it for the selected part, with the pose in hand; the canv
  * the hinge centred on the wrist's axis (as ROBOT_ARM's elbow-housing is the elbow's); `badge` rides the hinge and holds
  * no pivot.
  */
-const fixture = (name: string): V3Asset => JSON.parse(readFileSync(fileURLToPath(new URL(`./fixtures/${name}.json`, import.meta.url)), 'utf8'))
-function column(): V3Asset {
+const fixture = (name: string): FigureAsset => JSON.parse(readFileSync(fileURLToPath(new URL(`./fixtures/${name}.json`, import.meta.url)), 'utf8'))
+function column(): FigureAsset {
   return fixture('joint-column')
 }
 
@@ -124,7 +124,7 @@ for (const [part, joint] of [
     const pivot = fan.pose.t
     const axis = [0, 1, 2].map(i => fan.pose.r[i]![1]!)
     const at = (s: number) =>
-      compileV3Asset({ ...asset, stateDefaults: { ...asset.stateDefaults, [joint]: s } }).evaluate().geometry.find(g => g.id === part) as unknown as { pose: { t: number[]; r: number[][] } }
+      compileFigureAsset({ ...asset, stateDefaults: { ...asset.stateDefaults, [joint]: s } }).evaluate().geometry.find(g => g.id === part) as unknown as { pose: { t: number[]; r: number[][] } }
     const onFan = (p: { x: number; y: number }) => [0, 1, 2].map(i => pivot[i]! + fan.pose.r[i]![0]! * p.x + fan.pose.r[i]![2]! * p.y)
     const flat = (v: number[]) => sub(v, axis.map(a => a * dot(v, axis)))
 
@@ -160,7 +160,7 @@ test('a housing shows the joint it houses, not the one that carries it; a part t
   const axis = [0, 1, 2].map(i => fan.pose.r[i]![1]!)
   const flat = (v: number[]) => sub(v, axis.map(a => a * dot(v, axis)))
   const onFan = (p: { x: number; y: number }) => [0, 1, 2].map(i => fan.pose.t[i]! + fan.pose.r[i]![0]! * p.x + fan.pose.r[i]![2]! * p.y)
-  const tipAt = (s: number) => (compileV3Asset({ ...asset, stateDefaults: { ...asset.stateDefaults, wrist: s } }).evaluate().geometry.find(g => g.id === 'tip') as unknown as { pose: { t: number[] } }).pose.t
+  const tipAt = (s: number) => (compileFigureAsset({ ...asset, stateDefaults: { ...asset.stateDefaults, wrist: s } }).evaluate().geometry.find(g => g.id === 'tip') as unknown as { pose: { t: number[] } }).pose.t
   const edges = fan.shape.profile.filter(p => p.x !== 0 || p.y !== 0)
   assert.ok(angle(flat(sub(onFan(edges[0]!), fan.pose.t)), flat(sub(tipAt(-120), fan.pose.t))) < 0.01)
   assert.ok(angle(flat(sub(onFan(edges[edges.length - 1]!), fan.pose.t)), flat(sub(tipAt(120), fan.pose.t))) < 0.01)

package/test/joints.ts

@@ -2,24 +2,24 @@
  * Moving a part in a test, as the modeller does it now (ADR-0093): the joint above the part is given a turn or a
  * slide. A part fastened to nothing is stood on the floor first -- a joint has a parent.
  */
-import { applyV3Authoring } from '@hatiolab/figure-model'
-import type { V3Asset, V3Joint } from '@hatiolab/figure-model'
+import { applyFigureAuthoring } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureJoint } from '@hatiolab/figure-model'
 
 export function moving(
-  asset: V3Asset,
+  asset: FigureAsset,
   part: string,
   spec: { kind: 'slide' | 'turn'; axis: 'x' | 'y' | 'z'; id: string; min: number; max: number; start?: number }
-): V3Asset {
+): FigureAsset {
   /* Stood on the floor where it is: its X and Z kept as offsets on the plane. */
   const at = (axis: 'x' | 'z') => ({ mm: asset.designInputs[`${part}.position.${axis}`] ?? 0 })
-  const above: V3Joint = asset.joints?.find(j => j.body1.part === part) ?? {
+  const above: FigureJoint = asset.joints?.find(j => j.body1.part === part) ?? {
     id: part,
     type: 'fixed',
     body0: { plane: 'mounting-plane' },
     body1: { part, face: 'bottom' },
     origin: { align: { x: at('x'), z: at('z') } }
   }
-  return applyV3Authoring(asset, {
+  return applyFigureAuthoring(asset, {
     kind: 'set-joint',
     joint: {
       ...above,

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

@@ -6,7 +6,7 @@ import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 
-import { keyActionOf } from '../client/modeller/v3-keys.ts'
+import { keyActionOf } from '../client/modeller/keys.ts'
 
 test('되돌리기 · 다시 하기 — Ctrl 과 Cmd 모두, 부품을 고르지 않아도', () => {
   assert.equal(keyActionOf({ key: 'z', ctrlKey: true }, ''), 'undo')
@@ -31,7 +31,7 @@ test('칸에 치는 키는 칸의 것 — 이름 칸의 Backspace 는 글자를
 })
 
 test('편집기가 창의 키를 듣고, 떼어지면 놓는다', () => {
-  const editor = readFileSync(fileURLToPath(new URL('../client/modeller/v3-editor.ts', import.meta.url)), 'utf8')
+  const editor = readFileSync(fileURLToPath(new URL('../client/modeller/editor.ts', import.meta.url)), 'utf8')
   assert.ok(editor.includes("window.addEventListener('keydown', this.onKey, true)") && editor.includes("window.removeEventListener('keydown', this.onKey, true)"))
 })