@things-factory/figure-ui 10.1.75 → 10.1.77

package/test/{v3-product-session.test.ts → product-session.test.ts}

@@ -1,11 +1,11 @@
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
-import { createV3Asset, addV3Box, serializeV3Asset } from '@hatiolab/figure-model'
-import { createV3ProductSession, type V3ProductRecord } from '../client/modeller/v3-product-session.js'
+import { createFigureAsset, addFigureBox, serializeFigureAsset } from '@hatiolab/figure-model'
+import { createFigureProductSession, type FigureProductRecord } from '../client/modeller/product-session.js'
 
 const source = (name = 'sample') =>
-  serializeV3Asset(
-    addV3Box(createV3Asset(name), {
+  serializeFigureAsset(
+    addFigureBox(createFigureAsset(name), {
       id: 'body',
       size: { x: 100, y: 100, z: 100 },
       position: { x: 0, y: 50, z: 0 }
@@ -25,7 +25,7 @@ const store = {
 }
 
 test('existing model -> new clears geometry, ID, history and derived state', async () => {
-  const s = createV3ProductSession(store)
+  const s = createFigureProductSession(store)
   await s.open('A')
   assert.equal(s.read().geometry.length, 1)
   const v = s.startNew()
@@ -33,18 +33,18 @@ test('existing model -> new clears geometry, ID, history and derived state', asy
   assert.equal(v.geometry.length, 0)
   assert.equal(v.canUndo, false)
   assert.equal(v.dirty, false)
-  assert.equal(JSON.parse(s.source()).version, 'figure-v3-asset-1')
+  assert.equal(JSON.parse(s.source()).version, 'figure-asset-1')
 })
 test('late load cannot overwrite another model or a new figure', async () => {
-  const pending = deferred<V3ProductRecord>()
-  const s = createV3ProductSession({ ...store, load: id => (id === 'A' ? pending.promise : store.load(id)) })
+  const pending = deferred<FigureProductRecord>()
+  const s = createFigureProductSession({ ...store, load: id => (id === 'A' ? pending.promise : store.load(id)) })
   const first = s.open('A')
   await s.open('B')
   pending.resolve({ id: 'A', source: source('A') })
   await first
   assert.equal(s.read().id, 'B')
-  const p = deferred<V3ProductRecord>(),
-    t = createV3ProductSession({ ...store, load: () => p.promise })
+  const p = deferred<FigureProductRecord>(),
+    t = createFigureProductSession({ ...store, load: () => p.promise })
   const loading = t.open('A')
   t.startNew()
   p.resolve({ id: 'A', source: source() })
@@ -53,7 +53,7 @@ test('late load cannot overwrite another model or a new figure', async () => {
   assert.equal(t.read().geometry.length, 0)
 })
 test('failed load hides previous geometry and cannot save under the failed ID', async () => {
-  const s = createV3ProductSession({ ...store, load: async id => ({ id, source: id === 'bad' ? '{}' : source() }) })
+  const s = createFigureProductSession({ ...store, load: async id => ({ id, source: id === 'bad' ? '{}' : source() }) })
   await s.open('A')
   await s.open('bad')
   assert.equal(s.read().geometry.length, 0)
@@ -62,7 +62,7 @@ test('failed load hides previous geometry and cannot save under the failed ID',
   await assert.rejects(s.save())
 })
 test('UI and AI use a shared revision and history; stale/cross-model AI is rejected', async () => {
-  const s = createV3ProductSession(store)
+  const s = createFigureProductSession(store)
   await s.open('A')
   const before = s.read(),
     changes = [{ kind: 'set-design' as const, input: 'body.size.y', unit: 'mm' as const, value: 150 }]
@@ -76,7 +76,7 @@ test('UI and AI use a shared revision and history; stale/cross-model AI is rejec
 })
 test('save carries exact baseline and acknowledges only matching response', async () => {
   let baseline: string | undefined
-  const s = createV3ProductSession({
+  const s = createFigureProductSession({
     ...store,
     save: async q => {
       baseline = q.expectedSource
@@ -93,8 +93,8 @@ test('save carries exact baseline and acknowledges only matching response', asyn
   assert.equal(s.read().dirty, true)
 })
 test('pending save locks edits/navigation and duplicate create', async () => {
-  const p = deferred<V3ProductRecord>(),
-    s = createV3ProductSession({ ...store, save: () => p.promise })
+  const p = deferred<FigureProductRecord>(),
+    s = createFigureProductSession({ ...store, save: () => p.promise })
   s.startNew()
   const text = s.source(),
     saving = s.save()
@@ -106,7 +106,7 @@ test('pending save locks edits/navigation and duplicate create', async () => {
   assert.equal(s.read().id, 'new')
 })
 test('save failure preserves edits and allows retry; wrong acknowledgement never clears dirty', async () => {
-  const s = createV3ProductSession({ ...store, save: async () => ({ id: 'wrong', source: source() }) })
+  const s = createFigureProductSession({ ...store, save: async () => ({ id: 'wrong', source: source() }) })
   await s.open('A')
   s.apply([{ kind: 'set-design', input: 'body.size.y', unit: 'mm', value: 200 }])
   await assert.rejects(s.save())
@@ -116,7 +116,7 @@ test('save failure preserves edits and allows retry; wrong acknowledgement never
 })
 test('retry after a lost create response reuses the same creation identity', async () => {
   const keys: string[] = []
-  const s = createV3ProductSession({
+  const s = createFigureProductSession({
     ...store,
     save: async q => {
       keys.push(q.creationId!)

package/test/{v3-product-write.test.ts → product-write.test.ts}

@@ -1,12 +1,12 @@
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
-import { addV3Box, createV3Asset, serializeV3Asset } from '@hatiolab/figure-model'
-import { prepareV3Write, compareAndSwapV3 } from '../../figure-service/server/service/figure/figure-v3-write.js'
+import { addFigureBox, createFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
+import { prepareFigureWrite, compareAndSwapFigure } from '../../figure-service/server/service/figure/figure-write.js'
 import { DatabaseSync } from 'node:sqlite'
 
-test('V3 saves preserve the graph and clear unmeasured previous scores', () => {
-  const source = serializeV3Asset(createV3Asset('빈 자산'))
-  const saved = prepareV3Write(source)
+test('saves preserve the graph and clear unmeasured previous scores', () => {
+  const source = serializeFigureAsset(createFigureAsset('빈 자산'))
+  const saved = prepareFigureWrite(source)
   assert.equal(saved.source, source)
   assert.equal(saved.name, '빈 자산')
   /* 점수는 저장할 때 재지 않으므로 비운다. */
@@ -16,26 +16,26 @@ test('V3 saves preserve the graph and clear unmeasured previous scores', () => {
   assert.equal(saved.groups, 0)
   assert.equal(saved.state, 'draft')
 })
-test('V3 예산은 실제로 그리는 것을 센다 — 상자 하나는 삼각형 12 다', () => {
-  const asset = addV3Box(createV3Asset('상자'), {
+test('예산은 실제로 그리는 것을 센다 — 상자 하나는 삼각형 12 다', () => {
+  const asset = addFigureBox(createFigureAsset('상자'), {
     id: 'body',
     size: { x: 100, y: 100, z: 100 },
     position: { x: 0, y: 50, z: 0 }
   })
-  const saved = prepareV3Write(serializeV3Asset(asset))
+  const saved = prepareFigureWrite(serializeFigureAsset(asset))
   assert.equal(saved.triangles, 12)
   assert.equal(saved.groups, 1)
 })
 test('source concurrency check requires exact baseline; no implicit overwrite', () => {
-  const source = serializeV3Asset(createV3Asset('A'))
-  assert.throws(() => prepareV3Write(source, { source }))
-  assert.throws(() => prepareV3Write(source, { source }, 'changed'))
-  assert.equal(prepareV3Write(source, { source }, source).source, source)
+  const source = serializeFigureAsset(createFigureAsset('A'))
+  assert.throws(() => prepareFigureWrite(source, { source }))
+  assert.throws(() => prepareFigureWrite(source, { source }, 'changed'))
+  assert.equal(prepareFigureWrite(source, { source }, source).source, source)
 })
-test('old/invalid/duplicate-key sources never become a V3 saved draft', () => {
-  assert.throws(() => prepareV3Write('{"version":2,"parts":[]}'))
-  assert.throws(() => prepareV3Write('{"version":1,"version":2}'))
-  assert.throws(() => prepareV3Write('{'))
+test('old/invalid/duplicate-key sources never become a saved draft', () => {
+  assert.throws(() => prepareFigureWrite('{"version":2,"parts":[]}'))
+  assert.throws(() => prepareFigureWrite('{"version":1,"version":2}'))
+  assert.throws(() => prepareFigureWrite('{'))
 })
 
 test('SQLite compare-and-swap rejects a stale editor and another tenant', async () => {
@@ -49,10 +49,10 @@ test('SQLite compare-and-swap rejects a stale editor and another tenant', async
         .run('next', where.id, where.domain.id, where.source)
       return { affected: Number(result.changes) }
     }
-    await assert.rejects(compareAndSwapV3(update, 'A', 'tenant-B', 'original'))
-    await compareAndSwapV3(update, 'A', 'tenant-A', 'original')
-    await assert.rejects(compareAndSwapV3(update, 'A', 'tenant-A', 'original'))
-    await assert.rejects(compareAndSwapV3(update, 'A', 'tenant-A', undefined))
+    await assert.rejects(compareAndSwapFigure(update, 'A', 'tenant-B', 'original'))
+    await compareAndSwapFigure(update, 'A', 'tenant-A', 'original')
+    await assert.rejects(compareAndSwapFigure(update, 'A', 'tenant-A', 'original'))
+    await assert.rejects(compareAndSwapFigure(update, 'A', 'tenant-A', undefined))
     assert.equal(db.prepare('SELECT source FROM figures WHERE id=?').get('A')!.source, 'next')
   } finally {
     db.close()

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

@@ -9,18 +9,18 @@ import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 
-import { addV3Box, applyV3Authoring, createV3Asset, inspectV3Asset, parseV3Asset, serializeV3Asset } from '@hatiolab/figure-model'
+import { addFigureBox, applyFigureAuthoring, createFigureAsset, inspectFigureAsset, parseFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
 
-import { tagsOf, v3FigureFacts } from '../client/modeller/v3-figure-facts.ts'
-import { occupancyFromParts } from '../client/modeller/v3-occupancy.ts'
+import { tagsOf, figureFigureFacts } from '../client/modeller/figure-facts.ts'
+import { occupancyFromParts } from '../client/modeller/occupancy.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 } })
+  let asset = createFigureAsset('Probe')
+  asset = addFigureBox(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
   return asset
 }
-const facts = (asset: ReturnType<typeof probe>) => v3FigureFacts(serializeV3Asset(asset))
+const facts = (asset: ReturnType<typeof probe>) => figureFigureFacts(serializeFigureAsset(asset))
 
 test('탭이 읽는 사실 — 선언 전에는 배치 기준도 장착면도 「없음」이다', () => {
   const read = facts(probe())
@@ -32,25 +32,25 @@ test('탭이 읽는 사실 — 선언 전에는 배치 기준도 장착면도
 })
 
 test('배치 기준을 고르면 그 기준으로 공간을 선언한다 — 판정도 풀린다', () => {
-  const source = serializeV3Asset(probe())
-  const declared = applyV3Authoring(parseV3Asset(source), occupancyFromParts(source, 'ceiling'))
+  const source = serializeFigureAsset(probe())
+  const declared = applyFigureAuthoring(parseFigureAsset(source), occupancyFromParts(source, 'ceiling'))
 
   assert.equal(facts(declared).placement, 'ceiling')
   assert.equal(facts(declared).declared, true)
-  assert.ok(!inspectV3Asset(declared).violations.some(v => v.code === 'OCCUPANCY_UNDECLARED'))
+  assert.ok(!inspectFigureAsset(declared).violations.some(v => v.code === 'OCCUPANCY_UNDECLARED'))
 })
 
 test('장착면을 정하면 탭이 그 부품과 면을 다시 읽고, 해제하면 없어진다', () => {
-  const source = serializeV3Asset(probe())
-  const declared = applyV3Authoring(parseV3Asset(source), occupancyFromParts(source))
-  const mounted = applyV3Authoring(declared, { kind: 'set-mounting-face', part: 'body', face: 'bottom' })
+  const source = serializeFigureAsset(probe())
+  const declared = applyFigureAuthoring(parseFigureAsset(source), occupancyFromParts(source))
+  const mounted = applyFigureAuthoring(declared, { kind: 'set-mounting-face', part: 'body', face: 'bottom' })
 
   assert.deepEqual(facts(mounted).mounting, { part: 'body', face: 'bottom' })
-  assert.equal(facts(applyV3Authoring(mounted, { kind: 'clear-mounting-face' })).mounting, undefined)
+  assert.equal(facts(applyFigureAuthoring(mounted, { kind: 'clear-mounting-face' })).mounting, undefined)
 })
 
 test('이름을 바꾸면 자산의 이름이 바뀐다 — 저장하면 목록 이름이 이것을 따른다', () => {
-  assert.equal(facts(applyV3Authoring(probe(), { kind: 'rename', name: 'Roller conveyor' })).name, 'Roller conveyor')
+  assert.equal(facts(applyFigureAuthoring(probe(), { kind: 'rename', name: 'Roller conveyor' })).name, 'Roller conveyor')
 })
 
 test('태그 줄은 쉼표로 나뉘어 목록이 된다', () => {
@@ -58,14 +58,14 @@ test('태그 줄은 쉼표로 나뉘어 목록이 된다', () => {
   assert.deepEqual(tagsOf(''), [], '빈 줄은 전부 지우는 것이다')
 })
 
-const page = read('../client/pages/figure-v3-modeller-page.ts')
+const page = read('../client/pages/figure-modeller-page.ts')
 
 test('화면이 속성 탭을 걸고, 명령은 세션의 이력 하나로, 분류 · 태그는 행으로 간다', () => {
-  const editor = read('../client/modeller/v3-editor.ts')
+  const editor = read('../client/modeller/editor.ts')
   assert.ok(/renderTab\('properties', 'tune'/.test(editor), '속성 탭은 편집기의 오른쪽 칸에')
-  assert.ok(/<figure-v3-properties\s+slot="figure"/.test(page), '도형 속성은 부품을 고르지 않았을 때 속성 탭에 선다')
+  assert.ok(/<figure-properties\s+slot="figure"/.test(page), '도형 속성은 부품을 고르지 않았을 때 속성 탭에 선다')
   assert.ok(editor.includes('<slot name="figure"></slot>'))
-  assert.ok(/@v3-command=\$\{this\.onCommand\}/.test(page) && /@v3-catalog=\$\{this\.onCatalog\}/.test(page))
+  assert.ok(/@command=\$\{this\.onCommand\}/.test(page) && /@catalog=\$\{this\.onCatalog\}/.test(page))
   const run = page.slice(page.indexOf('private runCommand'), page.indexOf('private onCatalog'))
   assert.ok(/this\.session\.command\(actionOf\(\)\)/.test(run), '명령은 세션을 지난다 — 되돌리기가 먹는다')
   const catalog = page.slice(page.indexOf('private onCatalog'), page.indexOf('private released'))
@@ -83,7 +83,7 @@ test('발행한 뒤에도 행의 타입이 남는다 — 새로 짜면 잠긴
 })
 
 test('속성 탭의 말은 다섯 말 모두에 있다', () => {
-  const tab = read('../client/modeller/figure-v3-properties.ts')
+  const tab = read('../client/modeller/figure-properties.ts')
   assert.ok(tab.includes('occupancyFromParts(this.source, placement)'), '고른 배치 기준으로 선언한다')
   const keys = [...tab.matchAll(/'(figure\.[a-z.-]*[a-z])'/g)].map(m => m[1])
   for (const face of ['left', 'right', 'bottom', 'top', 'back', 'front']) keys.push(`figure.label.face-${face}`)
@@ -97,12 +97,12 @@ test('속성 탭의 말은 다섯 말 모두에 있다', () => {
 /* Walk 1 (2026-09-26): the mounting face offered is where the figure meets its plane -- a conveyor's legs, not its bed. */
 test('장착면은 도형이 평면에 닿는 부품으로 권한다 — 다리 위 바닥이 아니라 다리', async () => {
   const fm = await import('@hatiolab/figure-model')
-  let asset = fm.addV3Box(fm.createV3Asset('Conveyor'), { id: 'bed', size: { x: 3000, y: 700, z: 800 }, position: { x: 0, y: 1050, z: 0 } })
-  asset = fm.addV3Box(asset, { id: 'leg', size: { x: 60, y: 700, z: 60 }, position: { x: -1400, y: 350, z: -300 } })
-  asset = fm.applyV3Authoring(asset, { kind: 'attach', part: 'leg', face: 'top', to: { part: 'bed', face: 'bottom' }, align: { x: 'min', z: 'min' } })
-  const facts = v3FigureFacts(fm.serializeV3Asset(asset))
+  let asset = fm.addFigureBox(fm.createFigureAsset('Conveyor'), { id: 'bed', size: { x: 3000, y: 700, z: 800 }, position: { x: 0, y: 1050, z: 0 } })
+  asset = fm.addFigureBox(asset, { id: 'leg', size: { x: 60, y: 700, z: 60 }, position: { x: -1400, y: 350, z: -300 } })
+  asset = fm.applyFigureAuthoring(asset, { kind: 'attach', part: 'leg', face: 'top', to: { part: 'bed', face: 'bottom' }, align: { x: 'min', z: 'min' } })
+  const facts = figureFigureFacts(fm.serializeFigureAsset(asset))
   assert.deepEqual(facts.suggested, { part: 'leg', face: 'bottom' })
   assert.equal(facts.parts[0], 'bed', '목록의 첫 부품은 바닥이다')
-  const panel = readFileSync(fileURLToPath(new URL('../client/modeller/figure-v3-properties.ts', import.meta.url)), 'utf8')
+  const panel = readFileSync(fileURLToPath(new URL('../client/modeller/figure-properties.ts', import.meta.url)), 'utf8')
   assert.ok(panel.includes('[this.pickedPart, mounting?.part, facts.suggested?.part, facts.parts[0]]'), '고른 것 · 정한 것 다음이 권하는 것')
 })

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

@@ -7,7 +7,7 @@ import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 
-import { recipeFieldOf, recipeReady, recipesMatching, recipeValueOf, recipeWord, recipeWorkings, templatesOf } from '../client/modeller/v3-recipes.ts'
+import { recipeFieldOf, recipeReady, recipesMatching, recipeValueOf, recipeWord, recipeWorkings, templatesOf } from '../client/modeller/recipes.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 /* The product's templates, as the server reads them. */
@@ -62,22 +62,22 @@ test('작동 방식은 레시피에서 셈한다 — 미닫이 문: 두 문짝
 })
 
 test('모델러 — 부품 칸의 단추가 카탈로그를 열고, 넣으면 한 단계로 들어가고 창이 닫힌다; 목록은 페이지가 서버에서 한 번 읽는다', () => {
-  const parts = read('../client/modeller/figure-v3-parts.ts')
+  const parts = read('../client/modeller/figure-parts.ts')
   assert.ok(parts.includes("this.ask('open-recipe-catalog', {})"))
-  const editor = read('../client/modeller/v3-editor.ts')
+  const editor = read('../client/modeller/editor.ts')
   const insert = editor.slice(editor.indexOf('  private insertRecipe('), editor.indexOf('  /** The design values of the asset being edited. */'))
-  assert.ok(insert.includes('v3RecipeIdFor(asset, checked)') && insert.includes('this.session!.applyRecipe(steps)') && insert.includes('this.catalogOpen = false'))
+  assert.ok(insert.includes('figureRecipeIdFor(asset, checked)') && insert.includes('this.session!.applyRecipe(steps)') && insert.includes('this.catalogOpen = false'))
   assert.ok(insert.includes('this.recipeError = recipeRefusalOf(error, (key, params) => i18next.t(key, params)) ?? this.said(error)'), '거절은 사람의 말로, 막힌 단계와 함께 — 커널의 영어가 아니라 (2026-09-27)')
-  const page = read('../client/pages/figure-v3-modeller-page.ts')
+  const page = read('../client/pages/figure-modeller-page.ts')
   assert.ok(page.includes("availableRecipes(i18next.language || 'en')") && page.includes('.templates=${this.templates}'))
-  const catalog = read('../client/modeller/figure-v3-recipe-catalog.ts')
-  assert.ok(catalog.includes('describeV3Recipe(t.recipe)'), '부품 수는 셈한다')
+  const catalog = read('../client/modeller/figure-recipe-catalog.ts')
+  assert.ok(catalog.includes('describeFigureRecipe(t.recipe)'), '부품 수는 셈한다')
   assert.ok(catalog.includes("${this.guide ? html`<ox-markdown"), '설명이 없으면 아무것도 두지 않는다 — 「준비 중」 없음')
 })
 
 test('넣기는 카탈로그에서 온다 — 편집기는 카탈로그 요소에서 insert-recipe 를 듣는다 (잘못 옮겨진 연결, 09-26)', () => {
-  const editor = read('../client/modeller/v3-editor.ts')
-  const catalog = editor.slice(editor.indexOf('<figure-v3-recipe-catalog'), editor.indexOf('</figure-v3-recipe-catalog>'))
+  const editor = read('../client/modeller/editor.ts')
+  const catalog = editor.slice(editor.indexOf('<figure-recipe-catalog'), editor.indexOf('</figure-recipe-catalog>'))
   assert.ok(catalog.includes('@insert-recipe=${(e: CustomEvent) => this.insertRecipe(e.detail.recipe, e.detail.values)}'))
 })
 

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

@@ -6,7 +6,7 @@ import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 
-import { sizeRangeRefusalOf } from '../client/modeller/v3-refusals.ts'
+import { sizeRangeRefusalOf } from '../client/modeller/refusals.ts'
 
 const ko = JSON.parse(readFileSync(fileURLToPath(new URL('../translations/ko.json', import.meta.url)), 'utf8'))
 const say = (key: string, params: Record<string, string>) => ko[key].replace(/\{(\w+)\}/g, (_: string, k: string) => params[k] ?? '')
@@ -28,14 +28,14 @@ test('다른 거절은 건드리지 않는다', () => {
 })
 
 test('범위가 받을 수 없는 연결은 같은 연결을 범위를 좁혀 다시 권한다 — 다시 재기로는 풀리지 않는다 (사이징, 2026-09-25)', async () => {
-  const { narrowingRetryOf } = await import('../client/modeller/v3-refusals.ts')
-  const { addV3Box, applyV3Authoring, createV3Asset } = await import('@hatiolab/figure-model')
-  let asset = addV3Box(createV3Asset('Panel'), { id: 'panel', size: { x: 400, y: 400, z: 400 }, position: { x: 0, y: 0, z: 0 } })
-  asset = applyV3Authoring(asset, { kind: 'declare-instance-size', range: { x: { min: 1, max: 4000 }, y: { min: 1, max: 4000 }, z: { min: 1, max: 4000 } }, at: { x: 400, y: 400, z: 400 } })
+  const { narrowingRetryOf } = await import('../client/modeller/refusals.ts')
+  const { addFigureBox, applyFigureAuthoring, createFigureAsset } = await import('@hatiolab/figure-model')
+  let asset = addFigureBox(createFigureAsset('Panel'), { id: 'panel', size: { x: 400, y: 400, z: 400 }, position: { x: 0, y: 0, z: 0 } })
+  asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: { x: { min: 1, max: 4000 }, y: { min: 1, max: 4000 }, z: { min: 1, max: 4000 } }, at: { x: 400, y: 400, z: 400 } })
   const link = { kind: 'link-dimension' as const, part: 'panel', axis: 'x' as const, source: { of: 'instance' as const, axis: 'x' as const }, plus: -50 }
   let error: unknown
   try {
-    applyV3Authoring(asset, link)
+    applyFigureAuthoring(asset, link)
   } catch (e) {
     error = e
   }
@@ -44,24 +44,24 @@ test('범위가 받을 수 없는 연결은 같은 연결을 범위를 좁혀
   assert.ok(offer, '권한다')
   assert.match(offer.label, /figure.button.narrow-range-from .*"axis":"X"/)
   assert.deepEqual(offer.retry, { ...link, narrowRange: true })
-  assert.doesNotThrow(() => applyV3Authoring(asset, offer.retry as never), '권한 것은 받아들여진다')
+  assert.doesNotThrow(() => applyFigureAuthoring(asset, offer.retry as never), '권한 것은 받아들여진다')
   assert.equal(narrowingRetryOf({ kind: 'attach' }, error, say), null, '연결이 아닌 명령에는 권하지 않는다')
 })
 
 test('지우기는 매단 것 · 따라 움직이는 것을 풀어 남기고 그 이름을 한 줄로 말한다; 남는 거절은 공간 선언과 줄 (아키텍트 판정 2026-09-27)', async () => {
-  const { partRefusalOf, removalNoticeOf, editRefusalOf } = await import('../client/modeller/v3-refusals.ts')
+  const { partRefusalOf, removalNoticeOf, editRefusalOf } = await import('../client/modeller/refusals.ts')
   const fm = await import('@hatiolab/figure-model')
   const say = (key: string, p: Record<string, string>) => `${key} ${JSON.stringify(p)}`
-  let a = fm.createV3Asset('Bench')
-  a = fm.addV3Box(a, { id: 'leg', size: { x: 60, y: 700, z: 60 }, position: { x: 0, y: 0, z: 0 } })
-  a = fm.addV3Box(a, { id: 'top', size: { x: 1200, y: 40, z: 600 }, position: { x: 0, y: 0, z: 0 } })
-  a = fm.addV3Box(a, { id: 'lamp', size: { x: 80, y: 80, z: 80 }, position: { x: 0, y: 0, z: 0 } })
-  a = fm.addV3Box(a, { id: 'shade', size: { x: 40, y: 40, z: 40 }, position: { x: 0, y: 0, z: 0 } })
-  a = fm.applyV3Authoring(a, { kind: 'attach', part: 'leg', face: 'bottom', to: { plane: 'mounting-plane' } })
-  a = fm.applyV3Authoring(a, { kind: 'attach', part: 'top', face: 'bottom', to: { part: 'leg', face: 'top' } })
-  a = fm.applyV3Authoring(a, { kind: 'attach', part: 'lamp', face: 'bottom', to: { part: 'top', face: 'top' }, align: { x: { mm: -300 } } })
-  a = fm.applyV3Authoring(a, { kind: 'attach', part: 'shade', face: 'bottom', to: { part: 'top', face: 'top' }, align: { x: { mm: 300 } } })
-  const turn = (asset: typeof a, part: string, extra: object) => fm.applyV3Authoring(asset, { kind: 'set-joint', joint: { ...asset.joints!.find(j => j.body1.part === part)!, type: 'revolute', axis: 'Y', ...extra } as never })
+  let a = fm.createFigureAsset('Bench')
+  a = fm.addFigureBox(a, { id: 'leg', size: { x: 60, y: 700, z: 60 }, position: { x: 0, y: 0, z: 0 } })
+  a = fm.addFigureBox(a, { id: 'top', size: { x: 1200, y: 40, z: 600 }, position: { x: 0, y: 0, z: 0 } })
+  a = fm.addFigureBox(a, { id: 'lamp', size: { x: 80, y: 80, z: 80 }, position: { x: 0, y: 0, z: 0 } })
+  a = fm.addFigureBox(a, { id: 'shade', size: { x: 40, y: 40, z: 40 }, position: { x: 0, y: 0, z: 0 } })
+  a = fm.applyFigureAuthoring(a, { kind: 'attach', part: 'leg', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = fm.applyFigureAuthoring(a, { kind: 'attach', part: 'top', face: 'bottom', to: { part: 'leg', face: 'top' } })
+  a = fm.applyFigureAuthoring(a, { kind: 'attach', part: 'lamp', face: 'bottom', to: { part: 'top', face: 'top' }, align: { x: { mm: -300 } } })
+  a = fm.applyFigureAuthoring(a, { kind: 'attach', part: 'shade', face: 'bottom', to: { part: 'top', face: 'top' }, align: { x: { mm: 300 } } })
+  const turn = (asset: typeof a, part: string, extra: object) => fm.applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...asset.joints!.find(j => j.body1.part === part)!, type: 'revolute', axis: 'Y', ...extra } as never })
   a = turn(a, 'lamp', { state: { id: 'lamp-turn' } })
   a = turn(a, 'shade', { mimic: { joint: 'lamp', multiplier: 1 } })
 
@@ -73,10 +73,10 @@ test('지우기는 매단 것 · 따라 움직이는 것을 풀어 남기고 그
   assert.match(lamp, /removal-own-control .*"part":"shade".*"control":"shade".*"min":"-180".*"max":"180"/, '따르던 것은 제 조작값을 받는다')
   assert.equal(removalNoticeOf(fm.removePart(a, { kind: 'remove-part', target: 'shade' }).notice, say), null, '아무것도 풀지 않았으면 말하지 않는다')
 
-  const declared = fm.applyV3Authoring(a, { kind: 'declare-occupancy', proposal: fm.proposeV3Occupancy(a), placement: 'floor' })
+  const declared = fm.applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'floor' })
   const why = (asset: typeof a, part: string) => {
     try {
-      fm.editV3Part(asset, { kind: 'remove-part', target: part })
+      fm.editFigurePart(asset, { kind: 'remove-part', target: part })
       return 'removed'
     } catch (e) {
       return partRefusalOf(e, part, say)
@@ -84,12 +84,12 @@ test('지우기는 매단 것 · 따라 움직이는 것을 풀어 남기고 그
   }
   assert.match(why(declared, 'shade')!, /part-in-declared-space .*"part":"shade"/, '잎인데 공간 선언에 들어 있다')
 
-  let row = fm.createV3Asset('Conveyor')
-  row = fm.addV3Box(row, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 0, z: 0 } })
-  row = fm.addV3Box(row, { id: 'roller', size: { x: 60, y: 60, z: 560 }, position: { x: 0, y: 0, z: 0 } })
-  row = fm.applyV3Authoring(row, { kind: 'attach', part: 'frame', face: 'bottom', to: { plane: 'mounting-plane' } })
-  row = fm.applyV3Authoring(row, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'frame', face: 'top' } })
-  row = fm.applyV3Authoring(row, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 200 })
+  let row = fm.createFigureAsset('Conveyor')
+  row = fm.addFigureBox(row, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 0, z: 0 } })
+  row = fm.addFigureBox(row, { id: 'roller', size: { x: 60, y: 60, z: 560 }, position: { x: 0, y: 0, z: 0 } })
+  row = fm.applyFigureAuthoring(row, { kind: 'attach', part: 'frame', face: 'bottom', to: { plane: 'mounting-plane' } })
+  row = fm.applyFigureAuthoring(row, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  row = fm.applyFigureAuthoring(row, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 200 })
   assert.match(why(row, 'frame')!, /part-row-along .*"part":"frame".*"rows":"roller"/, '줄이 따라 놓인 부품')
 
   /* A refusal no sentence knows is still said as a refusal, with its code -- never the kernel's English. */
@@ -99,37 +99,37 @@ test('지우기는 매단 것 · 따라 움직이는 것을 풀어 남기고 그
 })
 
 test('공간 선언에 든 부품 — 지우고 공간을 남은 부품에 맞추는 길을 한 번에 권한다(차단기의 떠도는 상자, 09-25)', async () => {
-  const { inDeclaredRoom } = await import('../client/modeller/v3-refusals.ts')
+  const { inDeclaredRoom } = await import('../client/modeller/refusals.ts')
   const fm = await import('@hatiolab/figure-model')
-  let a = fm.addV3Box(fm.createV3Asset('Gate'), { id: 'housing', size: { x: 300, y: 1000, z: 300 }, position: { x: 0, y: 0, z: 0 } })
-  a = fm.addV3Box(a, { id: 'stray', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
-  a = fm.applyV3Authoring(a, { kind: 'attach', part: 'housing', face: 'bottom', to: { plane: 'mounting-plane' } })
-  a = fm.applyV3Authoring(a, { kind: 'attach', part: 'stray', face: 'bottom', to: { plane: 'mounting-plane' } })
-  a = fm.applyV3Authoring(a, { kind: 'declare-occupancy', proposal: fm.proposeV3Occupancy(a), placement: 'floor' })
+  let a = fm.addFigureBox(fm.createFigureAsset('Gate'), { id: 'housing', size: { x: 300, y: 1000, z: 300 }, position: { x: 0, y: 0, z: 0 } })
+  a = fm.addFigureBox(a, { id: 'stray', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+  a = fm.applyFigureAuthoring(a, { kind: 'attach', part: 'housing', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = fm.applyFigureAuthoring(a, { kind: 'attach', part: 'stray', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = fm.applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'floor' })
   let refused: unknown
   try {
-    fm.editV3Part(a, { kind: 'remove-part', target: 'stray' })
+    fm.editFigurePart(a, { kind: 'remove-part', target: 'stray' })
   } catch (e) {
     refused = e
   }
   assert.equal(inDeclaredRoom(refused), true)
   assert.equal(inDeclaredRoom(Object.assign(new Error('PART_REFERENCED: top: top holds leg; take it off first'), { code: 'PART_REFERENCED' })), false, '매단 것은 이 길이 아니다')
-  const after = fm.editV3Part(a, { kind: 'remove-part', target: 'stray', refitRoom: true })
+  const after = fm.editFigurePart(a, { kind: 'remove-part', target: 'stray', refitRoom: true })
   assert.equal(after.document.model.nodes.some(n => n.id === 'stray'), false)
   assert.ok(after.occupancy?.bounds, '공간은 남은 부품으로 다시 선언된다')
-  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("if (!refitRoom && inDeclaredRoom(error)) this.retry = { label: i18next.t('figure.button.remove-and-refit-room', { part: id }), run: () => this.removePart(id, true) }"))
   assert.ok(ko['figure.button.remove-and-refit-room'].includes('{part}'))
 })
 
 test('배치를 바꿀 수 없는 까닭 — 평면에 붙은 부품과 새 평면이 받는 면을 말한다(벽 배치, 09-25)', async () => {
-  const { placementRefusalOf } = await import('../client/modeller/v3-refusals.ts')
+  const { placementRefusalOf } = await import('../client/modeller/refusals.ts')
   const fm = await import('@hatiolab/figure-model')
-  let a = fm.addV3Box(fm.createV3Asset('Post'), { id: 'post', size: { x: 100, y: 1000, z: 100 }, position: { x: 0, y: 0, z: 0 } })
-  a = fm.applyV3Authoring(a, { kind: 'attach', part: 'post', face: 'bottom', to: { plane: 'mounting-plane' } })
+  let a = fm.addFigureBox(fm.createFigureAsset('Post'), { id: 'post', size: { x: 100, y: 1000, z: 100 }, position: { x: 0, y: 0, z: 0 } })
+  a = fm.applyFigureAuthoring(a, { kind: 'attach', part: 'post', face: 'bottom', to: { plane: 'mounting-plane' } })
   let refused: unknown
   try {
-    fm.applyV3Authoring(a, { kind: 'declare-occupancy', proposal: fm.proposeV3Occupancy(a), placement: 'wall' as never })
+    fm.applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'wall' as never })
   } catch (e) {
     refused = e
   }
@@ -137,14 +137,14 @@ test('배치를 바꿀 수 없는 까닭 — 평면에 붙은 부품과 새 평
   assert.ok(said.includes('post (bottom)') && said.includes('벽 기반') && said.includes('back'), said)
   assert.equal(placementRefusalOf(new Error('x'), say), null)
   /* The placement list sends its command through the page, not the editor: the page says it in words too, and the list goes back. */
-  const page = readFileSync(fileURLToPath(new URL('../client/pages/figure-v3-modeller-page.ts', import.meta.url)), 'utf8')
+  const page = readFileSync(fileURLToPath(new URL('../client/pages/figure-modeller-page.ts', import.meta.url)), 'utf8')
   assert.ok(page.includes('placementRefusalOf(error, (key, params) => i18next.t(key, params))'), '페이지 경로도 사람의 말로')
-  const props = readFileSync(fileURLToPath(new URL('../client/modeller/figure-v3-properties.ts', import.meta.url)), 'utf8')
+  const props = readFileSync(fileURLToPath(new URL('../client/modeller/figure-properties.ts', import.meta.url)), 'utf8')
   assert.ok(props.includes('select.value = current'), '거절되면 목록이 원래 배치로 돌아온다')
 })
 
 test('범위 밖 값은 받을 수 있는 범위를 숫자로 말한다 — 커널의 영어가 아니다 (Figure 레인 :3300, 2026-09-26)', async () => {
-  const { inputRangeRefusalOf } = await import('../client/modeller/v3-refusals.ts')
+  const { inputRangeRefusalOf } = await import('../client/modeller/refusals.ts')
   const range = (message: string) => Object.assign(new Error(message), { code: 'INPUT_RANGE' })
   const size = inputRangeRefusalOf(range('INPUT_RANGE: size.x: 6021100 outside [300,1200]'), say)!
   assert.ok(size.includes('X') && size.includes('300') && size.includes('1,200') && size.includes('6,021,100'), size)
@@ -156,7 +156,7 @@ test('범위 밖 값은 받을 수 있는 범위를 숫자로 말한다 — 커
 })
 
 test('레시피가 막히면 몇 번째 단계에서 왜 막혔는지 사람의 말로 — 커널의 영어가 아니라 (2026-09-27)', async () => {
-  const { recipeRefusalOf } = await import('../client/modeller/v3-refusals.ts')
+  const { recipeRefusalOf } = await import('../client/modeller/refusals.ts')
   const say = (key: string, p: Record<string, string>) => `${key} ${JSON.stringify(p)}`
   const refusal = Object.assign(new Error('EDIT_TARGET: steps[2]: attach: door is wider than the opening'), { code: 'EDIT_TARGET', path: 'steps[2]' })
   const told = recipeRefusalOf(refusal, say)!

package/test/{v3-release-panel.test.ts → release-panel.test.ts}

@@ -1,8 +1,8 @@
 /*
- * **V3 화면에서 발행할 수 있다** (ADR-0087 5단계의 선행 조건, 2026-09-24).
+ * **화면에서 발행할 수 있다** (ADR-0087 5단계의 선행 조건, 2026-09-24).
  *
- * V3 모델러에는 발행 패널이 없었다 — 저장은 되고 발행 · 판본 · 복원 · 판정을 볼 자리가 없었다. 복사본 검증의
- * 「32 개 발행 통과」는 스크립트가 서버의 문을 직접 부른 것이지 화면이 아니었다. 그리고 새로 만든 V3 도형은 전부
+ * 모델러에는 발행 패널이 없었다 — 저장은 되고 발행 · 판본 · 복원 · 판정을 볼 자리가 없었다. 복사본 검증의
+ * 「32 개 발행 통과」는 스크립트가 서버의 문을 직접 부른 것이지 화면이 아니었다. 그리고 새로 만든 도형은 전부
  * 「공간 선언 없음」으로 발행이 막히는데, 그 선언을 할 단추가 화면 어디에도 없었다. 5단계에서 `figure-modeller`
  * 가 이 화면으로 바뀌면 새 도형은 영영 발행할 수 없었다.
  *
@@ -15,37 +15,37 @@ import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 
 import {
-  addV3Box,
-  applyV3Authoring,
-  createV3Asset,
-  inspectV3Asset,
-  proposeV3Occupancy,
-  serializeV3Asset
+  addFigureBox,
+  applyFigureAuthoring,
+  createFigureAsset,
+  inspectFigureAsset,
+  proposeFigureOccupancy,
+  serializeFigureAsset
 } from '@hatiolab/figure-model'
 
-import { occupancyFromParts } from '../client/modeller/v3-occupancy.ts'
+import { occupancyFromParts } from '../client/modeller/occupancy.ts'
 
-const codes = (asset: Parameters<typeof inspectV3Asset>[0]) => inspectV3Asset(asset).violations.map(v => v.code)
+const codes = (asset: Parameters<typeof inspectFigureAsset>[0]) => inspectFigureAsset(asset).violations.map(v => v.code)
 
-test('새로 만든 V3 도형의 「공간 선언 없음」을 「부품에 맞추기」 한 번이 푼다', () => {
-  let asset = createV3Asset('Probe')
-  asset = addV3Box(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+test('새로 만든 도형의 「공간 선언 없음」을 「부품에 맞추기」 한 번이 푼다', () => {
+  let asset = createFigureAsset('Probe')
+  asset = addFigureBox(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
   assert.deepEqual(codes(asset), ['OCCUPANCY_UNDECLARED'], '전제: 선언 없는 도형은 막힌다')
 
-  const fitted = applyV3Authoring(asset, occupancyFromParts(serializeV3Asset(asset)))
+  const fitted = applyFigureAuthoring(asset, occupancyFromParts(serializeFigureAsset(asset)))
 
   assert.deepEqual(codes(fitted), [])
   assert.equal(fitted.occupancy?.placement, 'floor', '처음 선언하는 도형은 바닥에 선다')
 })
 
 test('선언한 공간을 넘은 부품도 같은 한 번으로 풀리고, 배치 기준은 지킨다', () => {
-  let asset = createV3Asset('Probe')
-  asset = addV3Box(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
-  asset = applyV3Authoring(asset, { kind: 'declare-occupancy', proposal: proposeV3Occupancy(asset, { over: 'range' }), placement: 'center' })
-  asset = addV3Box(asset, { id: 'arm', size: { x: 100, y: 100, z: 100 }, position: { x: 900, y: 50, 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 = applyFigureAuthoring(asset, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(asset, { over: 'range' }), placement: 'center' })
+  asset = addFigureBox(asset, { id: 'arm', size: { x: 100, y: 100, z: 100 }, position: { x: 900, y: 50, z: 0 } })
   assert.ok(codes(asset).includes('PART_OUTSIDE_OCCUPANCY'), '전제: 넘은 부품은 막힌다')
 
-  const fitted = applyV3Authoring(asset, occupancyFromParts(serializeV3Asset(asset)))
+  const fitted = applyFigureAuthoring(asset, occupancyFromParts(serializeFigureAsset(asset)))
 
   assert.deepEqual(codes(fitted), [])
   assert.equal(fitted.occupancy?.placement, 'center', '이미 선언된 배치 기준을 바꾸지 않는다')
@@ -54,7 +54,7 @@ test('선언한 공간을 넘은 부품도 같은 한 번으로 풀리고, 배
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 
 test('모델러가 발행 패널을 걸고, 패널이 내는 셋을 받는다', () => {
-  const page = read('../client/pages/figure-v3-modeller-page.ts')
+  const page = read('../client/pages/figure-modeller-page.ts')
 
   assert.ok(/<figure-history-panel/.test(page), '패널을 건다')
   for (const event of ['fit-base-to-parts', 'figure-released', 'figure-reverted']) {

package/test/renderer.test.ts

@@ -0,0 +1,24 @@
+import {test} from 'node:test'
+import assert from 'node:assert/strict'
+import * as THREE from 'three'
+import {replaceFigureMeshes} from '../client/modeller/renderer.ts'
+import type {FigureRenderPart} from '../client/modeller/renderer.ts'
+const box=(id:string):FigureRenderPart=>({id,shape:{provider:'box',dimensions:{width:100,height:200,depth:300}},pose:{r:[[1,0,0],[0,1,0],[0,0,1]],t:[0,100,0]},material:{token:'primary'}})
+test('renderer replaces rather than accumulates; empty scene disposes old resources',()=>{
+ const group=new THREE.Group();replaceFigureMeshes(group,[box('a'),box('b')],{primary:'#123456'})
+ assert.equal(group.children.length,2);let disposed=0
+ const first=group.children[0] as THREE.Mesh;first.geometry.addEventListener('dispose',()=>disposed++)
+ replaceFigureMeshes(group,[box('c')],{primary:'#123456'});assert.equal(group.children.length,1);assert.equal(group.children[0].name,'c');assert.equal(disposed,1)
+ replaceFigureMeshes(group,[],{});assert.equal(group.children.length,0)
+})
+test('renderer preserves scene on unsupported geometry and resolves pose/material',()=>{
+ const group=new THREE.Group();replaceFigureMeshes(group,[box('a')],{primary:'#123456'})
+ const old=group.children[0],bounds=new THREE.Box3().setFromObject(group)
+ assert.equal(bounds.min.y,0);assert.equal(bounds.max.y,200)
+ assert.throws(()=>replaceFigureMeshes(group,[box('b'),{...box('c'),shape:{provider:'unknown',dimensions:{}}}],{primary:'#123456'}),/Unsupported/)
+ assert.equal(group.children[0],old)
+ const p=box('glow');p.material={token:'primary',preset:'metal',transparent:true,emissive:{token:'primary',intensity:2,on:true}}
+ replaceFigureMeshes(group,[p],{primary:'#123456'})
+ const material=(group.children[0] as THREE.Mesh).material as THREE.MeshStandardMaterial
+ assert.equal(material.metalness,0.8);assert.equal(material.transparent,true);assert.equal(material.emissiveIntensity,2)
+})