@things-factory/figure-service 10.1.66 → 10.1.67

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

@@ -1,44 +1,62 @@
 /*
- * Which format a stored source is written in, and one door per job that reads either.
- *
- * ## Why this exists
- *
- * The cutover (ADR-0087) converts assets to V3 and the `source` column holds one or the other while that
- * happens. Every server path that reads a source — saving, publishing, restoring a version, handing a
- * blueprint to a board — had exactly one implementation, the V2 one, so a V3 asset saved through
- * `saveFigureV3` could not be published, restored or drawn. Branching at each of those four places would put
- * the same question in four voices; it is asked once, here.
- *
- * ## How the format is known
- *
- * The asset says so. A V2 source carries `version: 2`; a V3 asset carries `version: 'figure-v3-asset-1'`.
- * Nothing is guessed from the shape of the object: a source that says neither is refused by name, because a
- * source the server cannot identify is one it must not save.
- *
- * ## What is not here
- *
- * No conversion. This door reads what is stored; turning a V2 asset into a V3 one is `convertV2ToV3`, run
- * deliberately against a recoverable copy (the designer's step 3), never as a side effect of a save.
+ * 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
+ * that does not is refused by name, because a source the server cannot identify is one it must not save.
  */
-import { compile, compileV3Asset, inspectV3Asset, isPlaceholderType, parseV3Asset, serializeV3Asset, v3ContractChanges, v3CostOf, v3ScoreOf } from '@hatiolab/figure-model'
+import { compileV3Asset, inspectV3Asset, isPlaceholderType, parseV3Asset, serializeV3Asset, v3ContractChanges, v3CostOf, v3ScoreOf } from '@hatiolab/figure-model'
 import type { V3Asset, V3ContractChange, V3ContractError, V3Violation } from '@hatiolab/figure-model'
 
-import type { GateFinding, Inspection } from './figure-gate.js'
-import { inspectSource } from './figure-gate.js'
-import { FigureSourceError, parseSource } from './figure-source.js'
-import type { ParsedSource } from './figure-source.js'
-
-export type FigureFormat = 'v2' | 'v3'
+import type { FigureFinding } from './figure-type.js'
 
-/** The version each format stamps on its own source. */
+/** The version the format stamps on its own source. */
 export const V3_ASSET_VERSION = 'figure-v3-asset-1'
 
+/** A source that passed the save door: what is stored, and the numbers the catalogue shows, computed here. */
+export interface ParsedSource {
+  /** The source to store, as the kernel serializes it. */
+  source: string
+  /** Computed from the source, never taken from the client -- a client's numbers could lie to the catalogue. */
+  derived: { score: number; triangles: number; groups: number }
+  /** Findings that do not block the save; the caller returns them with the answer. */
+  violations: FigureFinding[]
+}
+
+/** The source breaks the format. It is not stored. */
+export class FigureSourceError extends Error {
+  readonly findings: FigureFinding[]
+
+  constructor(findings: FigureFinding[]) {
+    super(`정본이 형식을 어겼다 — ${findings.length}건: ${findings.map(f => f.code).join(', ')}`)
+    this.name = 'FigureSourceError'
+    this.findings = findings
+  }
+}
+
+/** One thing the release gate found. `blocking` true means the figure cannot be published. */
+export interface GateFinding {
+  code: string
+  message: string
+  /** **Why it matters.** A measurement alone leaves the reader at "so what?". */
+  why?: string
+  /** **What to change.** By part name and value. */
+  how?: string
+  /** Where it points: the parts, or the path in the source. */
+  at?: string
+  blocking: boolean
+}
+
+export interface Inspection {
+  findings: GateFinding[]
+  /** Whether anything blocks. The screen locks the button with this. */
+  blocked: boolean
+}
+
 /**
- * Which format this source is written in, read from the `version` the asset carries.
+ * That the source is JSON and names the format.
  *
- * @throws {FigureSourceError} when the text is not JSON, or carries no version this server knows.
+ * @throws {FigureSourceError} when the text is not JSON, or does not carry `version: 'figure-v3-asset-1'`.
  */
-export function formatOf(sourceJson: string): FigureFormat {
+function assertFormat(sourceJson: string): void {
   let parsed: unknown
   try {
     parsed = JSON.parse(sourceJson)
@@ -47,31 +65,21 @@ export function formatOf(sourceJson: string): FigureFormat {
       { code: 'source-not-json', message: `정본이 JSON 이 아니다: ${(e as Error).message}`, at: 'source' }
     ])
   }
-  const version = (parsed as { version?: unknown } | null)?.version
-  if (version === V3_ASSET_VERSION) return 'v3'
-  if (typeof version === 'number') return 'v2'
-  throw new FigureSourceError([
-    {
-      code: 'source-format-unknown',
-      message: `정본의 판을 알 수 없다 — V2 는 숫자 version 을, V3 자산은 '${V3_ASSET_VERSION}' 을 적는다`,
-      at: 'version'
-    }
-  ])
+  if ((parsed as { version?: unknown } | null)?.version !== V3_ASSET_VERSION)
+    throw new FigureSourceError([
+      { code: 'source-format-unknown', message: `정본의 판을 알 수 없다 — 도형 자산은 version '${V3_ASSET_VERSION}' 을 적는다`, at: 'version' }
+    ])
 }
 
 /**
- * Validates a source of either format and computes what the catalogue shows.
+ * Validates a source and computes what the catalogue shows: the cost from `v3CostOf`, and the score from `v3ScoreOf`
+ * -- 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.
  *
- * A V3 asset is measured with `v3CostOf`, which charges the same per-shape estimate V2 charges, so the
- * budget columns mean one thing across the two formats. Its `score` is `v3ScoreOf`'s -- 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.
- *
- * @throws {FigureSourceError} when the source breaks its own format.
+ * @throws {FigureSourceError} when the source breaks the format.
  */
-export function parseAnySource(sourceJson: string): ParsedSource & { format: FigureFormat } {
-  if (formatOf(sourceJson) === 'v2') return { ...parseSource(sourceJson), format: 'v2' }
-
+export function parseSource(sourceJson: string): ParsedSource {
+  assertFormat(sourceJson)
   let asset
   try {
     asset = parseV3Asset(sourceJson)
@@ -85,7 +93,6 @@ export function parseAnySource(sourceJson: string): ParsedSource & { format: Fig
   const cost = v3CostOf(asset)
   const score = v3ScoreOf(asset)
   return {
-    format: 'v3',
     source: serializeV3Asset(asset),
     derived: { score: (score?.score ?? null) as unknown as number, triangles: cost.triangles, groups: cost.groups },
     violations: []
@@ -95,7 +102,7 @@ export function parseAnySource(sourceJson: string): ParsedSource & { format: Fig
 /**
  * Whether this source may be published, and why not.
  *
- * For V3 the judgement is `inspectV3Asset`: every part inside the volume the asset declares, over the whole
+ * The judgement is `inspectV3Asset`: 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.
@@ -113,8 +120,7 @@ export type Translate = (key: string, options?: Record<string, unknown>) => stri
  * rather than as the key printed raw.
  *
  * 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`). The same register as the V2 blockers since 2026-09-19 — a fact, then
- * the way out — because at ADR-0087 step 5 these become the only findings an author sees.
+ * (`figure.text.mounting-face-explained`). A fact, then the way out.
  */
 function v3Wording(violation: V3Violation, say: Say, hasParts: boolean): Pick<GateFinding, 'message' | 'why' | 'how'> {
   const part = violation.part ?? ''
@@ -164,7 +170,7 @@ function v3Wording(violation: V3Violation, say: Say, hasParts: boolean): Pick<Ga
     case 'PARTS_SPLIT_ON_RESIZE': {
       /*
         What comes off is every piece but the largest — the figure as the author sees it is the big piece, and the
-        small ones are what they will see hanging in the air (V2's sizing-splits, carried to V3 on 2026-09-24).
+        small ones are what they will see hanging in the air (2026-09-24).
       */
       const resize = violation.resize!
       const pieces = [...resize.pieces].sort((a, b) => b.length - a.length)
@@ -203,23 +209,22 @@ function sayerOf(t?: Translate): Say {
     t ? t(key, { ...params, defaultValue: english, interpolation: { escapeValue: false } }) : english
 }
 
-export function inspectAnySource(
+export function inspectSource(
   sourceJson?: string | null,
   releasedJson?: string | null,
   t?: Translate,
-  /** The row's `type` — for V3 the only place the name lives, since the asset carries none. */
+  /** The row's `type` -- the only place the name lives, since the asset carries none. */
   rowType?: string
 ): Inspection {
-  if (!sourceJson) return inspectSource(sourceJson, releasedJson)
-
-  let format: FigureFormat
+  if (!sourceJson) {
+    return { blocked: true, findings: [{ code: 'no-source', message: '저장된 정본이 없다. 저장하면 발행할 수 있다', blocking: true }] }
+  }
   try {
-    format = formatOf(sourceJson)
+    assertFormat(sourceJson)
   } catch (e) {
     const findings = (e as FigureSourceError).findings ?? [{ code: 'source-unreadable', message: String(e) }]
     return { blocked: true, findings: findings.map(f => ({ ...f, blocking: true })) }
   }
-  if (format === 'v2') return inspectSource(sourceJson, releasedJson)
 
   let inspection
   let asset: V3Asset | undefined
@@ -245,10 +250,9 @@ export function inspectAnySource(
     blocking: true
   }))
   /*
-    V2 refuses a machine-made name at release (`type-is-placeholder`, from the source's own `type`). A V3 asset has
-    no `type`, so that check never ran and a new V3 figure was published as `FIGURE_<uuid>` — seen on :3300,
-    2026-09-24. Publishing freezes the name (ADR-0063 decision 4) and boards call a figure by it, so the same
-    refusal stands here, read off the row.
+    A machine-made name is refused at release. The asset has no `type`, so the name is read off the row; a new figure
+    was once published as `FIGURE_<uuid>` (:3300, 2026-09-24). Publishing freezes the name (ADR-0063 decision 4) and
+    boards call a figure by it.
   */
   if (rowType && isPlaceholderType(rowType)) {
     findings.push({
@@ -283,23 +287,12 @@ export function inspectAnySource(
  * 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
- * the last release cannot be compared — it was a V2 source, which is what every converted figure's last release
- * is, or it no longer parses — the gate says so rather than passing in silence: a release that was not checked
+ * 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
   try {
-    if (formatOf(releasedJson) === 'v2') {
-      return [
-        {
-          code: 'released-unreadable',
-          message: say('figure.gate.v3-released-was-v2.message', {}, 'The last release is a V2 figure, so this release was not compared with it.'),
-          why: say('figure.gate.v3-released-not-compared.why', {}, 'Whether this release breaks the instances already placed has not been checked.'),
-          blocking: false
-        }
-      ]
-    }
     before = parseV3Asset(releasedJson)
   } catch (e) {
     return [
@@ -430,15 +423,12 @@ function v3ContractWording(change: V3ContractChange, say: Say): Pick<GateFinding
 }
 
 /**
- * What a consumer is handed for a released figure.
- *
- * V2 hands over a compiled blueprint; V3 hands over the asset itself, because the thing that draws a V3 asset
- * — `registerFigureV3` in things-scene — takes the asset and compiles it with the kernel. The format travels
- * with it so the consumer calls the right registration rather than sniffing the payload a second time.
+ * What a consumer is handed for a released figure: the asset itself, because what draws it -- `registerFigureV3` in
+ * things-scene -- takes the asset and compiles it with the kernel.
  */
-export function consumablePayloadOf(sourceJson: string): { format: FigureFormat; blueprint?: unknown; asset?: unknown } {
-  if (formatOf(sourceJson) === 'v2') return { format: 'v2', blueprint: compile(JSON.parse(sourceJson)) }
+export function consumablePayloadOf(sourceJson: string): { asset: V3Asset } {
+  assertFormat(sourceJson)
   const asset = parseV3Asset(sourceJson)
   compileV3Asset(asset)
-  return { format: 'v3', 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 canonical FigureSource JSON at this version.' })
+  @Field({ nullable: true, description: 'The figure asset JSON (figure-v3-asset-1) at this version.' })
   source?: string
 
   @Column({ nullable: true, ...longTextColumn() })

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

@@ -1,7 +1,7 @@
 /*
  * The inspect doors, read against a real row.
  *
- * `inspectAnySource` is tested on its own in figure-format.test.ts, and that is where the temporary-type refusal was
+ * `inspectSource` is tested on its own in figure-format.test.ts, and that is where the temporary-type refusal was
  * first pinned. It still did not reach the release panel: `inspectFigure` selected only `id` and `source`, so the row's
  * `type` arrived as `undefined` and the refusal never ran. The panel enabled 「발행하기」 and the release mutation —
  * which loads the whole row — refused on the press (2026-09-24). A test of the function could not see that; this
@@ -128,13 +128,3 @@ describe('inspectFigureDraft — the verdict while editing', () => {
     expect(declaration).toContain('category: "figure", privilege: "query"')
   })
 })
-
-describe('format — which modeller a screen opens', () => {
-  it('reads the format off the stored source; a source it cannot identify has none', () => {
-    const query = new FigureQuery()
-    expect(query.format({ source: sound() } as any)).toBe('v3')
-    expect(query.format({ source: JSON.stringify({ version: 2, parts: [] }) } as any)).toBe('v2')
-    expect(query.format({ source: 'not json' } as any)).toBeNull()
-    expect(query.format({} as any)).toBeNull()
-  })
-})

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

@@ -8,9 +8,9 @@ import { Figure } from './figure.js'
 import { FigureHistory } from './figure-history.js'
 import { FigurePatch, FigureSaveResult, NewFigure } from './figure-type.js'
 import { FigureProposal, ProposeRequest } from './figure-propose-type.js'
-import { inspectAnySource } from './figure-format.js'
+import { inspectSource } from './figure-format.js'
 import { renameDraftType, renameFacts } from './figure-rename.js'
-import { parseAnySource } from './figure-format.js'
+import { parseSource } from './figure-format.js'
 import { ProposeV3Failure, proposeFigureV3 } from './figure-propose-v3.js'
 import { prepareV3Write, compareAndSwapV3, pictureOf } from './figure-v3-write.js'
 
@@ -47,7 +47,7 @@ export class FigureMutation {
         — seen on :3300, 2026-09-24. A retry is still safe: the row id is the creation id, not the name.
       */
       /*
-        The author names it on the first save, as V2 asked (lost in the move to V3, 2026-09-25): created under that
+        The author names it on the first save (2026-09-25): created under that
         name or not at all -- a taken name refuses the save, rather than saving under the temporary one and failing a
         rename after. Without a name (a caller that has none to give) it is the temporary one, renamed later.
       */
@@ -95,7 +95,7 @@ export class FigureMutation {
     }
 
     // 형식을 어기면 여기서 던진다. 파생값은 서버가 계산한다.
-    const { source, derived, violations } = parseAnySource(figure.source)
+    const { source, derived, violations } = parseSource(figure.source)
 
     const saved = await repository.save({
       ...figure,
@@ -136,7 +136,7 @@ export class FigureMutation {
     let source = figure.source
 
     if (patch.source !== undefined && patch.source !== figure.source) {
-      const parsed = parseAnySource(patch.source)
+      const parsed = parseSource(patch.source)
       source = parsed.source
       derived = parsed.derived
       violations = parsed.violations
@@ -287,7 +287,7 @@ export class FigureMutation {
       .limit(1)
       .getOne()
 
-    const inspection = inspectAnySource(figure.source, released?.source, context.t, figure.type)
+    const inspection = inspectSource(figure.source, released?.source, context.t, figure.type)
     if (inspection.blocked) {
       const reasons = inspection.findings
         .filter(finding => finding.blocking)
@@ -361,7 +361,7 @@ export class FigureMutation {
     }
 
     /* 형식 검사도 다시 받는다 — 옛 판이 오늘의 형식을 어길 수 있고, 그것을 조용히 들이지 않는다. */
-    const { source, derived, violations } = parseAnySource(history.source)
+    const { source, derived, violations } = parseSource(history.source)
 
     const saved = await repository.save({
       /*

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

@@ -47,11 +47,11 @@ const liftTable = [
 const withoutRoom = liftTable.slice(0, -1)
 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, never V2', () => {
+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)
-    expect(rules).not.toMatch(/figure-v1|"parts"\s*:\s*\[|anchor/i)
+    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)', () => {

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

@@ -76,7 +76,7 @@ export function rulesPromptV3(): string {
   ].join('\n')
 }
 
-/** The request, and the open draft's V3 source when revising. Never V2. */
+/** The request, and the open draft's source when revising. */
 export function taskPromptV3(input: ProposeV3Input): string {
   const lines = [`Request: ${input.prompt}`]
   if (input.base) {

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

@@ -1,7 +1,6 @@
 import { In } from 'typeorm'
-import { Args, Arg, Ctx, Directive, FieldResolver, Query, Resolver, Root, UseMiddleware } from 'type-graphql'
+import { Args, Arg, Ctx, Directive, Query, Resolver, UseMiddleware } from 'type-graphql'
 import { GraphQLJSON } from 'graphql-scalars'
-import { compile } from '@hatiolab/figure-model'
 
 import {
   Domain,
@@ -14,29 +13,12 @@ import {
 
 import { Figure } from './figure.js'
 import { FigureHistory } from './figure-history.js'
-import { consumablePayloadOf, formatOf, inspectAnySource } from './figure-format.js'
+import { consumablePayloadOf, inspectSource } from './figure-format.js'
 import { FigureInspection, FigureList } from './figure-type.js'
 
 @Resolver(Figure)
 @UseMiddleware(SpeakRefusals)
 export class FigureQuery {
-  /**
-   * Which format the stored source is in — so a screen opens the modeller that can edit it.
-   *
-   * The catalogue sent every figure to the V2 modeller. A converted figure there fails to open, and the V3 modeller
-   * could only be reached by typing its address (2026-09-24). The row does not say; the source does (`formatOf`).
-   * A source the server cannot identify has no format rather than a guessed one.
-   */
-  @FieldResolver(type => String, { nullable: true, description: "The format of the stored source: 'v2' or 'v3'." })
-  format(@Root() figure: Figure): string | null {
-    if (!figure.source) return null
-    try {
-      return formatOf(figure.source)
-    } catch {
-      return null
-    }
-  }
-
   @Directive('@privilege(category: "figure", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => Figure, { nullable: true, description: 'Finds a single figure by its ID.' })
   async figure(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Figure> {
@@ -154,7 +136,7 @@ export class FigureQuery {
       .limit(1)
       .getOne()
 
-    return inspectAnySource(figure.source, released?.source, context.t, figure.type)
+    return inspectSource(figure.source, released?.source, context.t, figure.type)
   }
 
   /**
@@ -173,7 +155,7 @@ export class FigureQuery {
     @Arg('id', { nullable: true }) id?: string
   ): Promise<FigureInspection> {
     const { domain } = context.state
-    if (!id) return inspectAnySource(source, null, context.t)
+    if (!id) return inspectSource(source, null, context.t)
 
     const figure = await getRepository(Figure).findOne({
       where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id },
@@ -188,7 +170,7 @@ export class FigureQuery {
       .limit(1)
       .getOne()
 
-    return inspectAnySource(source, released?.source, context.t, figure.type)
+    return inspectSource(source, released?.source, context.t, figure.type)
   }
 
   @Directive('@privilege(category: "figure", privilege: "query", domainOwnerGranted: true)')
@@ -205,13 +187,16 @@ export class FigureQuery {
   }
 
   /**
-   * 소비처(operato-board, operato-twin, things-scene)를 위한 컴파일된 청사진(FigureBlueprint) 질의.
+   * 소비처(operato-board, operato-twin, things-scene)가 발행된 도형을 받아 가는 문.
+   *
+   * 이름은 보드와의 계약이라 그대로 둔다(바꾸는 일은 따로 한다). 돌려주는 것은 자산이다 —
+   * `{ format: 'v3', type, asset }`. 그리는 쪽(`registerFigureV3`)이 커널로 컴파일한다.
    *
    * ## 규칙
    * 1. 소비처는 초안(draft)을 볼 수 없다 — **반드시 발행된(released) 판만 전달**한다.
-   * 2. 현재 Figure가 released 상태이면 현재 source를 컴파일한다.
+   * 2. 현재 Figure가 released 상태이면 현재 source를 넘긴다.
    * 3. 현재 Figure가 저작 중(draft)이더라도 이전에 발행된 이력(FigureHistory)이 있으면
-   *    가장 최근의 released 판본을 컴파일하여 하위 호환성을 유지한다.
+   *    가장 최근의 released 판본을 넘긴다.
    * 4. 한 번도 발행된 적 없는 초안 자산이거나 존재하지 않는 타입인 경우 null을 반환하여
    *    미완성 자산이 씬 화면에 유출되는 것을 엄격히 차단한다.
    * 5. 도메인 상속 시 자식 도메인의 타입이 부모 도메인의 동일 타입을 항상 오버라이드한다.
@@ -236,7 +221,7 @@ export class FigureQuery {
   @Directive('@privilege(category: "figure-published", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => GraphQLJSON, {
     nullable: true,
-    description: 'Compiled FigureBlueprint for external consumers (board, twin, things-scene). Only returns released figures.'
+    description: 'A released figure for its consumers (board, twin, things-scene): { format, type, asset } with the figure asset. Only returns released figures.'
   })
   async figureBlueprint(
     @Arg('type') type: string,
@@ -261,17 +246,10 @@ export class FigureQuery {
     const { figure, source: sourceToCompile, version } = found
 
     try {
-      /*
-        A V2 figure hands over its compiled blueprint, as it always did. A V3 asset hands over the asset
-        itself under a `format` tag, because the thing that draws it — `registerFigureV3` — takes the asset
-        and compiles it with the kernel. A V2 blueprint carries no `format`, so a consumer that has not been
-        taught about V3 keeps working and a V3 payload is recognised rather than guessed at (ADR-0087).
-      */
       const text = typeof sourceToCompile === 'string' ? sourceToCompile : JSON.stringify(sourceToCompile)
-      const payload = consumablePayloadOf(text)
-      return payload.format === 'v3' ? { format: 'v3', type, asset: payload.asset } : payload.blueprint
+      return { format: 'v3', type, asset: consumablePayloadOf(text).asset }
     } catch (err) {
-      console.error(`[figureBlueprint] 타입 '${type}' (figure id: ${figure.id}) 청사진 컴파일 실패:`, err)
+      console.error(`[figureBlueprint] 타입 '${type}' (figure id: ${figure.id}) 자산 컴파일 실패:`, err)
 
       /*
         Null says one thing here: nobody published this type (ADR-0063 결정 2 보탬). A released figure

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

@@ -138,7 +138,7 @@ describe('이름을 바꾸기 전에 읽는 사실', () => {
 })
 
 /*
- * The first save names the figure (V2 asked for the type on the first save; the V3 modeller lost it, 2026-09-25).
+ * The first save names the figure (the modeller once lost the question, 2026-09-25).
  * Through the door itself, on sqlite: created under that name or not at all.
  */
 describe('처음 저장에 타입 이름을 받는다', () => {

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

@@ -13,25 +13,18 @@ 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: [] }),
+  source: serializeV3Asset(createV3Asset('새 Figure')),
   ...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')
-  })
-
   /*
-    V3 자산에는 type 칸이 없고 V3 형식은 모르는 칸을 거절한다. V2 처럼 원본에 이름을 써 넣었더니
-    그 도형을 다시 열 수 없었다(`parseV3Asset` — "unknown type"). V3 는 행만 바뀐다.
+    자산에는 type 칸이 없고 형식은 모르는 칸을 거절한다. 원본에 이름을 써 넣었더니 그 도형을 다시 열 수
+    없었다(`parseV3Asset` — "unknown type"). 행만 바뀐다.
   */
-  it('★ V3 도형은 행만 바뀌고, 원본은 그대로 다시 열린다', () => {
+  it('★ 행만 바뀌고, 원본은 그대로 다시 열린다', () => {
     const source = serializeV3Asset(createV3Asset('새 Figure'))
     const result = renameDraftType({ type: 'FIGURE_ABCDEF12', source }, 'ROLLER_CONVEYOR', never)
 
@@ -40,13 +33,6 @@ describe('초안의 type 고치기', () => {
     expect(() => parseV3Asset(result.source)).not.toThrow()
   })
 
-  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')

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

@@ -19,7 +19,6 @@
  * 그래야 규칙을 DB 없이 시험한다. 문(`figure-mutation.ts`)이 그 셋을 읽어 넘긴다.
  */
 
-import { V3_ASSET_VERSION } from './figure-format.js'
 
 /** 이름을 바꿀 때 알아야 하는 사실. 부르는 쪽이 저장소에서 읽어 온다. */
 export interface RenameFacts {
@@ -69,17 +68,8 @@ export function renameDraftType(
     throw new FigureRenameRefused('type-taken', `type 「${next}」 는 이 도메인에서 이미 쓰고 있다`)
   }
 
-  const parsed = JSON.parse(current.source) as { type?: string; version?: unknown }
-
-  /*
-    A V3 asset carries no `type`: the name a board uses is the row's alone, and the V3 schema refuses a field it
-    does not know. Writing it in, as V2 needs, left a V3 figure that could no longer be opened — `parseV3Asset`
-    answered "unknown type" (checked 2026-09-24). So only the row changes for V3.
-  */
-  if (parsed.version === V3_ASSET_VERSION) return { type: next, source: current.source }
-
-  parsed.type = next
-  return { type: next, source: JSON.stringify(parsed) }
+  /* The asset carries no `type`: the name a board uses is the row's alone, so only the row changes. */
+  return { type: next, source: current.source }
 }
 
 /**