@things-factory/figure-service 10.1.75 → 10.1.79

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

@@ -1,7 +1,7 @@
 import { In } from 'typeorm'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 
-import { parseV3Asset, placeholderType } from '@hatiolab/figure-model'
+import { parseFigureAsset, placeholderType } from '@hatiolab/figure-model'
 import { getRepository } from '@things-factory/shell'
 
 import { Figure } from './figure.js'
@@ -11,15 +11,15 @@ import { FigureProposal, ProposeRequest } from './figure-propose-type.js'
 import { inspectSource } from './figure-format.js'
 import { renameDraftType, renameFacts } from './figure-rename.js'
 import { parseSource } from './figure-format.js'
-import { ProposeV3Failure, proposeFigureV3 } from './figure-propose-v3.js'
-import { prepareV3Write, compareAndSwapV3, pictureOf } from './figure-v3-write.js'
+import { ProposeFigureFailure, proposeFigureSteps } from './figure-propose-steps.js'
+import { prepareFigureWrite, compareAndSwapFigure, pictureOf } from './figure-write.js'
 
 @Resolver(Figure)
 export class FigureMutation {
   @Directive('@transaction')
   @Directive('@privilege(category: "figure", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Figure, { description: 'Save a V3 asset draft using an exact-source concurrency check.' })
-  async saveFigureV3(
+  @Mutation(returns => Figure, { description: 'Save a asset draft using an exact-source concurrency check.' })
+  async saveFigure(
     @Arg('source') source: string,
     @Ctx() context: ResolverContext,
     @Arg('id', { nullable: true }) id?: string,
@@ -34,7 +34,7 @@ export class FigureMutation {
     if (!id) {
       if (!creationId || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(creationId))
         throw Error('새 모델 저장에는 생성 요청 식별자가 필요합니다.')
-      const prepared = { ...prepareV3Write(source), ...pictureOf(thumbnail) }
+      const prepared = { ...prepareFigureWrite(source), ...pictureOf(thumbnail) }
       const previous = await repository.findOne({ where: { id: creationId, domain: { id: domain.id } } })
       if (previous) {
         if (previous.source !== prepared.source) throw Error('이 생성 요청은 이미 다른 내용으로 저장되었습니다. 저장된 모델을 다시 열어 주세요.')
@@ -43,7 +43,7 @@ export class FigureMutation {
       /*
         The temporary name comes from the format's `placeholderType()`, the one rule the release gate and the AI
         tools use to recognise it. This used to build its own (`FIGURE_<32 hex>`), which `isPlaceholderType` does
-        not match, so a new V3 figure could be published under a machine name that then froze (ADR-0063 decision 4)
+        not match, so a new figure could be published under a machine name that then froze (ADR-0063 decision 4)
         — seen on :3300, 2026-09-24. A retry is still safe: the row id is the creation id, not the name.
       */
       /*
@@ -69,10 +69,10 @@ export class FigureMutation {
     // Exact tenant ownership: an inherited catalog entry is not writable in the child domain.
     const figure = await repository.findOne({ where: { id, domain: { id: domain.id } } })
     if (!figure) throw Error('편집할 Figure를 찾을 수 없습니다.')
-    const prepared = { ...prepareV3Write(source, figure, expectedSource), ...pictureOf(thumbnail, figure) }
+    const prepared = { ...prepareFigureWrite(source, figure, expectedSource), ...pictureOf(thumbnail, figure) }
     // Compare-and-swap in the UPDATE itself: supported by SQLite as well as PostgreSQL.
     // A pessimistic row lock is not supported by the product's SQLite deployment.
-    await compareAndSwapV3(criteria => repository.update(criteria, { ...prepared, updater: user }),
+    await compareAndSwapFigure(criteria => repository.update(criteria, { ...prepared, updater: user }),
       id, domain.id, expectedSource)
     return repository.findOneOrFail({ where: { id, domain: { id: domain.id } } })
   }
@@ -422,9 +422,9 @@ export class FigureMutation {
     }
 
     try {
-      const result = await proposeFigureV3({
+      const result = await proposeFigureSteps({
         prompt: request.prompt,
-        base: request.base ? parseV3Asset(request.base) : undefined,
+        base: request.base ? parseFigureAsset(request.base) : undefined,
         name: request.name,
         image
       })
@@ -438,7 +438,7 @@ export class FigureMutation {
         attempts: result.attempts
       }
     } catch (e) {
-      if (e instanceof ProposeV3Failure) {
+      if (e instanceof ProposeFigureFailure) {
         // 사유를 삼키지 않는다. 저작자가 무엇이 막혔는지 알아야 말을 고쳐 다시 시킨다.
         throw new Error([e.message, ...e.reasons].join('\n'))
       }

package/server/service/figure/{figure-propose-v3.test.ts → figure-propose-steps.test.ts}

@@ -1,15 +1,15 @@
 /**
- * figure-propose-v3 — an AI proposal for a V3 figure is a list of the modeller's commands (ADR-0094).
+ * figure-propose-steps — an AI proposal for a figure is a list of the modeller's commands (ADR-0094).
  *
  * What is held here is our filter, not the model's skill: the model is not called. The steps are applied on a copy;
  * the step the kernel refuses, and the gate findings the steps bring in, go back to the model; after three attempts
  * the proposer says it could not make it, and nothing half made comes back.
  */
-import { V3_PROPOSAL_GRAMMAR, applyV3Proposal, createV3Asset, inspectV3Asset } from '@hatiolab/figure-model'
+import { FIGURE_PROPOSAL_GRAMMAR, applyFigureProposal, createFigureAsset, inspectFigureAsset } from '@hatiolab/figure-model'
 import { setDefaultAIClient } from '@things-factory/ai-client-base'
 import type { AIClient } from '@things-factory/ai-client-base'
 
-import { ProposeV3Failure, proposeFigureV3, rulesPromptV3 } from './figure-propose-v3'
+import { ProposeFigureFailure, proposeFigureSteps, rulesPromptFigure } from './figure-propose-steps'
 
 function stubClient(answers: unknown[]): AIClient & { calls: number; sent: any[][]; system?: string } {
   const client = {
@@ -49,21 +49,21 @@ const wrongFace = liftTable.map((s, i) => (i === 4 ? { ...s, face: 'left' } : s)
 
 describe('the model is told the kernel\'s commands and the open draft', () => {
   it('teaches every word of the grammar, in its own shape', () => {
-    const rules = rulesPromptV3()
-    for (const word of V3_PROPOSAL_GRAMMAR) expect(rules).toContain(word.shape)
+    const rules = rulesPromptFigure()
+    for (const word of FIGURE_PROPOSAL_GRAMMAR) expect(rules).toContain(word.shape)
     expect(rules).not.toMatch(/"parts"\s*:\s*\[|anchor/i)
   })
 
   it('a measure asked to be the same as another is linked, not copied (:3300, 2026-09-26: 「몸통 지름과 같게」 came as a fixed 100)', () => {
-    expect(rulesPromptV3()).toMatch(/same as, matches or follows another part or the figure, write link-dimension/)
+    expect(rulesPromptFigure()).toMatch(/same as, matches or follows another part or the figure, write link-dimension/)
   })
 
-  it('a revision carries the draft\'s V3 source', async () => {
-    const draft = applyV3Proposal(createV3Asset('Lift table'), liftTable as any)
+  it('a revision carries the draft\'s source', async () => {
+    const draft = applyFigureProposal(createFigureAsset('Lift table'), liftTable as any)
     const client = stubClient([{ steps: [{ kind: 'rename', name: 'Lift table 2' }] }])
     setDefaultAIClient(client)
-    const made = await proposeFigureV3({ prompt: '이름을 바꿔 줘', base: draft })
-    expect(client.sent[0]![0]!.content).toContain('"version":"figure-v3-asset-1"')
+    const made = await proposeFigureSteps({ prompt: '이름을 바꿔 줘', base: draft })
+    expect(client.sent[0]![0]!.content).toContain('"version":"figure-asset-1"')
     expect(made.source.name).toBe('Lift table 2')
     expect(draft.name).toBe('Lift table')
   })
@@ -72,17 +72,17 @@ describe('the model is told the kernel\'s commands and the open draft', () => {
 describe('the steps are held to the kernel and the gate', () => {
   it('a list the kernel takes comes back with the figure it makes, the gate clean, on the first attempt', async () => {
     setDefaultAIClient(stubClient([{ steps: liftTable }]))
-    const made = await proposeFigureV3({ prompt: '리프트 테이블', name: 'Lift table' })
+    const made = await proposeFigureSteps({ prompt: '리프트 테이블', name: 'Lift table' })
     expect(made.attempts).toBe(1)
     expect(made.steps).toEqual(liftTable)
-    expect(inspectV3Asset(made.source).violations).toEqual([])
+    expect(inspectFigureAsset(made.source).violations).toEqual([])
     expect(made.score?.grade).toMatch(/^[ABCD]$/)
   })
 
   it('a refused step goes back with its place and the kernel\'s code, and the next answer is taken', async () => {
     const client = stubClient([{ steps: wrongFace }, { steps: liftTable }])
     setDefaultAIClient(client)
-    const made = await proposeFigureV3({ prompt: '리프트 테이블', name: 'Lift table' })
+    const made = await proposeFigureSteps({ prompt: '리프트 테이블', name: 'Lift table' })
     expect(made.attempts).toBe(2)
     const said = client.sent[1]!.at(-1)!.content as string
     expect(said).toMatch(/ATTACH_FACE: steps\[4\]: attach: /)
@@ -91,23 +91,23 @@ describe('the steps are held to the kernel and the gate', () => {
   it('a new figure must come out whole: a list that leaves the room undeclared is sent back', async () => {
     const client = stubClient([{ steps: withoutRoom }, { steps: liftTable }])
     setDefaultAIClient(client)
-    const made = await proposeFigureV3({ prompt: '리프트 테이블', name: 'Lift table' })
+    const made = await proposeFigureSteps({ prompt: '리프트 테이블', name: 'Lift table' })
     expect(made.attempts).toBe(2)
     expect(client.sent[1]!.at(-1)!.content).toMatch(/OCCUPANCY_UNDECLARED/)
   })
 
   it('a revision is not blamed for what the draft already had', async () => {
-    const draft = applyV3Proposal(createV3Asset('Lift table'), withoutRoom as any)
+    const draft = applyFigureProposal(createFigureAsset('Lift table'), withoutRoom as any)
     setDefaultAIClient(stubClient([{ steps: [{ kind: 'rename', name: 'Lift' }] }]))
-    const made = await proposeFigureV3({ prompt: '이름', base: draft })
+    const made = await proposeFigureSteps({ prompt: '이름', base: draft })
     expect(made.attempts).toBe(1)
   })
 
   it('three refusals said back, then it says it could not make it, with the last reasons -- nothing half made', async () => {
     const client = stubClient([{ steps: wrongFace }, new Error('cut short'), { nope: true }])
     setDefaultAIClient(client)
-    const failure = await proposeFigureV3({ prompt: '리프트 테이블', name: 'Lift table' }).catch(e => e)
-    expect(failure).toBeInstanceOf(ProposeV3Failure)
+    const failure = await proposeFigureSteps({ prompt: '리프트 테이블', name: 'Lift table' }).catch(e => e)
+    expect(failure).toBeInstanceOf(ProposeFigureFailure)
     expect(failure.message).toBe('만들지 못했습니다.')
     expect(failure.attempts).toBe(3)
     expect(failure.reasons).toEqual(['The answer must be { "steps": [ ... ] }.'])

package/server/service/figure/{figure-propose-v3.ts → figure-propose-steps.ts}

@@ -1,13 +1,13 @@
-import { V3_PROPOSAL_GRAMMAR, applyV3Proposal, createV3Asset, inspectV3Asset, serializeV3Asset, v3CostOf, v3ScoreOf } from '@hatiolab/figure-model'
-import type { V3Asset, V3ProposalStep } from '@hatiolab/figure-model'
+import { FIGURE_PROPOSAL_GRAMMAR, applyFigureProposal, createFigureAsset, inspectFigureAsset, serializeFigureAsset, figureCostOf, figureScoreOf } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureProposalStep } from '@hatiolab/figure-model'
 import { getDefaultAIClient } from '@things-factory/ai-client-base'
 import type { AIImageMediaType, AIMessage } from '@things-factory/ai-client-base'
 
 /**
- * An AI proposal for a V3 figure is a list of the modeller's own commands (ADR-0094).
+ * An AI proposal for a figure is a list of the modeller's own commands (ADR-0094).
  *
- * The model is told the command grammar (figure-model's `V3_PROPOSAL_GRAMMAR`, made from the kernel's constants) and
- * the open draft's V3 source, and answers with steps. The steps are applied on a copy with `applyV3Proposal`; the
+ * The model is told the command grammar (figure-model's `FIGURE_PROPOSAL_GRAMMAR`, made from the kernel's constants) and
+ * the open draft's source, and answers with steps. The steps are applied on a copy with `applyFigureProposal`; the
  * first step the kernel refuses, and any gate finding the steps brought in, go back to the model as reasons. After
  * three attempts the proposer says it could not make it. Nothing half made is returned, and nothing is saved: the
  * modeller applies the same steps through its session as one step of its history.
@@ -19,29 +19,29 @@ const MAX_ATTEMPTS = 3
 /** A list of commands for a figure with many parts is long; the default output limit cuts the JSON short. */
 const GENERATE_MAX_TOKENS = 16384
 
-export interface ProposeV3Input {
+export interface ProposeFigureInput {
   /** What the author asked for, in their words. */
   prompt: string
   /** The open draft to revise. Absent: a new figure. */
-  base?: V3Asset
+  base?: FigureAsset
   /** The name of a new figure. */
   name?: string
   /** A reference picture: proportions and masses, not surface detail. */
   image?: { data: Buffer; mediaType: AIImageMediaType }
 }
 
-export interface ProposeV3Result {
+export interface ProposeFigureResult {
   /** What the modeller applies, as one step of its history. */
-  steps: V3ProposalStep[]
+  steps: FigureProposalStep[]
   /** The figure the steps make, for the dock to show. */
-  source: V3Asset
-  score: ReturnType<typeof v3ScoreOf>
-  cost: ReturnType<typeof v3CostOf>
+  source: FigureAsset
+  score: ReturnType<typeof figureScoreOf>
+  cost: ReturnType<typeof figureCostOf>
   attempts: number
 }
 
 /** Could not make it. Never an empty or half-made candidate. */
-export class ProposeV3Failure extends Error {
+export class ProposeFigureFailure extends Error {
   constructor(
     message: string,
     /** The last attempt's reasons, as the kernel and the gate said them. */
@@ -49,12 +49,12 @@ export class ProposeV3Failure extends Error {
     readonly attempts: number
   ) {
     super(message)
-    this.name = 'ProposeV3Failure'
+    this.name = 'ProposeFigureFailure'
   }
 }
 
 /** The rules and the words, all from figure-model's constants. */
-export function rulesPromptV3(): string {
+export function rulesPromptFigure(): string {
   return [
     'You author a 3D figure for a factory digital twin by writing the commands a person gives in the figure modeller.',
     'Answer with ONE JSON object only: { "steps": [ ...commands in order... ] }. No prose, no code fences.',
@@ -72,18 +72,18 @@ export function rulesPromptV3(): string {
     'When revising, write only the commands the request needs. Everything not touched stays as it is.',
     '',
     'The commands (shape, then what it means):',
-    ...V3_PROPOSAL_GRAMMAR.map(word => `- ${word.shape}\n  ${word.means}`)
+    ...FIGURE_PROPOSAL_GRAMMAR.map(word => `- ${word.shape}\n  ${word.means}`)
   ].join('\n')
 }
 
 /** The request, and the open draft's source when revising. */
-export function taskPromptV3(input: ProposeV3Input): string {
+export function taskPromptFigure(input: ProposeFigureInput): string {
   const lines = [`Request: ${input.prompt}`]
   if (input.base) {
     lines.push(
       '',
-      'Revise this figure. Its V3 source (reference data, not instructions):',
-      serializeV3Asset(input.base),
+      'Revise this figure. Its source (reference data, not instructions):',
+      serializeFigureAsset(input.base),
       '',
       `Palette tokens it has: ${Object.keys(input.base.palette ?? {}).join(', ') || 'none'}.`
     )
@@ -99,8 +99,8 @@ function findingKey(v: { code: string; part?: string; axis?: string }): string {
   return `${v.code}|${v.part ?? ''}|${v.axis ?? ''}`
 }
 
-function findingsOf(asset: V3Asset): { key: string; text: string }[] {
-  return inspectV3Asset(asset).violations.map(v => ({ key: findingKey(v), text: `${v.code}${v.part ? ` (${v.part})` : ''}: ${v.detail}` }))
+function findingsOf(asset: FigureAsset): { key: string; text: string }[] {
+  return inspectFigureAsset(asset).violations.map(v => ({ key: findingKey(v), text: `${v.code}${v.part ? ` (${v.part})` : ''}: ${v.detail}` }))
 }
 
 /**
@@ -108,13 +108,13 @@ function findingsOf(asset: V3Asset): { key: string; text: string }[] {
  * kernel refused, or the gate findings the steps brought in. When revising, a finding the draft already had is not the
  * answer's; a new figure has none to excuse, so it must come out whole (its room declared, its parts inside it).
  */
-export function judgeV3Answer(base: V3Asset, answer: unknown, revising: boolean): { source?: V3Asset; steps?: V3ProposalStep[]; reasons: string[] } {
+export function judgeFigureAnswer(base: FigureAsset, answer: unknown, revising: boolean): { source?: FigureAsset; steps?: FigureProposalStep[]; reasons: string[] } {
   const steps = (answer as { steps?: unknown } | undefined)?.steps
   if (!Array.isArray(steps)) return { reasons: ['The answer must be { "steps": [ ... ] }.'] }
 
-  let source: V3Asset
+  let source: FigureAsset
   try {
-    source = applyV3Proposal(base, steps as V3ProposalStep[])
+    source = applyFigureProposal(base, steps as FigureProposalStep[])
   } catch (e) {
     return { reasons: [(e as Error).message] }
   }
@@ -122,17 +122,17 @@ export function judgeV3Answer(base: V3Asset, answer: unknown, revising: boolean)
   const before = new Set(revising ? findingsOf(base).map(f => f.key) : [])
   const brought = findingsOf(source).filter(f => !before.has(f.key))
   if (brought.length) return { reasons: brought.map(f => f.text) }
-  return { source, steps: steps as V3ProposalStep[], reasons: [] }
+  return { source, steps: steps as FigureProposalStep[], reasons: [] }
 }
 
 /** Asks the model for steps and holds them to the kernel and the gate, three times at most. */
-export async function proposeFigureV3(input: ProposeV3Input): Promise<ProposeV3Result> {
+export async function proposeFigureSteps(input: ProposeFigureInput): Promise<ProposeFigureResult> {
   const client = getDefaultAIClient()
-  if (!client) throw new ProposeV3Failure('AI 모델이 설정돼 있지 않습니다.', [], 0)
+  if (!client) throw new ProposeFigureFailure('AI 모델이 설정돼 있지 않습니다.', [], 0)
 
-  const base = input.base ?? createV3Asset(input.name ?? 'Figure')
-  const system = rulesPromptV3()
-  const task = taskPromptV3(input)
+  const base = input.base ?? createFigureAsset(input.name ?? 'Figure')
+  const system = rulesPromptFigure()
+  const task = taskPromptFigure(input)
   const messages: AIMessage[] = [
     {
       role: 'user',
@@ -156,9 +156,9 @@ export async function proposeFigureV3(input: ProposeV3Input): Promise<ProposeV3R
       continue
     }
 
-    const judged = judgeV3Answer(base, answer, !!input.base)
+    const judged = judgeFigureAnswer(base, answer, !!input.base)
     if (judged.source) {
-      return { steps: judged.steps!, source: judged.source, score: v3ScoreOf(judged.source), cost: v3CostOf(judged.source), attempts: attempt }
+      return { steps: judged.steps!, source: judged.source, score: figureScoreOf(judged.source), cost: figureCostOf(judged.source), attempts: attempt }
     }
 
     reasons = judged.reasons
@@ -170,5 +170,5 @@ export async function proposeFigureV3(input: ProposeV3Input): Promise<ProposeV3R
     })
   }
 
-  throw new ProposeV3Failure('만들지 못했습니다.', reasons, MAX_ATTEMPTS)
+  throw new ProposeFigureFailure('만들지 못했습니다.', reasons, MAX_ATTEMPTS)
 }

package/server/service/figure/figure-propose-type.ts

@@ -8,7 +8,7 @@ export class ProposeRequest {
   @Field({ description: 'What the author asked for, in their own words' })
   prompt: string
 
-  @Field({ nullable: true, description: 'The V3 figure source to revise, as JSON. Omit to create a new one.' })
+  @Field({ nullable: true, description: 'The figure source to revise, as JSON. Omit to create a new one.' })
   base?: string
 
   @Field({ nullable: true, description: 'The name a person reads for a new figure. Ignored when base is given.' })
@@ -26,10 +26,10 @@ export class ProposeRequest {
  */
 @ObjectType({ description: 'A figure the assistant proposes, as modeller commands. Not saved — the author applies it or leaves it.' })
 export class FigureProposal {
-  @Field({ description: 'The V3 authoring commands, as a JSON array, in the order they apply' })
+  @Field({ description: 'The authoring commands, as a JSON array, in the order they apply' })
   steps: string
 
-  @Field({ description: 'The V3 figure source the steps make, as JSON' })
+  @Field({ description: 'The figure source the steps make, as JSON' })
   source: string
 
   @Field(type => Int, { nullable: true, description: 'Reuse score out of 100' })

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

@@ -114,7 +114,7 @@ export class FigureQuery {
     const figure = await getRepository(Figure).findOne({
       where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id },
       /*
-        `type` is read too. A V3 asset carries no type, so the temporary-type refusal reads the row's; with only
+        `type` is read too. A asset carries no type, so the temporary-type refusal reads the row's; with only
         id and source selected it saw `undefined`, the panel enabled 「발행하기」, and the release mutation — which
         loads the whole row — refused on the press (2026-09-24).
       */
@@ -142,7 +142,7 @@ export class FigureQuery {
   /**
    * The same judgement for a source that has not been saved — what the modeller shows **while** the author edits.
    *
-   * Without it a V3 author saw nothing until they saved and opened the release panel. The judgement runs here, not
+   * Without it a author saw nothing until they saved and opened the release panel. The judgement runs here, not
    * in the browser, because the sentences are made from the request's language (`inspectAnySource` with `context.t`)
    * and a second copy on the screen would drift from the one the release refuses with. When `id` names a saved
    * figure, its row type and last release are read as `inspectFigure` does; a figure never saved has neither.
@@ -190,7 +190,7 @@ export class FigureQuery {
    * 소비처(operato-board, operato-twin, things-scene)가 발행된 도형을 받아 가는 문.
    *
    * 이름은 보드와의 계약이라 그대로 둔다(바꾸는 일은 따로 한다). 돌려주는 것은 자산이다 —
-   * `{ format: 'v3', type, asset }`. 그리는 쪽(`registerFigureV3`)이 커널로 컴파일한다.
+   * `{ type, asset }`. 그리는 쪽(`registerFigure`)이 커널로 컴파일한다.
    *
    * ## 규칙
    * 1. 소비처는 초안(draft)을 볼 수 없다 — **반드시 발행된(released) 판만 전달**한다.
@@ -221,7 +221,7 @@ export class FigureQuery {
   @Directive('@privilege(category: "figure-published", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => GraphQLJSON, {
     nullable: true,
-    description: 'A released figure for its consumers (board, twin, things-scene): { format, type, asset } with the figure asset. Only returns released figures.'
+    description: 'A released figure for its consumers (board, twin, things-scene): { type, asset } with the figure asset. Only returns released figures.'
   })
   async figureBlueprint(
     @Arg('type') type: string,
@@ -247,7 +247,7 @@ export class FigureQuery {
 
     try {
       const text = typeof sourceToCompile === 'string' ? sourceToCompile : JSON.stringify(sourceToCompile)
-      return { format: 'v3', type, asset: consumablePayloadOf(text).asset }
+      return { type, asset: consumablePayloadOf(text).asset }
     } catch (err) {
       console.error(`[figureBlueprint] 타입 '${type}' (figure id: ${figure.id}) 자산 컴파일 실패:`, err)
 

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

@@ -143,18 +143,18 @@ describe('이름을 바꾸기 전에 읽는 사실', () => {
  */
 describe('처음 저장에 타입 이름을 받는다', () => {
   let FigureMutation: any
-  let V3_SOURCE: string
+  let FIGURE_SOURCE: string
   beforeAll(() => {
     FigureMutation = loadCompiled('service/figure/figure-mutation').FigureMutation
     const model = require('@hatiolab/figure-model')
-    V3_SOURCE = model.serializeV3Asset(
-      model.addV3Box(model.createV3Asset('상자'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+    FIGURE_SOURCE = model.serializeFigureAsset(
+      model.addFigureBox(model.createFigureAsset('상자'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
     )
   })
 
   const save = (creationId: string, type?: string) =>
-    new FigureMutation().saveFigureV3(
-      V3_SOURCE,
+    new FigureMutation().saveFigure(
+      FIGURE_SOURCE,
       { state: { domain: DOMAIN, user: undefined, tx: dataSource!.manager } },
       undefined,
       undefined,

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

@@ -7,13 +7,13 @@
 import { readFileSync } from 'fs'
 import { join } from 'path'
 
-import { createV3Asset, parseV3Asset, serializeV3Asset } from '@hatiolab/figure-model'
+import { createFigureAsset, parseFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
 
 import { FigureRenameRefused, renameDraftType } from './figure-rename'
 
 const draft = (over: Record<string, unknown> = {}) => ({
   type: 'FIGURE_MU6RJH47',
-  source: serializeV3Asset(createV3Asset('새 Figure')),
+  source: serializeFigureAsset(createFigureAsset('새 Figure')),
   ...over
 })
 
@@ -22,15 +22,15 @@ const never = { version: 0, hasHistory: false, takenByAnother: false }
 describe('초안의 type 고치기', () => {
   /*
     자산에는 type 칸이 없고 형식은 모르는 칸을 거절한다. 원본에 이름을 써 넣었더니 그 도형을 다시 열 수
-    없었다(`parseV3Asset` — "unknown type"). 행만 바뀐다.
+    없었다(`parseFigureAsset` — "unknown type"). 행만 바뀐다.
   */
   it('★ 행만 바뀌고, 원본은 그대로 다시 열린다', () => {
-    const source = serializeV3Asset(createV3Asset('새 Figure'))
+    const source = serializeFigureAsset(createFigureAsset('새 Figure'))
     const result = renameDraftType({ type: 'FIGURE_ABCDEF12', source }, 'ROLLER_CONVEYOR', never)
 
     expect(result.type).toBe('ROLLER_CONVEYOR')
     expect(result.source).toBe(source)
-    expect(() => parseV3Asset(result.source)).not.toThrow()
+    expect(() => parseFigureAsset(result.source)).not.toThrow()
   })
 
   it('앞뒤 공백을 뗀다. 대소문자는 저작자가 적은 대로 둔다', () => {
@@ -93,10 +93,10 @@ describe('문이 이 규칙을 지난다', () => {
   })
 
   /*
-    V3 저장이 임시 이름을 스스로 지었다(`FIGURE_<32 hex>`). 형식의 `isPlaceholderType` 이 그것을 못 알아봐서
+    저장이 임시 이름을 스스로 지었다(`FIGURE_<32 hex>`). 형식의 `isPlaceholderType` 이 그것을 못 알아봐서
     발행 판정이 기계 이름을 통과시켰다. 짓는 쪽과 알아보는 쪽이 한 규칙이어야 한다.
   */
-  /* 새 V3 도형의 임시 이름이 판정이 알아보는 그 규칙인지는 문을 실제로 불러 본다 — figure-rename-db.test.ts 「이름 없이 부르면」. */
+  /* 새 도형의 임시 이름이 판정이 알아보는 그 규칙인지는 문을 실제로 불러 본다 — figure-rename-db.test.ts 「이름 없이 부르면」. */
 
   it('문이 type 을 받는 칸을 갖는다', () => {
     const type = source('figure-type.ts')

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

@@ -1,7 +1,7 @@
 /**
  * 저작 도구의 **배선**을 못박는다.
  *
- * 도구가 무엇을 계산하는지는 각 진입점의 시험이 이미 잠근다(`figure-propose-v3.test` ·
+ * 도구가 무엇을 계산하는지는 각 진입점의 시험이 이미 잠근다(`figure-propose-steps.test` ·
  * figure-model 의 게이트 시험). 비어 있던 것은 **그 사이를 잇는 줄들**이고, 그 줄이 끊어질 때
  * 나타나는 증상이 실제로 겪은 실패와 1:1 로 대응한다.
  *
@@ -36,8 +36,8 @@ const THEIRS = { id: 'domain-theirs' }
 /** A stored figure: one body on the floor, its room declared. */
 const SOURCE = (() => {
   const model = require('@hatiolab/figure-model')
-  let asset = model.addV3Box(model.createV3Asset('Mixer'), { id: 'body', size: { x: 300, y: 400, z: 300 }, position: { x: 0, y: 200, z: 0 } })
-  asset = model.applyV3Authoring(asset, { kind: 'declare-occupancy', proposal: model.proposeV3Occupancy(asset), placement: 'floor' })
+  let asset = model.addFigureBox(model.createFigureAsset('Mixer'), { id: 'body', size: { x: 300, y: 400, z: 300 }, position: { x: 0, y: 200, z: 0 } })
+  asset = model.applyFigureAuthoring(asset, { kind: 'declare-occupancy', proposal: model.proposeFigureOccupancy(asset), placement: 'floor' })
   return asset
 })()
 
@@ -57,19 +57,19 @@ function install() {
     Figure: class {},
     inspectSource: (json?: string | null) =>
       json ? { blocked: false, findings: [] } : { blocked: true, findings: [{ code: 'no-source', message: '정본이 없다', blocking: true }] },
-    proposeFigureV3: async (input: any) => {
+    proposeFigureSteps: async (input: any) => {
       proposed.push(input)
       return {
         steps: [{ kind: 'rename', name: 'Mixer' }],
-        source: { ...model.createV3Asset(input.base?.name ?? input.name ?? 'Figure') },
+        source: { ...model.createFigureAsset(input.base?.name ?? input.name ?? 'Figure') },
         score: { grade: 'B' },
         cost: { triangles: 12 },
         attempts: 1
       }
     },
     parseSource: require('./figure-format').parseSource,
-    v3CostOf: model.v3CostOf,
-    v3ScoreOf: model.v3ScoreOf
+    figureCostOf: model.figureCostOf,
+    figureScoreOf: model.figureScoreOf
   })
 }
 
@@ -303,21 +303,21 @@ describe('모델이 넘긴 id 를 믿지 않는다', () => {
 
 /*
   제안은 모델러의 명령 목록이다(ADR-0094). 고치는 제안은 모델러가 모델이 본 판 위에 한 단계로 적용하므로, 고칠 수
-  있는 것은 모델러에 열린 V3 도형뿐이고 그 판(context · revision)을 문맥이 싣고 와야 한다.
+  있는 것은 모델러에 열린 도형뿐이고 그 판(context · revision)을 문맥이 싣고 와야 한다.
 */
-const v3Draft = () => {
+const figureDraft = () => {
   const model = require('@hatiolab/figure-model')
-  let asset = model.createV3Asset('Probe')
-  asset = model.addV3Box(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+  let asset = model.createFigureAsset('Probe')
+  asset = model.addFigureBox(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
   return asset
 }
-const modeller = (over: any = {}) => ({ figureId: 'fig-1', draftSource: v3Draft(), context: 'ctx-7', revision: 4, ...over })
+const modeller = (over: any = {}) => ({ figureId: 'fig-1', draftSource: figureDraft(), context: 'ctx-7', revision: 4, ...over })
 
 describe('제안을 요청할 때', () => {
-  it('열린 도형을 고치면 그 V3 초안이 제안기에 가고, 모델러가 적용할 판이 함께 돌아온다', async () => {
+  it('열린 도형을 고치면 그 초안이 제안기에 가고, 모델러가 적용할 판이 함께 돌아온다', async () => {
     const out = await toolNamed('proposeFigureCandidate').builder({ prompt: '다리를 길게' }, ctx(modeller()))
     expect(proposed[0].base.name).toBe('Probe')
-    expect(proposed[0].base.version).toBe('figure-v3-asset-1')
+    expect(proposed[0].base.version).toBe('figure-asset-1')
     expect(out.context).toBe('ctx-7')
     expect(out.revision).toBe(4)
     expect(out.figureId).toBe('fig-1')
@@ -373,17 +373,17 @@ describe('제안을 요청할 때', () => {
   })
 
   it('세 번 거절된 끝의 사유가 도구 경계를 넘어간다 — 「만들지 못했습니다」만 남지 않게', async () => {
-    const { ProposeV3Failure } = require('./figure-propose-v3')
+    const { ProposeFigureFailure } = require('./figure-propose-steps')
     const model = require('@hatiolab/figure-model')
     __setFigureToolDepsForTest({
       getRepository: () => stubRepository(ROWS),
       Figure: class {},
       parseSource: require('./figure-format').parseSource,
-      proposeFigureV3: async () => {
-        throw new ProposeV3Failure('만들지 못했습니다.', ['ATTACH_FACE: steps[4]: attach: faces along x'], 3)
+      proposeFigureSteps: async () => {
+        throw new ProposeFigureFailure('만들지 못했습니다.', ['ATTACH_FACE: steps[4]: attach: faces along x'], 3)
       },
-      v3CostOf: model.v3CostOf,
-      v3ScoreOf: model.v3ScoreOf
+      figureCostOf: model.figureCostOf,
+      figureScoreOf: model.figureScoreOf
     })
     await expect(toolNamed('proposeFigureCandidate').builder({ prompt: '고쳐줘' }, ctx(modeller()))).rejects.toThrow(
       /만들지 못했습니다\.\nATTACH_FACE: steps\[4\]/
@@ -420,8 +420,8 @@ describe('제안이 카드가 된다', () => {
 })
 
 describe('도형이 모델러에 열려 있을 때', () => {
-  it('저장 전 V3 초안을 V3 로 읽고, V3 셈으로 잰다', async () => {
-    const draft = v3Draft()
+  it('저장 전 초안을 이 모델로 읽고, 셈으로 잰다', async () => {
+    const draft = figureDraft()
     const got = await toolNamed('getFigureSource').builder({}, ctx({ figureId: 'fig-1', draftSource: draft, palette: ['palette.primary'] }))
     expect(got.draft).toBe(true)
     expect(got.cost.triangles).toBe(12)
@@ -429,7 +429,7 @@ describe('도형이 모델러에 열려 있을 때', () => {
   })
 
   it('형식을 어긴 초안은 저장 문의 말로 거절한다', async () => {
-    const broken = { ...v3Draft(), appearance: [] }
+    const broken = { ...figureDraft(), appearance: [] }
     await expect(toolNamed('getFigureSource').builder({}, ctx({ figureId: 'fig-1', draftSource: broken }))).rejects.toThrow(/unsaved draft is invalid/)
   })
 })