@things-factory/figure-service 10.1.75 → 10.1.79

package/server/service/figure/figure-format.test.ts

@@ -6,24 +6,24 @@
  *   - a source that does not name the format is refused -- what cannot be identified is not stored;
  *   - the budget columns (`triangles`, `groups`) and the score are the kernel's.
  */
-import { createV3Asset, addV3Box, addV3Primitive, serializeV3Asset, applyV3Authoring, proposeV3Occupancy, placeholderType, v3ScoreOf } from '@hatiolab/figure-model'
-import type { V3Asset } from '@hatiolab/figure-model'
+import { createFigureAsset, addFigureBox, addFigurePrimitive, serializeFigureAsset, applyFigureAuthoring, proposeFigureOccupancy, placeholderType, figureScoreOf } from '@hatiolab/figure-model'
+import type { FigureAsset } from '@hatiolab/figure-model'
 
 import { FigureSourceError, consumablePayloadOf, inspectSource, parseSource } from './figure-format'
 
-/** 온전한 V3 자산 하나: 바닥에 선 상자와, 부품에서 제안받아 확정한 점유 부피. */
-function v3Asset(): V3Asset {
-  let asset = createV3Asset('Mixer')
-  asset = addV3Box(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
-  asset = applyV3Authoring(asset, { kind: 'attach', part: 'body', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyV3Authoring(asset, {
+/** 온전한 자산 하나: 바닥에 선 상자와, 부품에서 제안받아 확정한 점유 부피. */
+function figureAsset(): FigureAsset {
+  let asset = createFigureAsset('Mixer')
+  asset = addFigureBox(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'body', face: 'bottom', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, {
     kind: 'declare-occupancy',
-    proposal: proposeV3Occupancy(asset, { over: 'range' }),
+    proposal: proposeFigureOccupancy(asset, { over: 'range' }),
     placement: 'floor'
   })
   return asset
 }
-const v3Source = () => serializeV3Asset(v3Asset())
+const figureSource = () => serializeFigureAsset(figureAsset())
 
 describe('figure-format — 판을 알아보는 문', () => {
   describe('판은 자산이 적는다', () => {
@@ -49,50 +49,50 @@ describe('figure-format — 판을 알아보는 문', () => {
 
   describe('저장', () => {
     it('예산 칸을 커널이 잰다 — 상자 하나는 삼각형 12, 묶음 1', () => {
-      const parsed = parseSource(v3Source())
+      const parsed = parseSource(figureSource())
       expect(parsed.derived.triangles).toBe(12)
       expect(parsed.derived.groups).toBe(1)
     })
 
-    it('점수 칸은 v3ScoreOf 다 — 저작면의 성숙도 탭과 같은 수(수석 아키텍트 판정 09-24)', () => {
-      const score = parseSource(v3Source()).derived.score
-      expect(score).toBe(v3ScoreOf(v3Asset())!.score)
+    it('점수 칸은 figureScoreOf 다 — 저작면의 성숙도 탭과 같은 수(수석 아키텍트 판정 09-24)', () => {
+      const score = parseSource(figureSource()).derived.score
+      expect(score).toBe(figureScoreOf(figureAsset())!.score)
       expect(score).toBeGreaterThan(0)
     })
 
     it('형식을 어긴 자산은 거절한다', () => {
-      const broken = JSON.parse(v3Source())
+      const broken = JSON.parse(figureSource())
       broken.appearance = []
       expect(() => parseSource(JSON.stringify(broken))).toThrow(FigureSourceError)
     })
   })
 
   describe('발행 판정', () => {
-    it('제 부피 안에 든 V3 자산은 막지 않는다', () => {
-      const inspection = inspectSource(v3Source())
+    it('제 부피 안에 든 자산은 막지 않는다', () => {
+      const inspection = inspectSource(figureSource())
       expect(inspection.blocked).toBe(false)
     })
 
     it('선언한 부피 밖으로 나간 부품은 이름과 함께 막는다', () => {
-      let asset = v3Asset()
-      asset = addV3Box(asset, { id: 'arm', size: { x: 100, y: 100, z: 100 }, position: { x: 900, y: 50, z: 0 } })
-      const inspection = inspectSource(serializeV3Asset(asset))
+      let asset = figureAsset()
+      asset = addFigureBox(asset, { id: 'arm', size: { x: 100, y: 100, z: 100 }, position: { x: 900, y: 50, z: 0 } })
+      const inspection = inspectSource(serializeFigureAsset(asset))
       expect(inspection.blocked).toBe(true)
       expect(inspection.findings.some(f => f.code === 'part-outside-occupancy' && f.at === 'arm')).toBe(true)
     })
 
-    it('부피를 선언하지 않은 V3 자산은 막는다', () => {
-      let asset = createV3Asset('Bare')
-      asset = addV3Box(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
-      const inspection = inspectSource(serializeV3Asset(asset))
+    it('부피를 선언하지 않은 자산은 막는다', () => {
+      let asset = createFigureAsset('Bare')
+      asset = addFigureBox(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+      const inspection = inspectSource(serializeFigureAsset(asset))
       expect(inspection.blocked).toBe(true)
       expect(inspection.findings.some(f => f.code === 'occupancy-undeclared')).toBe(true)
     })
 
     it('전 범위를 증명하지 못한 판정은 막지 않고 그 사실을 말한다', () => {
       /* 상태에 따라 도는 부품은 모서리만으로 증명되지 않는다 — 표본 검사였음을 발행 화면이 읽는다. */
-      let asset = v3Asset()
-      asset = addV3Primitive(asset, { id: 'wheel', kind: 'cylinder', dimensions: { radius: 20, length: 20 }, position: { x: 0, y: 20, z: 0 } })
+      let asset = figureAsset()
+      asset = addFigurePrimitive(asset, { id: 'wheel', kind: 'cylinder', dimensions: { radius: 20, length: 20 }, position: { x: 0, y: 20, z: 0 } })
       const m = asset.document.model as any
       m.inputs.push({ id: 'spin', unit: 'deg', min: -180, max: 180, role: 'state' })
       asset.stateDefaults['spin'] = 0
@@ -108,13 +108,13 @@ describe('figure-format — 판을 알아보는 문', () => {
       pose.params = { ...pose.params, to: 'wheel.spun' }
       m.nodes.push({ id: 'wheel.world', op: 'compose@1', args: ['wheel.turn.p', pose.outputs.pose], outputs: { pose: 'wheel.wp' } })
       m.nodes.find((n: any) => n.id === 'wheel').args = [m.nodes.find((n: any) => n.id === 'wheel.shape').outputs.shape, 'wheel.wp']
-      asset = applyV3Authoring(asset, {
+      asset = applyFigureAuthoring(asset, {
         kind: 'declare-occupancy',
-        proposal: proposeV3Occupancy(asset, { over: 'range' }),
+        proposal: proposeFigureOccupancy(asset, { over: 'range' }),
         placement: 'floor'
       })
 
-      const inspection = inspectSource(serializeV3Asset(asset))
+      const inspection = inspectSource(serializeFigureAsset(asset))
       const sampled = inspection.findings.find(f => f.code === 'state-range-sampled')
       expect(sampled).toBeDefined()
       expect(sampled!.blocking).toBe(false)
@@ -127,16 +127,16 @@ describe('figure-format — 판을 알아보는 문', () => {
       expect(inspectSource(null).findings[0].code).toBe('no-source')
     })
 
-    it('바뀐 것 없는 V3 재발행은 아무 말도 없이 지난다', () => {
-      const again = inspectSource(v3Source(), v3Source())
+    it('바뀐 것 없는 재발행은 아무 말도 없이 지난다', () => {
+      const again = inspectSource(figureSource(), figureSource())
       expect(again.blocked).toBe(false)
       expect(again.findings.filter(f => f.code !== 'state-range-sampled')).toEqual([])
     })
 
-    it('놓인 인스턴스가 기대던 것을 없앤 V3 재발행은 막는다 — 없어진 능력을 이름으로 댄다', () => {
-      const before = v3Asset()
+    it('놓인 인스턴스가 기대던 것을 없앤 재발행은 막는다 — 없어진 능력을 이름으로 댄다', () => {
+      const before = figureAsset()
       before.document.capabilities.names = ['Holdable']
-      const inspection = inspectSource(v3Source(), serializeV3Asset(before))
+      const inspection = inspectSource(figureSource(), serializeFigureAsset(before))
       const gone = inspection.findings.find(f => f.code === 'capability-gone')
       expect(gone).toBeDefined()
       expect(gone!.blocking).toBe(true)
@@ -151,7 +151,7 @@ describe('figure-format — 판을 알아보는 문', () => {
     이 판정은 한때 발행 패널에 영어 문장(`detail`)을 그대로 냈고 왜 · 어떻게가 없었다 — 사용자가 2026-09-19 에
     「가장 큰 문제」로 짚은 모양이다. 문장은 요청의 언어를 아는 서버가 코드와 값에서 만든다(ADR-0054).
   */
-  describe('V3 판정의 문장 — 발행 패널의 말로', () => {
+  describe('판정의 문장 — 발행 패널의 말로', () => {
     const KO = require('../../../translations/ko.json') as Record<string, string>
     const EN = require('../../../translations/en.json') as Record<string, string>
 
@@ -164,14 +164,14 @@ describe('figure-format — 판을 알아보는 문', () => {
       }
 
     const outside = () => {
-      let asset = v3Asset()
-      asset = addV3Box(asset, { id: 'arm', size: { x: 100, y: 100, z: 100 }, position: { x: 900, y: 50, z: 0 } })
-      return serializeV3Asset(asset)
+      let asset = figureAsset()
+      asset = addFigureBox(asset, { id: 'arm', size: { x: 100, y: 100, z: 100 }, position: { x: 900, y: 50, z: 0 } })
+      return serializeFigureAsset(asset)
     }
     const bare = () => {
-      let asset = createV3Asset('Bare')
-      asset = addV3Box(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
-      return serializeV3Asset(asset)
+      let asset = createFigureAsset('Bare')
+      asset = addFigureBox(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+      return serializeFigureAsset(asset)
     }
 
     it('넘은 부품은 이름 · 축 · 넘은 양을 화면 말투로 말하고, 왜와 어떻게를 함께 낸다', () => {
@@ -193,7 +193,7 @@ describe('figure-format — 판을 알아보는 문', () => {
     })
 
     it('부품이 없는 새 도형에는 도형을 먼저 추가하라고 한다 — 화면은 그때 맞추기 단추를 내지 않는다', () => {
-      const empty = serializeV3Asset(createV3Asset('Empty'))
+      const empty = serializeFigureAsset(createFigureAsset('Empty'))
       const finding = inspectSource(empty, null, translatorOf(KO)).findings.find(f => f.code === 'occupancy-undeclared')!
 
       expect(finding.how).toBe('먼저 도형을 추가한 뒤, 「부품에 맞추기」로 공간을 선언하세요.')
@@ -205,16 +205,16 @@ describe('figure-format — 판을 알아보는 문', () => {
       여기서는 손으로 만든다: 램프의 높이가 도형 높이(size.y)를 따라 올라가고, 몸통은 그대로다.
     */
     const splitting = () => {
-      let asset = createV3Asset('Lamp post')
-      asset = addV3Box(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
-      asset = addV3Box(asset, { id: 'lamp', size: { x: 40, y: 20, z: 40 }, position: { x: 0, y: 10, z: 0 } })
+      let asset = createFigureAsset('Lamp post')
+      asset = addFigureBox(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, 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.inputs.push({ id: 'size.y', unit: 'mm', min: 50, max: 20000, role: 'design' } as never)
       asset.designInputs['size.y'] = 100
       model.nodes.push({ id: 'lamp.lift', op: 'add@1', args: ['size.y', 'lamp.position.y'], outputs: { value: 'lamp.lift.value' } } as never)
       const pose = model.nodes.find(n => n.id === 'lamp.pose')!
       pose.args[1] = 'lamp.lift.value'
-      return serializeV3Asset(asset)
+      return serializeFigureAsset(asset)
     }
 
     it('크기를 바꾸면 떨어지는 부품을 막고, 어느 부품이 어느 축에서인지 · 왜 · 어떻게를 말한다', () => {
@@ -230,14 +230,14 @@ describe('figure-format — 판을 알아보는 문', () => {
 
     /* 한 비율로 커진다고 선언한 도형에서 제 숫자를 가진 부품(수석 아키텍트 판정 2026-09-24 조건 ②). */
     it('한 비율로 커진다고 선언한 도형에서 따라 커지지 않는 부품을 막고 이름을 댄다', () => {
-      let asset = createV3Asset('Uniform')
-      asset = addV3Box(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+      let asset = createFigureAsset('Uniform')
+      asset = addFigureBox(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
       for (const axis of ['x', 'y', 'z']) {
         asset.document.model.inputs.push({ id: `size.${axis}`, unit: 'mm', min: 1, max: 20000, role: 'design' } as never)
         asset.designInputs[`size.${axis}`] = 100
       }
-      asset = applyV3Authoring(asset, { kind: 'scale-uniformly' } as never)
-      const finding = inspectSource(serializeV3Asset(asset), null, translatorOf(KO)).findings.find(f => f.code === 'sizing-not-uniform')
+      asset = applyFigureAuthoring(asset, { kind: 'scale-uniformly' } as never)
+      const finding = inspectSource(serializeFigureAsset(asset), null, translatorOf(KO)).findings.find(f => f.code === 'sizing-not-uniform')
 
       expect(finding?.blocking).toBe(true)
       expect(finding!.message).toBe("이 도형은 한 비율로 커지는데, 크기를 X 로 2배로 하면 'body' 부품은 같이 커지지 않습니다.")
@@ -283,13 +283,13 @@ describe('figure-format — 판을 알아보는 문', () => {
     it('임시 이름인 도형은 발행을 막는다 — 이름은 행에 있다', () => {
       /* The name a new figure gets — the format's rule, the one the gate recognises. */
       const placeholder = placeholderType()
-      const finding = inspectSource(v3Source(), null, translatorOf(KO), placeholder).findings.find(f => f.code === 'type-is-placeholder')
+      const finding = inspectSource(figureSource(), null, translatorOf(KO), placeholder).findings.find(f => f.code === 'type-is-placeholder')
 
       expect(finding?.blocking).toBe(true)
       expect(finding!.message).toBe(`'${placeholder}' 타입은 처음 저장할 때 붙은 임시 타입입니다.`)
       /* 화면의 칸 이름은 「타입」이다(`figure.label.figure-type`). */
       expect(finding!.how).toContain('타입 칸')
-      expect(inspectSource(v3Source(), null, translatorOf(KO), 'ROLLER_CONVEYOR').blocked).toBe(false)
+      expect(inspectSource(figureSource(), null, translatorOf(KO), 'ROLLER_CONVEYOR').blocked).toBe(false)
     })
 
     /* 코드가 묻는 키가 두 언어에 다 있어야 한다 — 없으면 그 언어의 화면에 영어가 섞인다. */
@@ -298,8 +298,8 @@ describe('figure-format — 판을 알아보는 문', () => {
       const t = translatorOf(KO, asked)
       inspectSource(outside(), null, t)
       inspectSource(bare(), null, t)
-      inspectSource(v3Source(), v3Source(), t)
-      inspectSource(v3Source(), null, t, 'FIGURE_ABCDEF12')
+      inspectSource(figureSource(), figureSource(), t)
+      inspectSource(figureSource(), null, t, 'FIGURE_ABCDEF12')
 
       const keys = [...new Set(asked)]
       expect(keys.length).toBeGreaterThan(5)
@@ -310,12 +310,12 @@ describe('figure-format — 판을 알아보는 문', () => {
 
   describe('소비처', () => {
     it('자산을 그대로 받는다 — 그리는 쪽이 커널로 컴파일한다', () => {
-      const payload = consumablePayloadOf(v3Source())
-      expect(payload.asset.version).toBe('figure-v3-asset-1')
+      const payload = consumablePayloadOf(figureSource())
+      expect(payload.asset.version).toBe('figure-asset-1')
     })
 
     it('컴파일되지 않는 자산은 소비처에 넘기지 않고 던진다', () => {
-      const broken = JSON.parse(v3Source())
+      const broken = JSON.parse(figureSource())
       broken.designInputs = {}
       expect(() => consumablePayloadOf(JSON.stringify(broken))).toThrow()
     })

package/server/service/figure/figure-format.ts

@@ -1,15 +1,15 @@
 /*
  * The doors a stored source goes through: saving (`parseSource`), publishing (`inspectSource`) and handing it to a
- * board (`consumablePayloadOf`). The format is `figure-v3-asset-1`, and the asset says so in its `version`; a source
+ * board (`consumablePayloadOf`). The format is `figure-asset-1`, and the asset says so in its `version`; a source
  * that does not is refused by name, because a source the server cannot identify is one it must not save.
  */
-import { compileV3Asset, inspectV3Asset, isPlaceholderType, parseV3Asset, serializeV3Asset, v3ContractChanges, v3CostOf, v3ScoreOf } from '@hatiolab/figure-model'
-import type { V3Asset, V3ContractChange, V3ContractError, V3Violation } from '@hatiolab/figure-model'
+import { compileFigureAsset, inspectFigureAsset, isPlaceholderType, parseFigureAsset, serializeFigureAsset, figureContractChanges, figureCostOf, figureScoreOf } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureContractChange, FigureContractError, FigureViolation } from '@hatiolab/figure-model'
 
 import type { FigureFinding } from './figure-type.js'
 
 /** The version the format stamps on its own source. */
-export const V3_ASSET_VERSION = 'figure-v3-asset-1'
+export const FIGURE_ASSET_VERSION = 'figure-asset-1'
 
 /** A source that passed the save door: what is stored, and the numbers the catalogue shows, computed here. */
 export interface ParsedSource {
@@ -54,7 +54,7 @@ export interface Inspection {
 /**
  * That the source is JSON and names the format.
  *
- * @throws {FigureSourceError} when the text is not JSON, or does not carry `version: 'figure-v3-asset-1'`.
+ * @throws {FigureSourceError} when the text is not JSON, or does not carry `version: 'figure-asset-1'`.
  */
 function assertFormat(sourceJson: string): void {
   let parsed: unknown
@@ -65,14 +65,14 @@ function assertFormat(sourceJson: string): void {
       { code: 'source-not-json', message: `정본이 JSON 이 아니다: ${(e as Error).message}`, at: 'source' }
     ])
   }
-  if ((parsed as { version?: unknown } | null)?.version !== V3_ASSET_VERSION)
+  if ((parsed as { version?: unknown } | null)?.version !== FIGURE_ASSET_VERSION)
     throw new FigureSourceError([
-      { code: 'source-format-unknown', message: `정본의 판을 알 수 없다 — 도형 자산은 version '${V3_ASSET_VERSION}' 을 적는다`, at: 'version' }
+      { code: 'source-format-unknown', message: `정본의 판을 알 수 없다 — 도형 자산은 version '${FIGURE_ASSET_VERSION}' 을 적는다`, at: 'version' }
     ])
 }
 
 /**
- * Validates a source and computes what the catalogue shows: the cost from `v3CostOf`, and the score from `v3ScoreOf`
+ * Validates a source and computes what the catalogue shows: the cost from `figureCostOf`, and the score from `figureScoreOf`
  * -- the headroom against placing `LIMITS.screenInstances` of it on one screen (chief architect, 2026-09-24), the
  * same number the modeller's maturity tab shows. An asset that draws nothing has no score, not a full one.
  *
@@ -82,18 +82,18 @@ export function parseSource(sourceJson: string): ParsedSource {
   assertFormat(sourceJson)
   let asset
   try {
-    asset = parseV3Asset(sourceJson)
-    compileV3Asset(asset)
+    asset = parseFigureAsset(sourceJson)
+    compileFigureAsset(asset)
   } catch (e) {
-    const error = e as V3ContractError & { path?: string }
+    const error = e as FigureContractError & { path?: string }
     throw new FigureSourceError([
-      { code: error.code ?? 'v3-asset-invalid', message: error.message ?? String(e), at: error.path }
+      { code: error.code ?? 'asset-invalid', message: error.message ?? String(e), at: error.path }
     ])
   }
-  const cost = v3CostOf(asset)
-  const score = v3ScoreOf(asset)
+  const cost = figureCostOf(asset)
+  const score = figureScoreOf(asset)
   return {
-    source: serializeV3Asset(asset),
+    source: serializeFigureAsset(asset),
     derived: { score: (score?.score ?? null) as unknown as number, triangles: cost.triangles, groups: cost.groups },
     violations: []
   }
@@ -102,7 +102,7 @@ export function parseSource(sourceJson: string): ParsedSource {
 /**
  * Whether this source may be published, and why not.
  *
- * The judgement is `inspectV3Asset`: every part inside the volume the asset declares, over the whole
+ * The judgement is `inspectFigureAsset`: every part inside the volume the asset declares, over the whole
  * state range, and the face it says it is mounted on lying in that plane. A verdict reached by sampling is
  * reported as a finding of its own rather than hidden — an author releasing a figure the gate could only
  * sample should be told so, because nothing proved it holds between the states that were checked.
@@ -111,7 +111,7 @@ export function parseSource(sourceJson: string): ParsedSource {
 export type Translate = (key: string, options?: Record<string, unknown>) => string
 
 /**
- * A V3 finding in the words of the release panel.
+ * A finding in the words of the release panel.
  *
  * The gate says what it measured as a code and values (`part`, `axis`, `mm`, `degrees`) and an English `detail`
  * for logs. The sentence an author reads is made here, where the request's language is known (ADR-0054) — not in
@@ -122,7 +122,7 @@ export type Translate = (key: string, options?: Record<string, unknown>) => stri
  * The words are the modeller's: 「공간 선언」 for the volume a figure takes up and 「장착면」 for the face it stands on
  * (`figure.text.mounting-face-explained`). A fact, then the way out.
  */
-function v3Wording(violation: V3Violation, say: Say, hasParts: boolean): Pick<GateFinding, 'message' | 'why' | 'how'> {
+function figureWording(violation: FigureViolation, say: Say, hasParts: boolean): Pick<GateFinding, 'message' | 'why' | 'how'> {
   const part = violation.part ?? ''
   const axis = (violation.axis ?? '').toUpperCase()
   const mm = violation.mm ?? 0
@@ -227,25 +227,25 @@ export function inspectSource(
   }
 
   let inspection
-  let asset: V3Asset | undefined
+  let asset: FigureAsset | undefined
   let hasParts = true
   try {
-    asset = parseV3Asset(sourceJson)
-    inspection = inspectV3Asset(asset)
-    const cost = v3CostOf(asset)
+    asset = parseFigureAsset(sourceJson)
+    inspection = inspectFigureAsset(asset)
+    const cost = figureCostOf(asset)
     hasParts = cost.groups + cost.hidden > 0
   } catch (e) {
-    const error = e as V3ContractError & { path?: string }
+    const error = e as FigureContractError & { path?: string }
     return {
       blocked: true,
-      findings: [{ code: error.code ?? 'v3-asset-invalid', message: error.message ?? String(e), at: error.path, blocking: true }]
+      findings: [{ code: error.code ?? 'asset-invalid', message: error.message ?? String(e), at: error.path, blocking: true }]
     }
   }
 
   const say = sayerOf(t)
   const findings: GateFinding[] = inspection.violations.map(violation => ({
     code: violation.code.toLowerCase().replace(/_/g, '-'),
-    ...v3Wording(violation, say, hasParts),
+    ...figureWording(violation, say, hasParts),
     at: violation.part,
     blocking: true
   }))
@@ -279,41 +279,41 @@ export function inspectSource(
       blocking: false
     })
   }
-  if (releasedJson) findings.push(...v3ContractFindings(asset!, releasedJson, say))
+  if (releasedJson) findings.push(...figureContractFindings(asset!, releasedJson, say))
   return { blocked: findings.some(finding => finding.blocking), findings }
 }
 
 /**
  * The last release against this one — what the drawings that already hold this type lean on (ADR-0063 decision 3).
  *
- * figure-model names the changes and whether each blocks (`v3ContractChanges`); the sentence is made here. When
+ * figure-model names the changes and whether each blocks (`figureContractChanges`); the sentence is made here. When
  * the last release no longer parses, the gate says so rather than passing in silence: a release that was not checked
  * against the last one is a different fact from one that was checked and found safe.
  */
-function v3ContractFindings(asset: V3Asset, releasedJson: string, say: Say): GateFinding[] {
-  let before: V3Asset
+function figureContractFindings(asset: FigureAsset, releasedJson: string, say: Say): GateFinding[] {
+  let before: FigureAsset
   try {
-    before = parseV3Asset(releasedJson)
+    before = parseFigureAsset(releasedJson)
   } catch (e) {
     return [
       {
         code: 'released-unreadable',
-        message: say('figure.gate.v3-released-not-compared.message', { reason: (e as Error).message }, `The last release could not be read, so this release was not compared with it: ${(e as Error).message}`),
-        why: say('figure.gate.v3-released-not-compared.why', {}, 'Whether this release breaks the instances already placed has not been checked.'),
+        message: say('figure.gate.released-not-compared.message', { reason: (e as Error).message }, `The last release could not be read, so this release was not compared with it: ${(e as Error).message}`),
+        why: say('figure.gate.released-not-compared.why', {}, 'Whether this release breaks the instances already placed has not been checked.'),
         blocking: false
       }
     ]
   }
-  return v3ContractChanges(before, asset).map(change => ({
+  return figureContractChanges(before, asset).map(change => ({
     code: change.code,
-    ...v3ContractWording(change, say),
+    ...figureContractWording(change, say),
     at: change.subject,
     blocking: change.blocking
   }))
 }
 
 /** One contract change in the words of the release panel. The English line is the fallback for a missing key. */
-function v3ContractWording(change: V3ContractChange, say: Say): Pick<GateFinding, 'message' | 'why' | 'how'> {
+function figureContractWording(change: FigureContractChange, say: Say): Pick<GateFinding, 'message' | 'why' | 'how'> {
   const v = change.values
   const key = (field: string) => `figure.gate.contract.${change.code}.${field}`
   const gone = {
@@ -423,12 +423,12 @@ function v3ContractWording(change: V3ContractChange, say: Say): Pick<GateFinding
 }
 
 /**
- * What a consumer is handed for a released figure: the asset itself, because what draws it -- `registerFigureV3` in
+ * What a consumer is handed for a released figure: the asset itself, because what draws it -- `registerFigure` in
  * things-scene -- takes the asset and compiles it with the kernel.
  */
-export function consumablePayloadOf(sourceJson: string): { asset: V3Asset } {
+export function consumablePayloadOf(sourceJson: string): { asset: FigureAsset } {
   assertFormat(sourceJson)
-  const asset = parseV3Asset(sourceJson)
-  compileV3Asset(asset)
+  const asset = parseFigureAsset(sourceJson)
+  compileFigureAsset(asset)
   return { asset }
 }

package/server/service/figure/figure-history.ts

@@ -64,7 +64,7 @@ export class FigureHistory implements HistoryEntityInterface<Figure> {
   state?: 'draft' | 'released'
 
   @Column({ nullable: true, ...longTextColumn() })
-  @Field({ nullable: true, description: 'The figure asset JSON (figure-v3-asset-1) at this version.' })
+  @Field({ nullable: true, description: 'The figure asset JSON (figure-asset-1) at this version.' })
   source?: string
 
   @Column({ nullable: true, ...longTextColumn() })

package/server/service/figure/figure-inspect-db.test.ts

@@ -9,12 +9,12 @@
  */
 import type { DataSource } from 'typeorm'
 import {
-  addV3Box,
-  applyV3Authoring,
-  createV3Asset,
+  addFigureBox,
+  applyFigureAuthoring,
+  createFigureAsset,
   placeholderType,
-  proposeV3Occupancy,
-  serializeV3Asset
+  proposeFigureOccupancy,
+  serializeFigureAsset
 } from '@hatiolab/figure-model'
 
 const { DataSource: TypeOrmDataSource } = require('typeorm')
@@ -37,12 +37,12 @@ function loadCompiled(modulePath: string): any {
   return require(resolved)
 }
 
-/** A V3 figure that passes the gate on its own: a box standing on the floor, with its space declared. */
+/** A figure that passes the gate on its own: a box standing on the floor, with its space declared. */
 function sound(): string {
-  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: 'floor' })
-  return serializeV3Asset(asset)
+  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: 'floor' })
+  return serializeFigureAsset(asset)
 }
 
 beforeAll(async () => {
@@ -82,7 +82,7 @@ const save = (type: string, source = sound()) =>
   dataSource!.getRepository(Figure).save({ domain, type, name: 'probe', state: 'draft', source, version: 0 })
 
 describe('inspectFigure — the release panel', () => {
-  it('refuses a V3 figure still under its temporary type — the type comes from the row', async () => {
+  it('refuses a figure still under its temporary type — the type comes from the row', async () => {
     const figure = await save(placeholderType())
 
     const inspection = await new FigureQuery().inspectFigure(figure.id, context())
@@ -101,10 +101,10 @@ describe('inspectFigure — the release panel', () => {
 describe('inspectFigureDraft — the verdict while editing', () => {
   it('judges the unsaved source, not the stored one, and still reads the row type', async () => {
     const figure = await save(placeholderType())
-    let edited = createV3Asset('Probe')
-    edited = addV3Box(edited, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+    let edited = createFigureAsset('Probe')
+    edited = addFigureBox(edited, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
 
-    const inspection = await new FigureQuery().inspectFigureDraft(serializeV3Asset(edited), context(), figure.id)
+    const inspection = await new FigureQuery().inspectFigureDraft(serializeFigureAsset(edited), context(), figure.id)
     const codes = inspection.findings.map((f: any) => f.code)
 
     expect(codes).toContain('occupancy-undeclared')

package/server/service/figure/figure-llm-smoke.test.ts

@@ -1,7 +1,7 @@
 /**
  * 실제 LLM Figure 후보 생성 smoke test (기본 비활성).
  *
- * 결정적 시험은 프롬프트·도구·검사 배선을 고정하지만, 실제 모델이 V3 명령 목록(ADR-0094)을 써서 게이트를
+ * 결정적 시험은 프롬프트·도구·검사 배선을 고정하지만, 실제 모델이 명령 목록(ADR-0094)을 써서 게이트를
  * 지나는 도형을 만드는지는 대신할 수 없다. 이 시험은 `RUN_FIGURE_LLM_SMOKE=1`과 공급자 API 키가 모두 있을 때만 실행한다.
  * DB·GraphQL·Figure 저장을 건드리지 않고 후보 생성 함수만 호출하므로, 외부 영향은 API 비용뿐이다.
  *
@@ -11,9 +11,9 @@
  */
 import { createAIClient, setDefaultAIClient } from '@things-factory/ai-client-base'
 
-import { applyV3Proposal, createV3Asset, inspectV3Asset } from '@hatiolab/figure-model'
+import { applyFigureProposal, createFigureAsset, inspectFigureAsset } from '@hatiolab/figure-model'
 
-import { proposeFigureV3 } from './figure-propose-v3'
+import { proposeFigureSteps } from './figure-propose-steps'
 
 // Provider modules register themselves on import. Keep this separate from the deterministic tests.
 import '@things-factory/ai-client-base'
@@ -50,13 +50,13 @@ describeIf('Figure 실제 LLM smoke', () => {
   test(
     '새 Figure 는 게이트를 지나는 명령 목록으로 온다',
     async () => {
-      const result = await proposeFigureV3({
+      const result = await proposeFigureSteps({
         prompt: 'two cylindrical rollers inside a simple rectangular press frame; make the rollers visually distinct',
         name: 'Roll press'
       })
 
       expect(result.steps.length).toBeGreaterThan(0)
-      expect(inspectV3Asset(result.source).violations).toEqual([])
+      expect(inspectFigureAsset(result.source).violations).toEqual([])
       expect(result.cost.triangles).toBeGreaterThan(0)
       // eslint-disable-next-line no-console
       console.log(`[figure-llm-smoke] new: ${result.steps.length} steps, ${result.attempts} attempt(s)`)
@@ -67,14 +67,14 @@ describeIf('Figure 실제 LLM smoke', () => {
   test(
     '고치는 제안은 건드리지 않은 부품을 그대로 둔다',
     async () => {
-      const draft = applyV3Proposal(createV3Asset('Mixer'), [
+      const draft = applyFigureProposal(createFigureAsset('Mixer'), [
         { kind: 'add-part', part: { id: 'body', kind: 'cylinder', dimensions: { radius: 140, length: 320 } } },
         { kind: 'add-part', part: { id: 'port', kind: 'box', dimensions: { width: 80, height: 60, depth: 30 } } },
         { kind: 'attach', part: 'body', face: 'bottom', to: { plane: 'mounting-plane' } },
         { kind: 'attach', part: 'port', face: 'back', to: { part: 'body', face: 'front' } },
         { kind: 'fit-room', placement: 'floor' }
       ] as any)
-      const result = await proposeFigureV3({ prompt: 'make the port twice as wide and give it an accent colour', base: draft })
+      const result = await proposeFigureSteps({ prompt: 'make the port twice as wide and give it an accent colour', base: draft })
 
       const ids = result.source.document.model.nodes.map((n: any) => n.id)
       expect(ids.some((id: string) => id.includes('body'))).toBe(true)