@things-factory/figure-service 10.1.28 → 10.1.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-service",
-  "version": "10.1.28",
+  "version": "10.1.29",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -23,15 +23,15 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.1.21",
+    "@hatiolab/figure-model": "^0.1.27",
     "@operato/typeorm-history": "^10.0.0",
-    "@things-factory/ai-client-base": "^10.1.28",
-    "@things-factory/auth-base": "^10.1.28",
+    "@things-factory/ai-client-base": "^10.1.29",
+    "@things-factory/auth-base": "^10.1.29",
     "@things-factory/env": "^10.1.20",
-    "@things-factory/shell": "^10.1.28",
+    "@things-factory/shell": "^10.1.29",
     "graphql-scalars": "^1.22.4",
     "graphql-upload": "^15.0.2",
     "koa-router": "^7.4.0"
   },
-  "gitHead": "3a260a0f79bc6b41a692a103955bfcc541aff60e"
+  "gitHead": "e6bf9dec003fe5e794746aaeb5852b3b50478232"
 }

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

@@ -8,6 +8,7 @@ import { FigureHistory } from './figure-history.js'
 import { FigurePatch, FigureSaveResult, NewFigure } from './figure-type.js'
 import { FigureProposal, ProposeRequest } from './figure-propose-type.js'
 import { inspectSource } from './figure-gate.js'
+import { renameDraftType, renameFacts } from './figure-rename.js'
 import { parseSource } from './figure-source.js'
 import { ProposeFailure, proposeFigure } from './figure-propose.js'
 
@@ -78,6 +79,23 @@ export class FigureMutation {
       violations = parsed.violations
     }
 
+    /*
+      **타입은 발행 전에만 바뀐다** — ADR-0063 결정 4.
+
+      발행된 뒤에는 이미 배치된 도면이 이 이름을 가리키고, 바꾸면 그 도면이 아무 오류 없이
+      빈 자리가 된다. 발행된 적 없는 도형은 가리키는 도면이 있을 수 없다 — 도면은 최신
+      발행판을 그리므로 그려질 자리가 없다.
+
+      행과 정본 둘 다 고친다. 정본 안에도 `type` 이 있어서 한쪽만 고치면 저장된 JSON 과
+      행이 다른 이름을 말하고, 발행할 때 어느 쪽이 도면에 적히는지가 갈린다.
+    */
+    let renamed: string | undefined
+    if (patch.type !== undefined && patch.type !== figure.type) {
+      const change = await this.renameType(figure, domain, patch.type, source, tx)
+      renamed = change.type
+      source = change.source
+    }
+
     /*
       **판 번호는 여기서 손대지 않는다.** 저장은 저작이고, 판은 발행에서 생긴다(`releaseFigure`).
       board 의 `updateBoard` 도 같다 — 저장 경로에는 version 이 없다.
@@ -93,6 +111,8 @@ export class FigureMutation {
       domain,
       ...figure,
       ...patch,
+      /* 앞뒤 공백을 떼고 겹침까지 본 이름. `patch.type` 을 그대로 두면 다듬기 전 값이 들어간다. */
+      ...(renamed !== undefined ? { type: renamed } : {}),
       source,
       /*
         **고치면 발행이 풀린다.**
@@ -114,6 +134,30 @@ export class FigureMutation {
     return { figure: saved, violations }
   }
 
+  /**
+   * 초안의 타입을 고친다 — 규칙은 `figure-rename.ts`, 여기서는 그 규칙이 볼 **사실만** 읽는다.
+   *
+   * 겹침은 DB 인덱스(`ix_figure_1`)도 잡지만 먼저 읽어 본다. 인덱스가 던지는 말은 저작자가
+   * 읽을 것이 못 되고, 어느 이름이 이미 쓰였는지도 안 알려 준다.
+   */
+  private async renameType(
+    figure: Figure,
+    domain: { id: string },
+    wanted: string,
+    source: string,
+    tx: { getRepository: <T>(target: new () => T) => any }
+  ): Promise<{ type: string; source: string }> {
+    /* 읽어 온 엔티티에는 관계가 안 실려 있다 — 도메인은 문맥에서 온 것을 쓴다. */
+    const facts = await renameFacts(
+      { figures: tx.getRepository(Figure), histories: tx.getRepository(FigureHistory) },
+      figure,
+      domain,
+      wanted
+    )
+
+    return renameDraftType({ type: figure.type, source }, wanted, facts)
+  }
+
   /**
    * 발행한다 — **판이 생기는 유일한 자리.**
    *

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

@@ -188,7 +188,7 @@ export function rulesPrompt(palette: string[]): string {
     'Hard limits — exceeding these makes the figure unusable at scale:',
     `  parts        by detailLevel: ${partLimits}`,
     `  material groups (distinct token+preset+slot combinations)  <= ${LIMITS.materialGroups}`,
-    `  animated parts  <= ${LIMITS.animatedParts}`,
+    `  independently transformed parts  <= ${LIMITS.independentParts}`,
     `  transparent materials  <= ${LIMITS.transparentMaterials}`,
     '',
     'Geometry rules:',

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

@@ -0,0 +1,138 @@
+/**
+ * 이름을 바꾸기 전에 읽는 사실 셋 — **sqlite 를 실제로 들고** 확인한다.
+ *
+ * 규칙(`renameDraftType`)은 사실을 받아 판단하므로 DB 없이 시험한다. 그런데 그 사실을 읽는
+ * 질의가 틀리면 저작자에게는 저장 실패로만 보인다. 실제로 그랬다 — 판본을 `figure: { id }` 로
+ * 물었고 `FigureHistory` 는 관계 칸이 아니라 `originalId` 로 가리킨다. TypeORM 이 「그런 속성이
+ * 없다」로 던졌고, 순수 시험은 전부 초록이었다.
+ *
+ * 그래서 여기서는 질의를 **돌려 본다.**
+ */
+import type { DataSource } from 'typeorm'
+
+const { DataSource: TypeOrmDataSource } = require('typeorm')
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+
+let dataSource: DataSource | null = null
+let Figure: any
+let FigureHistory: any
+let renameFacts: any
+
+function loadCompiled(modulePath: string): any {
+  const { existsSync } = require('fs')
+  const { join } = require('path')
+  const resolved = join(__dirname, '..', '..', '..', 'dist-server', `${modulePath}.js`)
+
+  if (!existsSync(resolved)) {
+    throw new Error(
+      `figure-service 산출물이 없다: ${resolved}\n` +
+        `이 시험은 tsc 산출물을 든다. 먼저 빌드할 것:\n` +
+        `  yarn workspace @things-factory/figure-service build:server`
+    )
+  }
+
+  return require(resolved)
+}
+
+beforeAll(async () => {
+  Figure = loadCompiled('service/figure/figure').Figure
+  FigureHistory = loadCompiled('service/figure/figure-history').FigureHistory
+  renameFacts = loadCompiled('service/figure/figure-rename').renameFacts
+
+  dataSource = new TypeOrmDataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [...shell.entities, ...authBase.entities, Figure, FigureHistory],
+    logging: false
+  })
+
+  await dataSource.initialize()
+  shell.addDataSource('default', dataSource)
+  shell.addDataSource('tx', dataSource)
+})
+
+beforeEach(async () => {
+  await dataSource!.synchronize(true)
+  await seedDomain()
+})
+
+afterAll(async () => {
+  if (!dataSource) return
+  shell.removeDataSource('default')
+  shell.removeDataSource('tx')
+  await dataSource.destroy()
+  dataSource = null
+})
+
+let DOMAIN: { id: string }
+
+/* 도형이 도메인을 가리킨다 — 행이 없으면 외래키가 먼저 막는다. */
+async function seedDomain() {
+  const saved = await dataSource!.getRepository(shell.Domain).save({ name: 'rename-probe', subdomain: 'rename-probe' })
+  DOMAIN = { id: saved.id }
+}
+
+async function seedFigure(over: Record<string, unknown> = {}) {
+  return await dataSource!.getRepository(Figure).save({
+    type: 'FIGURE_MU6SZ5DL',
+    name: '초안',
+    source: '{}',
+    state: 'draft',
+    version: 0,
+    domain: DOMAIN,
+    ...over
+  })
+}
+
+const facts = async (figure: any, wanted: string) =>
+  await renameFacts(
+    { figures: dataSource!.getRepository(Figure), histories: dataSource!.getRepository(FigureHistory) },
+    figure,
+    DOMAIN,
+    wanted
+  )
+
+describe('이름을 바꾸기 전에 읽는 사실', () => {
+  it('★ 판본 질의가 실제로 돈다 — 칸 이름이 틀리면 여기서 던진다', async () => {
+    const figure = await seedFigure()
+
+    expect(await facts(figure, 'ROBOT_ARM')).toEqual({ version: 0, hasHistory: false, takenByAnother: false })
+  })
+
+  it('★ 판본이 있으면 그것을 읽어 온다', async () => {
+    const figure = await seedFigure()
+    await dataSource!.getRepository(FigureHistory).save({
+      originalId: figure.id,
+      version: 1,
+      type: figure.type,
+      name: figure.name,
+      source: '{}',
+      domain: DOMAIN
+    })
+
+    expect((await facts(figure, 'ROBOT_ARM')).hasHistory).toBe(true)
+  })
+
+  it('같은 도메인에서 그 이름을 쓰는 다른 도형을 찾는다', async () => {
+    const figure = await seedFigure()
+    await seedFigure({ type: 'CONVEYOR', name: '컨베이어' })
+
+    expect((await facts(figure, 'CONVEYOR')).takenByAnother).toBe(true)
+  })
+
+  it('자기 이름은 겹침이 아니다', async () => {
+    const figure = await seedFigure()
+
+    expect((await facts(figure, figure.type)).takenByAnother).toBe(false)
+  })
+
+  it('빈 이름은 겹침을 묻지 않는다 — 규칙이 먼저 거절한다', async () => {
+    const figure = await seedFigure()
+
+    expect((await facts(figure, '   ')).takenByAnother).toBe(false)
+  })
+})

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

@@ -5,6 +5,9 @@
  * 실제로 등록된 명세를 등록기에 넣고, 등록기가 무엇도 문제 삼지 않는지 묻는다. 도구 목록이 늘면
  * 이 시험이 먼저 문다.
  */
+import { readdirSync, readFileSync } from 'fs'
+import { join } from 'path'
+
 import { clearToolRegistry, getAllToolSpecs, getToolRegistryWarnings } from '@things-factory/ai-client-base'
 
 import { registerFigureToolCategories } from './figure-tools'
@@ -36,3 +39,105 @@ describe('figure tools — declared doors', () => {
     expect(getToolRegistryWarnings().map(w => `${w.code}:${w.params.tool ?? ''}`)).toEqual([])
   })
 })
+
+/*
+ * 베낀 권한이 문의 지시자와 같은가 — ADR-0072 결정 5 (b).
+ *
+ * 권한은 문의 지시자에서 나와야 하는데(ADR-0071 결정 2) 지금은 읽을 자리가 없다: 지시자가 남기는
+ * 것은 (category, privilege) 쌍 목록뿐이고 필드별 지도가 없다. 그래서 도구 명세가 권한을 베껴
+ * 적는다. 베낀 값은 **문이 바뀌어도 안 따라간다** — 문에 권한을 붙이거나 떼거나 이름을 고치면
+ * 도구 명세만 옛 값을 들고 남고, 그때 게이트는 문이 안 묻는 것을 묻거나 문이 묻는 것을 안 묻는다.
+ *
+ * 여기서는 리졸버 원문의 지시자를 읽어 도구가 적은 것과 견준다. AUTH 에 청한 필드별 지도가 서면
+ * 이 시험과 베끼기가 함께 없어진다.
+ */
+describe('figure tools — the copied privilege matches the door', () => {
+  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 mismatched = getAllToolSpecs().flatMap(spec =>
+      ((spec as any).doors ?? []).map((door: string) => {
+        const declared = doors.get(door)
+        const copied = (spec as any).privilege
+        if (!declared) return `${spec.name} → ${door}: 그런 문이 없거나 그 문이 권한을 선언하지 않는다`
+        if (
+          declared.category !== copied?.category ||
+          declared.privilege !== copied?.privilege ||
+          declared.owner !== (copied?.owner ?? false)
+        ) {
+          return `${spec.name} → ${door}: 문은 ${JSON.stringify(declared)} 인데 도구는 ${JSON.stringify(copied)}`
+        }
+        return undefined
+      })
+    ).filter(Boolean)
+
+    expect(mismatched).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-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