@things-factory/figure-service 10.1.28 → 10.1.31

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

@@ -0,0 +1,99 @@
+/*
+ * 초안의 타입을 고치는 규칙 — ADR-0063 결정 4.
+ *
+ * 이 규칙이 지키는 것은 하나다: **발행된 이름은 안 바뀐다.** 도면은 그 이름 하나로 도형을
+ * 찾으므로, 바뀌면 배치된 자리가 아무 오류 없이 빈다.
+ */
+import { readFileSync } from 'fs'
+import { join } from 'path'
+
+import { FigureRenameRefused, renameDraftType } from './figure-rename'
+
+const draft = (over: Record<string, unknown> = {}) => ({
+  type: 'FIGURE_MU6RJH47',
+  source: JSON.stringify({ version: 2, type: 'FIGURE_MU6RJH47', base: { x: 1, y: 1, z: 1 }, parts: [] }),
+  ...over
+})
+
+const never = { version: 0, hasHistory: false, takenByAnother: false }
+
+describe('초안의 type 고치기', () => {
+  it('★ 행과 정본이 함께 바뀐다 — 한쪽만 바뀌면 발행 때 어느 이름이 나갈지 갈린다', () => {
+    const result = renameDraftType(draft(), 'ROBOT_ARM', never)
+
+    expect(result.type).toBe('ROBOT_ARM')
+    expect(JSON.parse(result.source).type).toBe('ROBOT_ARM')
+  })
+
+  it('정본의 다른 값은 건드리지 않는다', () => {
+    const before = JSON.parse(draft().source)
+    const after = JSON.parse(renameDraftType(draft(), 'ROBOT_ARM', never).source)
+
+    expect({ ...after, type: before.type }).toEqual(before)
+  })
+
+  it('앞뒤 공백을 뗀다. 대소문자는 저작자가 적은 대로 둔다', () => {
+    expect(renameDraftType(draft(), '  ROBOT_ARM  ', never).type).toBe('ROBOT_ARM')
+    expect(renameDraftType(draft(), 'Robot_Arm', never).type).toBe('Robot_Arm')
+  })
+
+  it('★ 한 번이라도 발행됐으면 거절한다 — 판 번호로', () => {
+    expect(() => renameDraftType(draft(), 'ROBOT_ARM', { ...never, version: 1 })).toThrow(FigureRenameRefused)
+  })
+
+  it('★ 판 번호가 도로 0 이어도 이력이 있으면 거절한다 — 되돌리기가 그 자리를 만든다', () => {
+    try {
+      renameDraftType(draft(), 'ROBOT_ARM', { ...never, hasHistory: true })
+      throw new Error('거절하지 않았다')
+    } catch (e) {
+      expect((e as FigureRenameRefused).code).toBe('already-released')
+    }
+  })
+
+  it('같은 도메인에서 쓰는 이름이면 거절하고, 어느 이름인지 말한다', () => {
+    try {
+      renameDraftType(draft(), 'CONVEYOR', { ...never, takenByAnother: true })
+      throw new Error('거절하지 않았다')
+    } catch (e) {
+      expect((e as FigureRenameRefused).code).toBe('type-taken')
+      expect((e as Error).message).toContain('CONVEYOR')
+    }
+  })
+
+  it('빈 이름은 거절한다 — 도면에 적히는 이름이다', () => {
+    for (const empty of ['', '   ']) {
+      try {
+        renameDraftType(draft(), empty, never)
+        throw new Error('거절하지 않았다')
+      } catch (e) {
+        expect((e as FigureRenameRefused).code).toBe('empty-type')
+      }
+    }
+  })
+})
+
+/*
+ * 규칙이 문에 붙어 있는가. 셈이 맞아도 문이 안 부르면 저작자는 그대로 막혀 있다.
+ */
+describe('문이 이 규칙을 지난다', () => {
+  const source = (name: string) => readFileSync(join(__dirname, name), 'utf8')
+
+  it('updateFigure 가 type 을 받고 규칙을 부른다', () => {
+    const mutation = source('figure-mutation.ts')
+
+    expect(/renameDraftType/.test(mutation)).toBe(true)
+    expect(/patch\.type !== undefined && patch\.type !== figure\.type/.test(mutation)).toBe(true)
+  })
+
+  it('다듬은 이름이 저장된다 — patch 의 날값이 아니라', () => {
+    const mutation = source('figure-mutation.ts')
+
+    expect(/renamed !== undefined \? \{ type: renamed \}/.test(mutation)).toBe(true)
+  })
+
+  it('문이 type 을 받는 칸을 갖는다', () => {
+    const type = source('figure-type.ts')
+
+    expect(/class FigurePatch \{[\s\S]{0,400}type\?: string/.test(type)).toBe(true)
+  })
+})

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

@@ -0,0 +1,98 @@
+/**
+ * 초안의 타입을 고치는 규칙 — ADR-0063 결정 4.
+ *
+ * ## 왜 발행 전에만인가
+ *
+ * `type` 은 도면에 적히는 이름이다. 도면은 `{ type, left, top, width, height }` 만 갖고 늘 최신
+ * 발행판을 그리므로, 발행된 도형의 이름을 바꾸면 이미 배치된 도면이 아무 오류 없이 빈 자리가
+ * 된다. 한 번도 발행되지 않은 도형은 그려질 자리가 없으니 가리키는 도면도 있을 수 없다.
+ *
+ * ## 왜 열어야 했나
+ *
+ * 닫아 두었더니 저작자가 이름을 **한 번도** 정하지 못했다. 새 Figure 에는 기계가 지은 이름이
+ * 붙고(`FIGURE_MU6RJH47`) 칸에 자물쇠가 걸려서, 그 이름이 그대로 도면에 적히는 이름이 됐다.
+ * 그렇게 남은 초안이 14 개다.
+ *
+ * ## 셈은 여기, 질의는 부르는 쪽
+ *
+ * 이 파일은 저장소를 모른다 — 판 번호 · 이력 유무 · 같은 이름의 주인을 **사실로 받는다.**
+ * 그래야 규칙을 DB 없이 시험한다. 문(`figure-mutation.ts`)이 그 셋을 읽어 넘긴다.
+ */
+
+/** 이름을 바꿀 때 알아야 하는 사실. 부르는 쪽이 저장소에서 읽어 온다. */
+export interface RenameFacts {
+  /** 발행 판 번호. 0 이면 한 번도 발행되지 않았다. */
+  version?: number
+  /** 판본이 하나라도 있나. 되돌리기로 판 번호가 도로 낮아져도 이력은 남는다. */
+  hasHistory: boolean
+  /** 같은 도메인에서 그 이름을 이미 쓰는 **다른** 도형이 있나. */
+  takenByAnother: boolean
+}
+
+export class FigureRenameRefused extends Error {
+  constructor(
+    readonly code: 'empty-type' | 'already-released' | 'type-taken',
+    message: string
+  ) {
+    super(message)
+    this.name = 'FigureRenameRefused'
+  }
+}
+
+/**
+ * 고친 이름과 정본. 못 고치면 **까닭과 함께 던진다** — 조용히 옛 이름으로 두지 않는다.
+ *
+ * 정본 안에도 `type` 이 있어서 함께 고친다. 한쪽만 고치면 저장된 JSON 과 행이 다른 이름을
+ * 말하고, 발행할 때 어느 쪽이 도면에 적히는지가 갈린다.
+ */
+export function renameDraftType(
+  current: { type: string; source: string },
+  wanted: string,
+  facts: RenameFacts
+): { type: string; source: string } {
+  const next = wanted.trim()
+
+  if (!next) {
+    throw new FigureRenameRefused('empty-type', 'type 이 비어 있다 — 도면에 적히는 이름이라 비울 수 없다')
+  }
+
+  if ((facts.version ?? 0) > 0 || facts.hasHistory) {
+    throw new FigureRenameRefused(
+      'already-released',
+      '발행된 도형의 type 은 바꿀 수 없다 — 이미 배치된 도면이 이 이름을 가리킨다'
+    )
+  }
+
+  if (facts.takenByAnother) {
+    throw new FigureRenameRefused('type-taken', `type 「${next}」 는 이 도메인에서 이미 쓰고 있다`)
+  }
+
+  const parsed = JSON.parse(current.source) as { type?: string }
+  parsed.type = next
+
+  return { type: next, source: JSON.stringify(parsed) }
+}
+
+/**
+ * 사실 셋을 저장소에서 읽는다.
+ *
+ * 규칙에서 떼어 둔 자리이지만 **질의의 모양이 틀리면 저작자에게는 저장 실패로만 보인다.**
+ * 실제로 그랬다 — 판본을 `figure: { id }` 로 물었고, `FigureHistory` 는 관계 칸이 아니라
+ * `originalId` 로 가리킨다. TypeORM 이 「그런 속성이 없다」로 던졌고 화면에는 영문 오류 한 줄이
+ * 떴다. 그래서 이 함수를 내보내 sqlite 를 들고 왕복까지 본다.
+ */
+export async function renameFacts(
+  repositories: {
+    figures: { findOne(options: any): Promise<{ id: string } | null> }
+    histories: { count(options: any): Promise<number> }
+  },
+  figure: { id?: string; version?: number },
+  domain: { id: string },
+  wanted: string
+): Promise<RenameFacts> {
+  const next = wanted.trim()
+  const hasHistory = (await repositories.histories.count({ where: { originalId: figure.id } })) > 0
+  const taken = next ? await repositories.figures.findOne({ where: { domain: { id: domain.id }, type: next } }) : null
+
+  return { version: figure.version, hasHistory, takenByAnother: !!taken && taken.id !== figure.id }
+}

package/server/service/figure/figure-tool-doors.test.ts

@@ -1,10 +1,13 @@
 /*
- * figure 도구가 지나는 문 — ADR-0072 결정 2.
+ * figure 도구가 지나는 문 — ADR-0072 결정 2, ADR-0071 결정 2 보탬(2026-09-18).
  *
- * 선언만 해 두고 아무도 읽지 않으면 그 선언은 다음 사람이 지우거나 바꿔도 아무 일이 없다. 여기서는
- * 실제로 등록된 명세를 등록기에 넣고, 등록기가 무엇도 문제 삼지 않는지 묻는다. 도구 목록이 늘면
- * 이 시험이 먼저 문다.
+ * 선언만 해 두고 아무도 읽지 않으면 그 선언은 다음 사람이 지우거나 바꿔도 아무 일이 없다. 이제는
+ * 읽는 쪽이 생겼다 — 관문이 이 목록으로 도구를 내보낼지 정한다. 그래서 여기서 묻는 것이 둘이다:
+ * 도구가 문을 적었는가, 그리고 **그 문이 무엇인가를 지키는가.**
  */
+import { readdirSync, readFileSync } from 'fs'
+import { join } from 'path'
+
 import { clearToolRegistry, getAllToolSpecs, getToolRegistryWarnings } from '@things-factory/ai-client-base'
 
 import { registerFigureToolCategories } from './figure-tools'
@@ -24,15 +27,101 @@ describe('figure tools — declared doors', () => {
     expect(undeclared).toEqual([])
   })
 
-  it('★ a door a tool reaches comes with the privilege that guards it', () => {
+  it('the registry itself finds nothing to report about these specs', () => {
+    expect(getToolRegistryWarnings().map(w => `${w.code}:${w.params.tool ?? ''}`)).toEqual([])
+  })
+})
+
+/*
+ * 도구가 가리키는 문이 무엇인가를 지키는가 — 관문이 딛고 선 사실.
+ *
+ * 2026-09-18 까지 도구 명세가 권한을 베껴 적었고 이 자리가 그 사본을 문과 견줬다. 사본은 없어졌다
+ * (ADR-0071 결정 2 보탬) — 관문이 AUTH 의 필드 표에서 문의 선언을 직접 읽는다. 그래서 견줄 두 값도
+ * 없다.
+ *
+ * 대신 관문이 **딛고 선 사실**이 남았다: 이 네 도구가 가리키는 문에 지시자가 붙어 있다는 것. 누가
+ * `Query.figures` 에서 `@privilege` 를 떼면 그 문은 테넌트 안에서 열리고, 도구도 같이 열린다 —
+ * 그 자리가 이제 아무 데서도 안 드러난다. 여기서 문다.
+ */
+describe('figure tools — the doors they reach are guarded', () => {
+  beforeEach(() => {
+    clearToolRegistry()
+    registerFigureToolCategories()
+  })
+  afterAll(() => clearToolRegistry())
+
+  /** 리졸버 원문에서 `Query.figures` 같은 문 이름 → 그 문의 `@privilege` 지시자. */
+  const doorPrivileges = (): Map<string, { category: string; privilege: string; owner: boolean }> => {
+    const found = new Map<string, { category: string; privilege: string; owner: boolean }>()
+
+    for (const file of readdirSync(__dirname).filter(one => one.endsWith('.ts') && !one.endsWith('.test.ts'))) {
+      const lines = readFileSync(join(__dirname, file), 'utf8').split('\n')
+      let privilege: { category: string; privilege: string; owner: boolean } | undefined
+      let kind: 'Query' | 'Mutation' | undefined
+      let decorator = ''
+
+      for (const line of lines) {
+        const declared = /@privilege\(category: "([^"]+)", privilege: "([^"]+)"(, domainOwnerGranted: (true|false))?\)/.exec(line)
+        if (declared) {
+          privilege = { category: declared[1]!, privilege: declared[2]!, owner: declared[4] === 'true' }
+          continue
+        }
+
+        const opens = /@(Query|Mutation)\(/.exec(line)
+        if (opens) {
+          kind = opens[1] as 'Query' | 'Mutation'
+          decorator = line
+          continue
+        }
+
+        if (!kind) {
+          /* 지시자와 문 사이에 딴 것이 오면 그 지시자는 이 문의 것이 아니다. */
+          if (line.trim() && !line.trim().startsWith('@') && !line.trim().startsWith('*') && !line.trim().startsWith('/*')) {
+            privilege = undefined
+          }
+          continue
+        }
+
+        decorator += '\n' + line
+        const method = /^\s*(?:async\s+)?([A-Za-z_$][\w$]*)\s*\(/.exec(line)
+        if (!method) continue
+
+        /*
+          필드 이름이 메서드 이름과 다를 수 있는 길은 하나뿐이다 — 데코레이터의 `name:`. 그것이
+          나타나면 조용히 메서드 이름으로 읽지 않고 멈춘다. 잘못 읽은 짝은 초록으로 보인다.
+        */
+        if (/\bname:\s*'/.test(decorator)) {
+          throw new Error(`${file} 의 ${kind} 가 데코레이터에서 이름을 정한다 — 이 시험이 그 길을 아직 안 읽는다`)
+        }
+
+        if (privilege) found.set(`${kind}.${method[1]}`, privilege)
+        kind = undefined
+        privilege = undefined
+        decorator = ''
+      }
+    }
+
+    return found
+  }
+
+  it('★ 도구가 가리키는 문마다 그 문을 지키는 지시자가 있다', () => {
+    const doors = doorPrivileges()
+
     const unguarded = getAllToolSpecs()
-      .filter(spec => ((spec as any).doors ?? []).length > 0 && !(spec as any).privilege)
-      .map(spec => spec.name)
+      .flatMap(spec =>
+        ((spec as any).doors ?? []).map((door: string) =>
+          doors.has(door) ? undefined : `${spec.name} → ${door}: 그런 문이 없거나 그 문이 권한을 선언하지 않는다`
+        )
+      )
+      .filter(Boolean)
 
     expect(unguarded).toEqual([])
   })
 
-  it('the registry itself finds nothing to report about these specs', () => {
-    expect(getToolRegistryWarnings().map(w => `${w.code}:${w.params.tool ?? ''}`)).toEqual([])
+  it('견줄 문을 실제로 찾아 읽었다 — 0 건이면 위 시험은 언제나 초록이다', () => {
+    const doors = doorPrivileges()
+    expect(doors.get('Query.figures')).toEqual({ category: 'figure', privilege: 'query', owner: true })
+    expect(doors.get('Mutation.proposeFigure')).toEqual({ category: 'figure', privilege: 'mutation', owner: true })
+    expect(doors.size).toBeGreaterThanOrEqual(4)
   })
 })

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

@@ -129,6 +129,72 @@ test('실제 registryAssistantChat 경계가 열린 모델 문맥을 Figure 도
   expect(JSON.stringify(seen[1])).not.toContain('FIGURE_TARGET_REQUIRED')
 })
 
+/*
+  등록된 범주에 도구 넷이 있다는 것과, 넷이 **모델에게 건네졌다**는 것은 다른 사실이다. 그 사이에
+  관문이 하나 있다 — `resolveToolScope` 가 도구마다 `doors` 를 부르는 사람의 권한에 물어 통과한 것만
+  싣는다(ADR-0071 결정 2). 그래서 등록은 넷인데 대화에 실리는 것은 셋일 수 있고, 그때 화면은 아무
+  오류도 내지 않는다 — 모델이 그 도구를 안 부르니 「후보를 만들었습니다」로 끝난다.
+
+  위의 배선 시험은 도구 하나(`getFigureSource`)가 오간 것으로 그 줄을 확인한다. 나머지 셋이 실렸는지는
+  보지 않는다. 그래서 건네진 목록 자체를 여기서 읽는다.
+*/
+describe('모델에게 건네지는 목록', () => {
+  /** `chatWithTools(messages, toolDefs, options)` 의 둘째 인자를 그대로 잡는다. */
+  async function offeredWith(access: (door: string) => Promise<boolean>) {
+    const offered: string[][] = []
+
+    await registryAssistantChat({
+      client: {
+        chatWithTools: async (_messages: any[], toolDefs: any[]) => {
+          offered.push((toolDefs ?? []).map(one => one.name ?? one.function?.name))
+          return { text: '네.', toolCalls: [], stopReason: 'end_turn' }
+        }
+      } as any,
+      messages: [{ role: 'user', content: '무엇을 할 수 있나' }],
+      systemPrompt: 'Author figures.',
+      toolCategories: ['figure-authoring'],
+      state: { domain: MINE },
+      hostContext: { figureId: 'fig-1', draftSource: SOURCE },
+      toolAccess: access
+    } as any)
+
+    expect(offered).toHaveLength(1)
+    return offered[0]!.sort()
+  }
+
+  it('★ 도구 넷이 다 건네진다 — 문을 다 가진 사람에게', async () => {
+    expect(await offeredWith(async () => true)).toEqual([
+      'getFigureSource',
+      'inspectFigure',
+      'listFigures',
+      'proposeFigureCandidate'
+    ])
+  })
+
+  /*
+    넷이 문 넷을 하나씩 나눠 가지므로, 문 하나를 닫으면 도구 하나만 빠져야 한다. 이 갈래가 없으면
+    위 시험은 「관문이 아무것도 안 걸러도」 초록이다.
+
+    후보를 내는 도구를 닫힌 쪽으로 골랐다. 읽기 권한만 가진 사람이 저작 대화를 열면 목록과 정본과
+    검사는 되고 후보 생성은 안 되는 것이 그 사람에게 맞는 모양이다.
+  */
+  it('★ 문이 닫힌 도구 하나만 빠진다 — 나머지 셋은 그대로다', async () => {
+    const offered = await offeredWith(async door => door !== 'Mutation.proposeFigure')
+
+    expect(offered).toEqual(['getFigureSource', 'inspectFigure', 'listFigures'])
+  })
+
+  /*
+    권한을 물어볼 길이 없으면 문에 닿는 도구는 전부 닫힌다(`resolveToolScope`: `if (!access) return false`).
+    figure 의 넷은 전부 문에 닿으므로 하나도 남지 않는다 — 부분만 열리는 일이 없다는 뜻이다.
+  */
+  it('물어볼 길이 없으면 하나도 건네지지 않는다', async () => {
+    const offered = await offeredWith(undefined as any)
+
+    expect(offered).toEqual([])
+  })
+})
+
 describe('범주가 등록된다', () => {
   it('figure-authoring 이 도구 넷과 함께 올라온다', () => {
     const category = getToolCategories().find((one: any) => one.name === 'figure-authoring')!

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

@@ -18,6 +18,12 @@
  * `ai-assistant:mutation` 이 지킨다 — 서로 다른 질문이라 서로 다른 권한이 지킨다. figure 가 board
  * 의 권한을 빌리지 않는다.
  *
+ * ── 권한은 적지 않는다. 문에 적힌 것을 관문이 읽는다 ────────────────────────
+ * 2026-09-18 까지 도구마다 `privilege: { category: 'figure', ... }` 를 적어 두었다. 문의 지시자와
+ * 같은 값이라 그때는 맞았고, 문이 선언을 바꾸는 날 어긋난다 — 어긋나면 느슨한 쪽이 이긴다. 이제
+ * 관문이 `doors` 에 적힌 문의 선언을 AUTH 의 표에서 읽어 묻는다(ADR-0071 결정 2 보탬). 여기 남길
+ * 것은 **닿는 문**뿐이다.
+ *
  * ── 규율을 도구와 함께 보낸다 ───────────────────────────────────────────────
  * 도구 목록만으로는 「언제 반드시 불러야 하는지」를 모른다. twin 이 그 공백에서 사고를 냈다 —
  * 조치 요청에 도구를 부르지 않고 「제안해 두었습니다」라고만 답해, 사용자에게 **없는 버튼을 누르라고
@@ -249,7 +255,6 @@ function figureToolSpecs(): ToolSpec[] {
       name: 'listFigures',
       /* 이 도메인의 도형 목록 — 저장소를 직접 읽지만 같은 일을 하는 문은 이것이다. */
       doors: ['Query.figures'],
-      privilege: { category: 'figure', privilege: 'query', owner: true },
       description:
         'Lists the figures in this tenant with their type names, states and part counts. ' +
         'Call it before naming a type — type names are stored identifiers and must not be invented.',
@@ -280,7 +285,6 @@ function figureToolSpecs(): ToolSpec[] {
       /* 저장된 도형의 원본. **저장 전 초안**을 물으면 저장소에 갈 것이 없어 화면이 보낸 것을 그대로 돌려준다 —
        * 그 갈래에는 닿는 문이 없지만 `doors: []` 로 적지 않는다. 그러면 저장된 도형을 읽는 권한 검사가 선언에서 사라진다. */
       doors: ['Query.figure'],
-      privilege: { category: 'figure', privilege: 'query', owner: true },
       description:
         'Returns the canonical FigureSource of one figure, with its measured cost ' +
         '(triangles, part groups, and how many of it hold 60fps on one screen). Call it before proposing a revision — ' +
@@ -318,7 +322,6 @@ function figureToolSpecs(): ToolSpec[] {
       name: 'inspectFigure',
       /* 검사 결과 — 같은 일을 하는 문. */
       doors: ['Query.inspectFigure'],
-      privilege: { category: 'figure', privilege: 'query', owner: true },
       description:
         'Says whether a figure may be released and, when it may not, what is wrong — each finding ' +
         'carries why it is a problem and what to change. Call it when asked about releasing, or ' +
@@ -340,7 +343,6 @@ function figureToolSpecs(): ToolSpec[] {
       name: 'proposeFigureCandidate',
       /* 후보 생성 — 저장은 하지 않지만 같은 문의 권한을 쓴다. */
       doors: ['Mutation.proposeFigure'],
-      privilege: { category: 'figure', privilege: 'mutation', owner: true },
       description:
         'Asks for a figure candidate from a description, optionally revising an existing one. ' +
         'Returns the candidate with its score and cost. NOTHING IS SAVED — the author accepts or ' +

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

@@ -41,11 +41,19 @@ export class NewFigure {
 /**
  * 수정.
  *
- * `type` 이 없다. **저장되는 식별자라 고칠 수 없다** — 바꾸면 이미 배치된 보드가
- * 타입을 못 찾아 오류 없이 빈 화면이 된다. 고칠 수 있는 이름은 `name` 뿐이다.
+ * `type` 은 **한 번도 발행되지 않은 초안에서만** 바뀐다(ADR-0063 결정 4). 저장되는 식별자라
+ * 발행된 뒤에 바꾸면 이미 배치된 보드가 타입을 못 찾아 오류 없이 빈 화면이 된다. 발행 전에는
+ * 그 도형을 가리키는 도면이 있을 수 없다 — 도면은 최신 발행판을 그리므로 발행된 적 없는
+ * 도형은 그려질 자리가 없다.
+ *
+ * 닫아 두었더니 저작자가 이름을 한 번도 정하지 못했다. 새 Figure 에는 기계가 지은 이름이
+ * 붙고(`FIGURE_MU6RJH47`) 칸에 자물쇠가 걸려서, 그 이름이 그대로 도면에 적히는 이름이 됐다.
  */
-@InputType({ description: 'Input for updating an existing figure. The `type` field is absent by design — it is a stored identifier.' })
+@InputType({ description: 'Input for updating an existing figure. `type` is accepted only while the figure has never been released.' })
 export class FigurePatch {
+  @Field({ nullable: true, description: 'The stored identifier. Accepted only before the first release; rejected once a version exists.' })
+  type?: string
+
   @Field({ nullable: true, description: 'The new display name.' })
   name?: string
 

package/translations/en.json

@@ -0,0 +1,3 @@
+{
+  "error.figure-release-does-not-compile": "the released source of {type} (version {version}) does not compile. open it in the modeller, fix it and release it again before it draws on a board."
+}

package/translations/ko.json

@@ -0,0 +1,3 @@
+{
+  "error.figure-release-does-not-compile": "{type} 의 발행판({version})이 지금 컴파일되지 않습니다. 저작 화면에서 열어 고친 뒤 다시 발행해야 보드에 나옵니다."
+}