@things-factory/figure-service 10.1.48 → 10.1.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-service",
-  "version": "10.1.48",
+  "version": "10.1.50",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -23,7 +23,7 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.1.54",
+    "@hatiolab/figure-model": "^0.1.57",
     "@operato/typeorm-history": "^10.0.0",
     "@things-factory/ai-client-base": "^10.1.39",
     "@things-factory/auth-base": "^10.1.47",
@@ -33,5 +33,5 @@
     "graphql-upload": "^15.0.2",
     "koa-router": "^7.4.0"
   },
-  "gitHead": "448b0d568a1816d25aa49f3b6233d8086d6011f9"
+  "gitHead": "4700d39d70eb5fae4ad56cf47ea0b966c8516ae2"
 }

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

@@ -25,7 +25,9 @@ export class FigureMutation {
     @Arg('id', { nullable: true }) id?: string,
     @Arg('expectedSource', { nullable: true }) expectedSource?: string,
     @Arg('creationId', { nullable: true }) creationId?: string,
-    @Arg('thumbnail', { nullable: true }) thumbnail?: string
+    @Arg('thumbnail', { nullable: true }) thumbnail?: string,
+    @Arg('type', { nullable: true, description: 'The type name a new figure is created under. Ignored for an existing one.' })
+    type?: string
   ): Promise<Figure> {
     const { domain, user, tx } = context.state
     const repository = tx.getRepository(Figure)
@@ -44,8 +46,23 @@ export class FigureMutation {
         not match, so a new V3 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.
       */
+      /*
+        The author names it on the first save, as V2 asked (lost in the move to V3, 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.
+      */
+      const named = type?.trim()
+      if (named) {
+        const facts = await renameFacts(
+          { figures: repository, histories: tx.getRepository(FigureHistory) },
+          { id: creationId },
+          domain,
+          named
+        )
+        renameDraftType({ type: named, source: prepared.source }, named, facts)
+      }
       // insert, not save: a concurrent retry must never turn into an unchecked overwrite.
-      await repository.insert({ ...prepared, id: creationId, type: placeholderType(),
+      await repository.insert({ ...prepared, id: creationId, type: named || placeholderType(),
         domain, creator: user, updater: user })
       return repository.findOneOrFail({ where: { id: creationId, domain: { id: domain.id } } })
     }

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

@@ -136,3 +136,48 @@ describe('이름을 바꾸기 전에 읽는 사실', () => {
     expect((await facts(figure, '   ')).takenByAnother).toBe(false)
   })
 })
+
+/*
+ * The first save names the figure (V2 asked for the type on the first save; the V3 modeller lost it, 2026-09-25).
+ * Through the door itself, on sqlite: created under that name or not at all.
+ */
+describe('처음 저장에 타입 이름을 받는다', () => {
+  let FigureMutation: any
+  let V3_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 } })
+    )
+  })
+
+  const save = (creationId: string, type?: string) =>
+    new FigureMutation().saveFigureV3(
+      V3_SOURCE,
+      { state: { domain: DOMAIN, user: undefined, tx: dataSource!.manager } },
+      undefined,
+      undefined,
+      creationId,
+      undefined,
+      type
+    )
+  const ids = ['8a1f2c3d-4b5e-4f60-8a71-92b3c4d5e6f7', '9b2e3d4c-5a6f-4e71-9b82-a3c4d5e6f708']
+
+  it('준 이름으로 만든다 — 앞뒤 빈칸은 뺀다', async () => {
+    const saved = await save(ids[0], '  ROBOT_ARM ')
+    expect(saved.type).toBe('ROBOT_ARM')
+  })
+
+  it('★ 이미 쓰는 이름이면 저장하지 않는다 — 임시 이름으로 남기지 않는다', async () => {
+    await seedFigure({ type: 'CONVEYOR', name: '컨베이어' })
+    await expect(save(ids[1], 'CONVEYOR')).rejects.toThrow(/이미 쓰고 있다/)
+    expect(await dataSource!.getRepository(Figure).count({ where: { id: ids[1] } })).toBe(0)
+  })
+
+  it('이름 없이 부르면 종전대로 임시 이름 — 나중에 고친다', async () => {
+    const model = require('@hatiolab/figure-model')
+    const saved = await save(ids[0])
+    expect(model.isPlaceholderType(saved.type)).toBe(true)
+  })
+})

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

@@ -110,13 +110,7 @@ describe('문이 이 규칙을 지난다', () => {
     V3 저장이 임시 이름을 스스로 지었다(`FIGURE_<32 hex>`). 형식의 `isPlaceholderType` 이 그것을 못 알아봐서
     발행 판정이 기계 이름을 통과시켰다. 짓는 쪽과 알아보는 쪽이 한 규칙이어야 한다.
   */
-  it('새 V3 도형의 임시 이름은 형식의 규칙으로 짓는다 — 판정이 알아보는 그 규칙', () => {
-    const mutation = readFileSync(join(__dirname, 'figure-mutation.ts'), 'utf8')
-    const save = mutation.slice(mutation.indexOf('async saveFigureV3'), mutation.indexOf('async createFigure'))
-
-    expect(save).toContain('type: placeholderType()')
-    expect(save).not.toMatch(/type: `FIGURE_/)
-  })
+  /* 새 V3 도형의 임시 이름이 판정이 알아보는 그 규칙인지는 문을 실제로 불러 본다 — figure-rename-db.test.ts 「이름 없이 부르면」. */
 
   it('문이 type 을 받는 칸을 갖는다', () => {
     const type = source('figure-type.ts')

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

@@ -92,7 +92,7 @@ export function renameDraftType(
  */
 export async function renameFacts(
   repositories: {
-    figures: { findOne(options: any): Promise<{ id: string } | null> }
+    figures: { findOne(options: any): Promise<{ id?: string } | null> }
     histories: { count(options: any): Promise<number> }
   },
   figure: { id?: string; version?: number },

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

@@ -79,7 +79,10 @@ function install() {
     costOf: model.costOf,
     scoreOf: model.scoreOf,
     validate: model.validate,
-    isPlaceholderType: model.isPlaceholderType
+    isPlaceholderType: model.isPlaceholderType,
+    parseAnySource: require('./figure-format').parseAnySource,
+    v3CostOf: model.v3CostOf,
+    v3ScoreOf: model.v3ScoreOf
   })
 }
 
@@ -505,3 +508,38 @@ describe('후보가 카드가 된다', () => {
     expect(proposed[0].refine).toBe(false)
   })
 })
+
+/*
+  V3 도형이 열려 있을 때(사용자 2026-09-24: 도크가 V3 초안에 「type 이 없다 · base 가 없다」 로 답했다). 읽기는 V3 로 읽고
+  잰다. 후보 제안은 아직 V2 만 쓰므로 지어내지 않고 그렇다고 말한다.
+*/
+describe('V3 도형이 열려 있을 때', () => {
+  const v3Draft = () => {
+    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 } })
+    return asset
+  }
+
+  it('저장 전 V3 초안을 V3 로 읽고, V3 셈으로 잰다', async () => {
+    const draft = v3Draft()
+    const got = await toolNamed('getFigureSource').builder({}, ctx({ figureId: 'fig-1', draftSource: draft, palette: ['palette.primary'] }))
+    expect(got.format).toBe('v3')
+    expect(got.draft).toBe(true)
+    expect(got.cost.triangles).toBe(12)
+    expect(got.score.grade).toBe('A')
+  })
+
+  it('형식을 어긴 V3 초안은 V3 의 말로 거절한다 — V2 파서의 말이 아니다', async () => {
+    const broken = { ...v3Draft(), appearance: [] }
+    await expect(toolNamed('getFigureSource').builder({}, ctx({ figureId: 'fig-1', draftSource: broken, palette: ['palette.primary'] }))).rejects.toThrow(/V3 draft/)
+    await expect(toolNamed('getFigureSource').builder({}, ctx({ figureId: 'fig-1', draftSource: broken, palette: ['palette.primary'] }))).rejects.not.toThrow(/base 가 없다/)
+  })
+
+  it('후보 제안은 V3 도형에 V2 후보를 지어내지 않고, 아직 못 한다고 말한다', async () => {
+    const got = await toolNamed('proposeFigureCandidate').builder({ prompt: '다리를 길게' }, ctx({ figureId: 'fig-1', draftSource: v3Draft(), palette: ['palette.primary'] }))
+    expect(got.error).toBe('V3_PROPOSAL_UNAVAILABLE')
+    expect(proposed).toHaveLength(0)
+  })
+})
+

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

@@ -62,6 +62,9 @@ function getDeps(): any {
         complaint. The tool's own contract is unchanged: it reads, it never saves (ADR-0087).
       */
       inspectSource: format.inspectAnySource,
+      parseAnySource: format.parseAnySource,
+      v3CostOf: model.v3CostOf,
+      v3ScoreOf: model.v3ScoreOf,
       proposeFigure: propose.proposeFigure,
       compile: model.compile,
       costOf: model.costOf,
@@ -153,6 +156,23 @@ async function resolveFigureTarget(figureId: string | undefined, domainId: strin
  * 찾은 뒤에만 보며, Figure의 불변 type과 형식 검증을 다시 확인한다. 검증되지 않은 큰 객체를 LLM
  * 프롬프트로 옮기면 비용만 태우고, DB에 있던 Figure와 다른 것을 고친다고 잘못 말할 수 있다.
  */
+/** A V3 asset names its format in `version`; a V2 FigureSource carries a number there. */
+const isV3 = (source: any) => source?.version === 'figure-v3-asset-1'
+
+/**
+ * The V2 proposer writes V2 figures; a V3 figure open in the modeller is not something it can revise or add to. Said as
+ * what is true, with what the assistant can do instead -- not a V2 parser's complaint about a V3 asset (user,
+ * 2026-09-24: the dock answered 「type 이 없다 · base 가 없다」 for a V3 draft).
+ */
+function v3ProposalUnavailable() {
+  return {
+    error: 'V3_PROPOSAL_UNAVAILABLE',
+    message: '이 도형은 V3 형식입니다. AI 후보 제안은 아직 V2 도형만 만들 수 있어 이 도형을 고치는 후보를 낼 수 없습니다.',
+    nextStep:
+      'Tell the person plainly that candidate proposals do not support V3 figures yet. You can still read the figure (getFigureSource) and explain whether it may be released and why (inspectFigure). Do not produce a V2 candidate for a V3 figure.'
+  }
+}
+
 function sourceForTool(row: any, host: any): { source: any; draft: boolean } {
   const isMatch = host?.figureId === row.id || (!row.id && host?.editorMode === 'new') || (!row.id && !host?.figureId)
   const draft = isMatch ? host?.draftSource : undefined
@@ -169,6 +189,17 @@ function sourceForTool(row: any, host: any): { source: any; draft: boolean } {
     throw new Error('the unsaved draft is too large to safely review')
   }
 
+  /* A V3 draft is checked as V3 -- the same door a save goes through. It names no type; the row does. */
+  if (isV3(draft)) {
+    try {
+      getDeps().parseAnySource(serialized)
+    } catch (e: any) {
+      const findings = Array.isArray(e?.findings) ? e.findings.map((one: any) => one.message).join(' · ') : String(e?.message ?? e)
+      throw new Error(`the unsaved V3 draft is invalid: ${findings}`)
+    }
+    return { source: draft, draft: true }
+  }
+
   const { validate, isPlaceholderType } = getDeps()
   const checked = validate(draft)
   if (checked.errors.length > 0) {
@@ -306,6 +337,22 @@ function figureToolSpecs(): ToolSpec[] {
           return { id: row.id, type: row.type, name: row.name, source: null, cost: null }
         }
 
+        if (isV3(current.source)) {
+          /* A V3 asset is measured as V3 -- triangles, draw groups, and its grade against one screen. */
+          const { v3CostOf, v3ScoreOf } = getDeps()
+          return {
+            id: row.id,
+            type: row.type,
+            name: row.name,
+            state: row.state,
+            format: 'v3',
+            source: current.source,
+            draft: current.draft,
+            cost: v3CostOf(current.source),
+            score: v3ScoreOf(current.source) ?? null
+          }
+        }
+
         const { compile, costOf, scoreOf } = getDeps()
         const blueprint = compile(current.source)
 
@@ -339,7 +386,7 @@ function figureToolSpecs(): ToolSpec[] {
 
         const current = sourceForTool(row, ctx?.host)
         const { inspectSource } = getDeps()
-        return { ...inspectSource(current.source ? JSON.stringify(current.source) : null), draft: current.draft }
+        return { ...inspectSource(current.source ? JSON.stringify(current.source) : null, null, undefined, row.type), draft: current.draft }
       }
     },
     {
@@ -391,6 +438,7 @@ function figureToolSpecs(): ToolSpec[] {
             base = sourceForTool(row, ctx?.host).source ?? undefined
           }
         }
+        if (isV3(base) || (args?.create !== true && isV3(ctx?.host?.draftSource))) return v3ProposalUnavailable()
 
         const palette = Array.isArray(ctx?.host?.palette) ? ctx.host.palette : []
         if (palette.length === 0) {