@things-factory/figure-service 10.1.244 → 10.1.246

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

@@ -328,6 +328,7 @@ const SUBJECT: { [K in FigureProposalStep['kind']]: (step: StepOf<K>, base: Figu
   'set-section-corner': step => step.part,
   'set-cavity': step => step.part,
   'set-section': step => step.part,
+  'set-pipe': step => step.part,
   attach: step => step.part,
   'link-dimension': step => step.part,
   'follow-size': step => step.part,
@@ -350,6 +351,7 @@ const SUBJECT: { [K in FigureProposalStep['kind']]: (step: StepOf<K>, base: Figu
   'set-visibility': step => step.target,
   'remove-part': step => step.target,
   'duplicate-part': step => step.target,
+  'mirror-part': step => step.target,
   'move-part': step => step.target,
   'set-placement': () => undefined,
   'declare-instance-size': () => undefined,
@@ -374,6 +376,7 @@ const SUBJECT: { [K in FigureProposalStep['kind']]: (step: StepOf<K>, base: Figu
   'set-driver': () => undefined,
   'remove-driver': () => undefined,
   'set-clip': () => undefined,
+  'copy-clip': () => undefined,
   'set-motion-group': () => undefined,
   'remove-motion-group': () => undefined,
   'set-data-schema': () => undefined,

package/server/service/figure/figure-llm-provider.ts

@@ -0,0 +1,20 @@
+/**
+ * Which provider a live figure-AI run asks (the smoke test, the scenarios): the one `FIGURE_LLM_PROVIDER` names, or the
+ * first whose key is set. Its model is `FIGURE_LLM_MODEL`, or the adapter's default. Undefined: no key, nothing runs.
+ */
+export type FigureLLMProvider = 'anthropic' | 'gemini' | 'openai'
+
+export function figureLLMProvider(env: NodeJS.ProcessEnv = process.env): { provider: FigureLLMProvider; apiKey: string; model?: string } | undefined {
+  const requested = env.FIGURE_LLM_PROVIDER as FigureLLMProvider | undefined
+  const candidates: Array<{ provider: FigureLLMProvider; keys: string[] }> = [
+    { provider: 'anthropic', keys: ['ANTHROPIC_API_KEY'] },
+    { provider: 'gemini', keys: ['GEMINI_API_KEY', 'GOOGLE_API_KEY'] },
+    { provider: 'openai', keys: ['OPENAI_API_KEY'] }
+  ]
+  const usable = requested ? candidates.filter(candidate => candidate.provider === requested) : candidates
+  for (const candidate of usable) {
+    const apiKey = candidate.keys.map(key => env[key]).find(Boolean)
+    if (apiKey) return { provider: candidate.provider, apiKey, ...(env.FIGURE_LLM_MODEL ? { model: env.FIGURE_LLM_MODEL } : {}) }
+  }
+  return undefined
+}

package/server/service/figure/figure-llm-smoke.test.ts

@@ -11,78 +11,15 @@
  */
 import { createAIClient, type AIClient } from '@things-factory/ai-client-base'
 
-import { applyFigureProposal, compileFigureAsset, createFigureAsset, figureShapeBoundsOf, inspectFigureAsset, type FigureAsset } from '@hatiolab/figure-model'
+import { inspectFigureAsset } from '@hatiolab/figure-model'
 
+import { mixerDraft, portRevisionMisses } from './figure-ai-scenarios'
+import { figureLLMProvider } from './figure-llm-provider'
 import { judgeFigureAnswer, proposeFigureSteps } from './figure-propose-steps'
 
 // Provider modules register themselves on import. Keep this separate from the deterministic tests.
 import '@things-factory/ai-client-base'
 
-type Provider = 'anthropic' | 'gemini' | 'openai'
-
-function provider(): { provider: Provider; apiKey: string } | undefined {
-  const requested = process.env.FIGURE_LLM_PROVIDER as Provider | undefined
-  const candidates: Array<{ provider: Provider; keys: string[] }> = [
-    { provider: 'anthropic', keys: ['ANTHROPIC_API_KEY'] },
-    { provider: 'gemini', keys: ['GEMINI_API_KEY', 'GOOGLE_API_KEY'] },
-    { provider: 'openai', keys: ['OPENAI_API_KEY'] }
-  ]
-  const usable = requested ? candidates.filter(candidate => candidate.provider === requested) : candidates
-  for (const candidate of usable) {
-    const apiKey = candidate.keys.map(key => process.env[key]).find(Boolean)
-    if (apiKey) return { provider: candidate.provider, apiKey }
-  }
-  return undefined
-}
-
-/** A mixer: a body standing on the floor, a port fastened to its front. */
-function mixerDraft(): FigureAsset {
-  return applyFigureProposal(createFigureAsset('Mixer'), [
-    { kind: 'add-part', part: { id: 'body', kind: 'cylinder', dimensions: { radius: 140, length: 320 } } },
-    { kind: 'add-part', part: { id: 'port', kind: 'box', dimensions: { width: 80, height: 60, depth: 30 } } },
-    { kind: 'attach', part: 'body', to: { plane: 'mounting-plane' } },
-    /* The body's front is its curved side: a point on it, by the outward normal there (ADR-0140 3.9; push Y, +Z is 270°). */
-    { kind: 'attach', part: 'port', to: { part: 'body', surface: { around: 270, along: 'centre' } } },
-    { kind: 'set-placement', placement: 'floor' }
-  ] as any)
-}
-
-/**
- * Each part's reach along its own axes and the colour it is drawn in, at the figure's default size. The colour is the
- * palette's value for the part's token: two tokens of one colour draw the same.
- */
-function drawn(asset: FigureAsset): Record<string, { size: Record<'x' | 'y' | 'z', number>; colour: string }> {
-  const geometry = compileFigureAsset(asset).evaluate({}).geometry as any[]
-  return Object.fromEntries(
-    geometry.map(body => {
-      const bounds = figureShapeBoundsOf(body.shape)
-      const size = { x: bounds.x.max - bounds.x.min, y: bounds.y.max - bounds.y.min, z: bounds.z.max - bounds.z.min }
-      /* The kernel refuses a token the palette has no colour for, so every body has one. */
-      return [body.id, { size, colour: String(asset.palette![body.material.token]).toLowerCase() }]
-    })
-  )
-}
-
-/**
- * What "make the port twice as wide and give it an accent colour" asks of the mixer, said as what is missing: the port
- * twice as wide (X), its height and depth kept, a colour it did not have, and the body left as it was. Nothing missing:
- * an empty list. Checking only that the parts still exist let a revision that changed nothing pass.
- */
-function portRevisionMisses(before: FigureAsset, after: FigureAsset): string[] {
-  const was = drawn(before),
-    now = drawn(after)
-  const misses: string[] = []
-  const near = (a: number, b: number) => Math.abs(a - b) <= 0.5
-  if (!now.port) return ['the port is gone']
-  if (!near(now.port.size.x, was.port.size.x * 2)) misses.push(`port width ${now.port.size.x}, asked ${was.port.size.x * 2}`)
-  for (const axis of ['y', 'z'] as const) if (!near(now.port.size[axis], was.port.size[axis])) misses.push(`port ${axis} changed to ${now.port.size[axis]}`)
-  if (now.port.colour === was.port.colour) misses.push(`port colour still ${was.port.colour}`)
-  if (!now.body) misses.push('the body is gone')
-  else for (const axis of ['x', 'y', 'z'] as const) if (!near(now.body.size[axis], was.body.size[axis])) misses.push(`body ${axis} changed to ${now.body.size[axis]}`)
-  if (now.body && now.body.colour !== was.body.colour) misses.push(`body colour changed to ${now.body.colour}`)
-  return misses
-}
-
 /* The check above, held to answers whose verdict is known - so it is seen to fail a wrong revision without a provider. */
 describe('the revision check of the smoke test', () => {
   const draft = mixerDraft()
@@ -113,13 +50,13 @@ describe('the revision check of the smoke test', () => {
   })
 })
 
-const picked = process.env.RUN_FIGURE_LLM_SMOKE === '1' ? provider() : undefined
+const picked = process.env.RUN_FIGURE_LLM_SMOKE === '1' ? figureLLMProvider() : undefined
 const describeIf = picked ? describe : describe.skip
 
 describeIf('Figure 실제 LLM smoke', () => {
   let client: AIClient
   beforeAll(() => {
-    client = createAIClient({ ...picked!, ...(process.env.FIGURE_LLM_MODEL ? { model: process.env.FIGURE_LLM_MODEL } : {}) })
+    client = createAIClient(picked!)
     // eslint-disable-next-line no-console
     console.log(`[figure-llm-smoke] provider=${picked!.provider} model=${process.env.FIGURE_LLM_MODEL ?? '(adapter default)'}`)
   })

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

@@ -297,34 +297,28 @@ export class FigureMutation {
       **버전 번호는 여기서 손대지 않는다.** 저장은 저작이고, 버전은 발행에서 생긴다(`releaseFigure`).
       board 의 `updateBoard` 도 같다 — 저장 경로에는 version 이 없다.
     */
-    const saved = await repository.save({
-      /*
-        `domain` 을 명시로 넣는다 — 읽어 온 엔티티에는 관계가 안 실려 있다.
+    /*
+      **바뀐 칸만 쓴다** (2026-11-03 점검 2). 처음 읽은 행을 통째로 펼쳐 다시 쓰면, 그 사이 다른 편집이
+      `saveFigure` 로 저장한 정본이 읽어 둔 옛 정본으로 되돌아간다 — 설명 한 줄을 고쳤을 뿐인데. 정본을 쓰는
+      경우(정본 패치, 타입 바꾸기)는 `saveFigure` 와 같이 읽어 둔 정본이 그대로일 때만 쓴다.
 
-        버전 스냅샷은 넘겨받은 엔티티를 베끼므로, 여기서 빠지면 버전의 도메인이 비고 그 버전은
-        도메인으로 거르는 조회에 **한 줄도 안 걸린다**(실제로 그랬다). board 의 저장들도 같은
-        자리에서 domain 을 함께 넣는다.
-      */
-      domain,
-      ...figure,
-      ...patchRest,
-      /* 앞뒤 공백을 떼고 겹침까지 본 이름. `patch.type` 을 그대로 두면 다듬기 전 값이 들어간다. */
+      **고치면 발행이 풀린다.** 발행은 「이 버전을 써도 된다」는 약속이고, 그 뒤에 바뀌면 약속한 것과
+      배포된 것이 달라진다. 그래서 저장은 언제나 초안으로 되돌린다. 버전 번호는 여기서 손대지 않는다 —
+      버전은 발행에서 생긴다(`releaseFigure`).
+    */
+    const { type: _type, source: _source, ...fields } = patchRest
+    const changes = {
+      ...Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined)),
       ...(renamed !== undefined ? { type: renamed } : {}),
-      source,
-      /*
-        **고치면 발행이 풀린다.**
-
-        발행은 「이 버전을 써도 된다」는 약속이고, 그 뒤에 정본이 바뀌면 약속한 것과 배포된 것이
-        달라진다. 그래서 저장은 언제나 초안으로 되돌리고, 다시 내보내려면 발행을 한 번 더 한다
-        (버전 번호가 하나 오르고 버전이 하나 더 남는다). board 의 `updateBoard` 가 같은 한 줄을 쓴다.
-      */
-      state: 'draft',
+      ...(source !== figure.source ? { source } : {}),
+      state: 'draft' as const,
       ...(derived ?? {}),
-      // 썸네일이 **썸네일로서** 바뀐 때만 시각을 갱신한다. 이름·설명 변경에는 안 건드린다.
-      thumbnail: figure.thumbnail ?? null,
       ...picture,
       updater: user
-    })
+    }
+    if ('source' in changes) await compareAndSwapFigure(criteria => repository.update(criteria, changes), id, domain.id, figure.source)
+    else await repository.update({ id, domain: { id: domain.id } }, changes)
+    const saved = await repository.findOneOrFail({ where: { id, domain: { id: domain.id } } })
 
     return { figure: saved, violations }
   }

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

@@ -96,6 +96,23 @@ describe('the model is told the kernel\'s commands and the open draft', () => {
     expect(made.source.name).toBe('Lift table 2')
     expect(draft.name).toBe('Lift table')
   })
+
+  it('a revision shows the draft\'s pipes as set-pipe takes them, and none for a draft without', async () => {
+    const draft = applyFigureProposal(createFigureAsset('Elbow'), [
+      { kind: 'add-part', part: { id: 'pipe', kind: 'pipe', dimensions: { radius: 40, wall: 4 }, path: [{ line: 500 }, { bend: { radius: 120, angle: 90, toward: 90 } }, { line: 400 }] } },
+      { kind: 'add-part', part: { id: 'stand', kind: 'box', dimensions: { width: 100, height: 100, depth: 100 } } },
+      { kind: 'attach', part: 'pipe', to: { plane: 'mounting-plane' } },
+      { kind: 'attach', part: 'stand', to: { plane: 'mounting-plane' }, align: { x: { mm: 600 } } }
+    ] as any)
+    const told = async (base: typeof draft) => {
+      const client = stubClient([{ steps: [{ kind: 'rename', name: 'Again' }] }])
+      await proposeFigureSteps({ client, prompt: '이름', base })
+      return client.sent[0]![0]!.content as string
+    }
+    const line = (await told(draft)).split('\n').find(l => l.startsWith('{"pipe":'))
+    expect(JSON.parse(line!)).toEqual({ pipe: { kind: 'pipe', radius: 40, wall: 4, path: [{ line: 500 }, { bend: { radius: 120, angle: 90, turn: '+X' } }, { line: 400 }] } })
+    expect(await told(applyFigureProposal(createFigureAsset('Box'), liftTable as any))).not.toContain('Its pipes and ducts')
+  })
 })
 
 describe('the steps are held to the kernel and the gate', () => {
@@ -108,6 +125,29 @@ describe('the steps are held to the kernel and the gate', () => {
     expect(made.score?.grade).toMatch(/^[ABCD]$/)
   })
 
+  /* ADR-0100 §16 (2026-11-03, 「파이프같은 경우가 많이 활용될 것 같으니까」): a pipe run and a tapered box made by a proposal. */
+  it('a pipe run with a flange on its end, and a tapered cover, are made by the grammar\'s words; a bend too tight is said back', async () => {
+    const run = [
+      { kind: 'add-part', part: { id: 'pipe', kind: 'pipe', dimensions: { radius: 40, wall: 4 }, path: [{ line: 500 }, { bend: { radius: 120, angle: 90, toward: 90 } }, { line: 400 }] } },
+      { kind: 'attach', part: 'pipe', to: { plane: 'mounting-plane' } },
+      { kind: 'add-part', part: { id: 'flange', kind: 'cylinder', dimensions: { radius: 70, length: 20 } } },
+      { kind: 'attach', part: 'flange', to: { part: 'pipe', face: 'right' } },
+      { kind: 'add-part', part: { id: 'cover', kind: 'tapered-box', dimensions: { width: 300, depth: 200, height: 150, topWidth: 180, topDepth: 120, round: 20, topRound: 10 } } },
+      { kind: 'attach', part: 'cover', to: { plane: 'mounting-plane' } }
+    ]
+    const tight = run.map((s, i) => (i === 0 ? { ...s, part: { ...(s as any).part, path: [{ line: 500 }, { bend: { radius: 30, angle: 90, toward: 90 } }] } } : s))
+    const client = stubClient([{ steps: tight }, { steps: run }])
+    const made = await proposeFigureSteps({ client, prompt: '엘보 배관과 플랜지, 덮개', name: 'Pipe run' })
+    expect(made.attempts).toBe(2)
+    expect(JSON.stringify(client.sent[1])).toContain('GEOMETRY_DOMAIN')
+    expect(made.steps).toEqual(run)
+    expect(inspectFigureAsset(made.source).violations).toEqual([])
+    /* The words the model was told include the pipe's and the tapered box's. */
+    expect(client.system).toContain("kind: 'pipe'")
+    expect(client.system).toContain("kind: 'set-pipe'")
+    expect(client.system).toContain("kind: 'tapered-box'")
+  })
+
   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 }])
     const made = await proposeFigureSteps({ client, prompt: '리프트 테이블', name: 'Lift table' })
@@ -178,6 +218,21 @@ describe('the steps are held to the kernel and the gate', () => {
   "Make this one bigger": the part the person selected reaches the step writer, or it guesses which part was meant
   (ADR-0097 §5.6 item 5). Only a revision has a selection; a new figure has nothing to select.
 */
+describe('a pipe in a revision is told as set-pipe takes it', () => {
+  it('its bends by the axis they turn to, so "down" is written as -Y', async () => {
+    const base = applyFigureProposal(createFigureAsset('Elbow'), [
+      { kind: 'add-part', part: { id: 'pipe', kind: 'pipe', dimensions: { radius: 40, wall: 4 }, path: [{ line: 500 }, { bend: { radius: 120, angle: 90, toward: 90 } }, { line: 400 }] } },
+      { kind: 'attach', part: 'pipe', to: { plane: 'mounting-plane' } }
+    ] as any)
+    const client = stubClient([{ steps: [{ kind: 'set-pipe', part: 'pipe', append: [{ bend: { radius: 120, angle: 90, turn: '-Y' } }, { line: 300 }] }] }])
+    const made = await proposeFigureSteps({ client, prompt: '끝에서 아래로 꺾어 300 더', base })
+    const task = String(client.sent[0][0].content)
+    expect(task).toContain('"turn":"+X"')
+    expect(task).toContain('set-pipe takes them')
+    expect(made.attempts).toBe(1)
+  })
+})
+
 describe('what the person has in view goes with a revision', () => {
   it('the selected part and the values being tried are named in the task', async () => {
     const draft = applyFigureProposal(createFigureAsset('Lift table'), liftTable as any)

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

@@ -1,4 +1,4 @@
-import { FIGURE_PROPOSAL_GRAMMAR, applyFigureProposal, createFigureAsset, inspectFigureAsset, serializeFigureAsset, figureCostOf, figureScoreOf } from '@hatiolab/figure-model'
+import { FIGURE_PROPOSAL_GRAMMAR, applyFigureProposal, createFigureAsset, figurePipesOf, inspectFigureAsset, serializeFigureAsset, figureCostOf, figureScoreOf } from '@hatiolab/figure-model'
 import type { FigureAsset, FigureProposalStep, FigureRefusalDetails } from '@hatiolab/figure-model'
 import { AIAnswerNotJSON, type AIClient } from '@things-factory/ai-client-base'
 import type { AIImageMediaType, AIMessage } from '@things-factory/ai-client-base'
@@ -61,7 +61,9 @@ export class ProposeFigureFailure extends Error {
     message: string,
     /** The last attempt's reasons, as the kernel and the gate said them. */
     readonly reasons: string[],
-    readonly attempts: number
+    readonly attempts: number,
+    /** The last answer refused, as the model wrote it: what to look at again without asking it. */
+    readonly lastAnswer?: unknown
   ) {
     super(message)
     this.name = 'ProposeFigureFailure'
@@ -151,6 +153,13 @@ export function taskPromptFigure(input: ProposeFigureInput, view: FigureView | u
         'Any other part may be named to fasten to or to follow; a step that changes it is refused. A section in outline.omitted is not known here: leave what is in it as it is.'
       )
     }
+    /*
+      Its pipes as set-pipe takes them: the source holds a bend as degrees across the section where it starts, which a
+      writer cannot turn into "down" (AI modelling scenarios 2026-11-03); said by the axis it turns to, it is written back right.
+    */
+    const pipes = figurePipesOf(input.base)
+    if (Object.keys(pipes).length)
+      lines.push('', 'Its pipes and ducts as set-pipe takes them, each bend by the axis it turns to there (to extend one, append; to change its section, give only the measures):', JSON.stringify(pipes))
     lines.push('', `Palette tokens it has: ${Object.keys(input.base.palette ?? {}).join(', ') || 'none'}.`)
     const { selection, trying } = input.focus ?? {}
     if (selection) lines.push('', `The person has selected the part "${selection.part}": "this part", "the selected one" and the like mean it.`)
@@ -294,6 +303,7 @@ export async function proposeFigureSteps(input: ProposeFigureInput): Promise<Pro
   ]
 
   let reasons: string[] = []
+  let refused: unknown
   for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
     let answer: unknown
     try {
@@ -320,6 +330,7 @@ export async function proposeFigureSteps(input: ProposeFigureInput): Promise<Pro
     }
 
     reasons = judged.reasons
+    refused = answer
     // The reasons go back as they were said; a summary would not tell the model which step to change.
     messages.push({ role: 'assistant', content: JSON.stringify(answer) })
     messages.push({
@@ -328,5 +339,5 @@ export async function proposeFigureSteps(input: ProposeFigureInput): Promise<Pro
     })
   }
 
-  throw new ProposeFigureFailure('The figure could not be made.', reasons, MAX_ATTEMPTS)
+  throw new ProposeFigureFailure('The figure could not be made.', reasons, MAX_ATTEMPTS, refused)
 }

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

@@ -178,3 +178,111 @@ describe('what another domain reads of a public figure', () => {
     expect(await dataSource!.getRepository(Figure).findOne({ where: { id: figure.id } })).not.toBeNull()
   })
 })
+
+describe('a public figure edited after its release (2026-11-03 audit 1)', () => {
+  it("another domain's list shows its latest release -- not the draft's source, name or description, nor a search by them", async () => {
+    const owner = await domain()
+    const reader = await domain()
+    const figure = await released(owner, 'public-edited')
+    await new FigureMutation().setFigurePublic(figure.id, true, owner.context)
+    const row = await dataSource!.getRepository(Figure).findOneOrFail({ where: { id: figure.id } })
+    await new FigureMutation().saveFigure(releasable('UNRELEASED DRAFT'), owner.context, figure.id, row.source)
+    await new FigureMutation().updateFigure(figure.id, { description: 'draft words' }, owner.context)
+    const list = (filters: unknown[]) => new FigureQuery().publicFigures({ filters }, reader.context)
+
+    const { items, total } = await list([{ name: 'type', operator: 'eq', value: 'public-edited' }])
+    expect(total).toBe(1)
+    expect([items[0].id, items[0].version, items[0].state, items[0].public]).toEqual([figure.id, 1, 'released', true])
+    expect(items[0].source).not.toContain('UNRELEASED DRAFT')
+    expect([items[0].name, items[0].description]).toEqual(['public-edited', null])
+    expect((await list([{ name: 'name', operator: 'like', value: '%UNRELEASED%' }])).total).toBe(0)
+    expect((await list([{ name: 'description', operator: 'like', value: '%draft words%' }])).total).toBe(0)
+
+    await new FigureMutation().releaseFigure(figure.id, 'second', owner.context)
+    const after = (await list([{ name: 'type', operator: 'eq', value: 'public-edited' }])).items
+    expect([after.length, after[0].version, after[0].name]).toEqual([1, 2, 'UNRELEASED DRAFT'])
+  })
+})
+
+describe('a catalogue write while another save lands (2026-11-03 audit 2)', () => {
+  /** Holds the catalogue write between its read and its write, while `meanwhile` runs. */
+  async function holdingTheWrite(description: string, meanwhile: () => Promise<unknown>, write: () => Promise<unknown>) {
+    const repository = dataSource!.getRepository(Figure)
+    const update = repository.update.bind(repository)
+    let resume = () => {}
+    let reached = () => {}
+    const held = new Promise<void>(r => (resume = r))
+    const waiting = new Promise<void>(r => (reached = r))
+    const spy = jest.spyOn(repository, 'update').mockImplementation(async (criteria: any, values: any) => {
+      if (values?.description === description || (typeof values?.source === 'string' && values.source.includes(description))) {
+        reached()
+        await held
+      }
+      return update(criteria, values)
+    })
+    try {
+      const pending = write()
+      await waiting
+      await meanwhile()
+      resume()
+      return await pending.then(
+        () => undefined,
+        error => error
+      )
+    } finally {
+      resume()
+      spy.mockRestore()
+    }
+  }
+
+  it('a description change keeps the source another save wrote meanwhile', async () => {
+    const owner = await domain()
+    const figure = await released(owner, 'race-description')
+    const row = await dataSource!.getRepository(Figure).findOneOrFail({ where: { id: figure.id } })
+    const failed = await holdingTheWrite(
+      'catalogue edit',
+      () => new FigureMutation().saveFigure(releasable('NEWER SAVED DESIGN'), owner.context, figure.id, row.source),
+      () => new FigureMutation().updateFigure(figure.id, { description: 'catalogue edit' }, owner.context)
+    )
+    expect(failed).toBeUndefined()
+    const after = await dataSource!.getRepository(Figure).findOneOrFail({ where: { id: figure.id } })
+    expect(after.source).toContain('NEWER SAVED DESIGN')
+    expect(after.description).toBe('catalogue edit')
+  })
+
+  it('a patch of the source is refused as a conflict rather than writing over the source saved meanwhile', async () => {
+    const owner = await domain()
+    const figure = await released(owner, 'race-source')
+    const row = await dataSource!.getRepository(Figure).findOneOrFail({ where: { id: figure.id } })
+    const failed: any = await holdingTheWrite(
+      'PATCHED DESIGN',
+      () => new FigureMutation().saveFigure(releasable('NEWER SAVED DESIGN'), owner.context, figure.id, row.source),
+      () => new FigureMutation().updateFigure(figure.id, { source: releasable('PATCHED DESIGN') }, owner.context)
+    )
+    expect(failed?.extensions?.code).toBe('FIGURE_SOURCE_CONFLICT')
+    const after = await dataSource!.getRepository(Figure).findOneOrFail({ where: { id: figure.id } })
+    expect(after.source).toContain('NEWER SAVED DESIGN')
+  })
+})
+
+describe('the release pre-checks see the category the release does (2026-11-03 audit 3)', () => {
+  it('both pass the saved category to an application check', async () => {
+    const owner = await domain()
+    const figure = await released(owner, 'checked-category')
+    await new FigureMutation().updateFigure(figure.id, { category: 'EQUIPMENT' }, owner.context)
+    const { registerFigureReleaseCheck } = loadCompiled('service/figure/figure-format')
+    const seen: unknown[] = []
+    const remove = registerFigureReleaseCheck((input: any) => {
+      seen.push(input.category)
+      return []
+    })
+    try {
+      const row = await dataSource!.getRepository(Figure).findOneOrFail({ where: { id: figure.id } })
+      await new FigureQuery().inspectFigure(figure.id, owner.context)
+      await new FigureQuery().inspectFigureDraft(row.source, owner.context, figure.id)
+      expect(seen).toEqual(['EQUIPMENT', 'EQUIPMENT'])
+    } finally {
+      remove()
+    }
+  })
+})

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

@@ -3,10 +3,12 @@ import { Args, Arg, Ctx, Directive, Int, Query, Resolver, UseMiddleware } from '
 import { GraphQLJSON } from 'graphql-scalars'
 
 import {
+  countListByField,
   Domain,
   getQueryBuilderFromListParams,
   getRepository,
   ListParam,
+  ListValueCount,
   Refusal,
   SpeakRefusals,
   refusalKey
@@ -24,6 +26,11 @@ import { meshSummaryOf } from './figure-mesh-store.js'
 import { readableFigure, publicFigureOfName } from './figure-public.js'
 import { figureCategories } from './figure-categories.js'
 
+/** What a figure list finds figures by - tags too, see `figures` - and its state counts alike. */
+const FIGURE_SEARCHABLES = ['type', 'name', 'description', 'category', 'tags']
+/** A release records no tags (`FigureHistory`). */
+const PUBLIC_FIGURE_SEARCHABLES = ['type', 'name', 'description', 'category']
+
 @Resolver(Figure)
 @UseMiddleware(SpeakRefusals)
 export class FigureQuery {
@@ -55,7 +62,7 @@ export class FigureQuery {
         본다. 「반출」로 찾으면 걸린다. 정확히 그 태그만 걸리는 것은 아니지만(이름에 「반출」이
         든 피규어도 걸린다) 찾기로는 그것이 오히려 낫다.
       */
-      searchables: ['type', 'name', 'description', 'category', 'tags']
+      searchables: FIGURE_SEARCHABLES
     })
 
     const [items, total] = await queryBuilder.getManyAndCount()
@@ -63,25 +70,62 @@ export class FigureQuery {
     return { items, total }
   }
 
+  @Directive('@privilege(category: "figure", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => [ListValueCount], { description: "How many of the domain's figures hold each state (draft, released), under the list conditions other than the state." })
+  async figureStateCounts(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ListValueCount[]> {
+    const counted = await countListByField({
+      repository: getRepository(Figure),
+      params,
+      domain: context.state.domain,
+      alias: 'figure',
+      searchables: FIGURE_SEARCHABLES,
+      field: 'state'
+    })
+    return ['draft', 'released'].map(value => ({ value, count: counted.get(value) ?? 0 }))
+  }
+
   /**
    * Other domains' public figures (LV figure-server design G2): what this domain may read, package and draw besides its
-   * own and its parent's. The rows carry their domain, so a screen says whose each is. Their drafts are not opened.
+   * own and its parent's. The rows carry their domain, so a screen says whose each is.
+   *
+   * **Each is its latest release, never its row** (2026-11-03 audit 1). A public figure edited after its release has a
+   * draft on its row -- its source, name, description, category and picture -- and listing the row gave that draft to
+   * every domain that asked for `source`. So the list is read from the releases, and searched by them too: a search
+   * on the row's name would tell another domain what the draft is called. Of the row only what its domain says of the
+   * figure as a whole is shown: that it is public and whether it is retired. Tags are not recorded with a release, so a
+   * public figure shows none.
    */
   @Directive('@privilege(category: "figure", privilege: "query", domainOwnerGranted: true)')
-  @Query(returns => FigureList, { description: "Other domains' public figures. Read only: their releases, never their drafts." })
+  @Query(returns => FigureList, { description: "Other domains' public figures, each as its latest release. Read only: their releases, never their drafts." })
   async publicFigures(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<FigureList> {
     const { domain } = context.state
     const mine = [domain.id, domain.parentId].filter(Boolean)
     const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(Figure),
+      repository: getRepository(FigureHistory),
       params,
       alias: 'figure',
-      searchables: ['type', 'name', 'description', 'category', 'tags']
+      searchables: PUBLIC_FIGURE_SEARCHABLES
     })
+      .innerJoinAndMapOne('figure.row', Figure, 'row', 'row.id = figure.originalId AND row.public = :public AND row.deletedAt IS NULL', { public: true })
       .leftJoinAndSelect('figure.domain', 'owner')
-      .andWhere('figure.public = :public', { public: true })
+      .leftJoinAndSelect('figure.updater', 'releaser')
       .andWhere('owner.id NOT IN (:...mine)', { mine })
-    const [items, total] = await queryBuilder.getManyAndCount()
+      .andWhere(query => {
+        const latest = query.subQuery().select('MAX(latest.version)').from(FigureHistory, 'latest').where('latest.originalId = figure.originalId').getQuery()
+        return `figure.version = ${latest}`
+      })
+    const [releases, total] = await queryBuilder.getManyAndCount()
+    const items = releases.map(({ row, ...release }: FigureHistory & { row: Figure }) => ({
+      ...release,
+      id: release.originalId,
+      state: 'released' as const,
+      public: true,
+      deprecated: row.deprecated,
+      supersededBy: row.supersededBy,
+      tags: [],
+      /* The card asks for its picture by this stamp; the picture served to another domain is the release's. */
+      thumbnailUpdatedAt: release.thumbnailHash ? release.updatedAt : null
+    })) as unknown as Figure[]
     return { items, total }
   }
 
@@ -175,9 +219,10 @@ export class FigureQuery {
       /*
         `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).
+        loads the whole row — refused on the press (2026-09-24). `category` likewise: an app's check by category saw
+        `undefined` here and the whole row's on the release (2026-11-03 audit 3).
       */
-      select: { id: true, source: true, type: true }
+      select: { id: true, source: true, type: true, category: true }
     })
 
     if (!figure) {
@@ -218,7 +263,7 @@ export class FigureQuery {
 
     const figure = await getRepository(Figure).findOne({
       where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id },
-      select: { id: true, type: true }
+      select: { id: true, type: true, category: true }
     })
     if (!figure) throw new Error(`Figure ${id} 를 찾을 수 없다`)
 

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

@@ -182,6 +182,22 @@ describe('served behind the permission, from the figure\'s own domain', () => {
     expect([again.status, again.body]).toEqual([304, undefined])
   })
 
+  it("another domain's public figure is served its latest release's picture, not the draft's on its row", async () => {
+    const files = mapFiles()
+    const owner = await newDomain(),
+      reader = await newDomain()
+    const releasedHash = await keepThumbnail(dataSource!.manager, owner, undefined, picture(21), files)
+    const draftHash = await keepThumbnail(dataSource!.manager, owner, undefined, picture(22), files)
+    const figure = await dataSource!.getRepository(Figure).save({ type: 'PUBLIC-PIC', name: 'x', source: SOURCE, state: 'draft', version: 1, public: true, thumbnailHash: draftHash, thumbnailUpdatedAt: new Date(), domain: owner })
+    await dataSource!.getRepository(FigureHistory).insert({ originalId: figure.id, version: 1, type: 'PUBLIC-PIC', state: 'released', source: SOURCE, thumbnailHash: releasedHash, updatedAt: new Date(), domain: owner, action: 'updated' })
+    const theirs = koa()
+    await sendFigureThumbnail(theirs, async () => {}, figure.id, reader, files)
+    expect(Buffer.compare(theirs.body, bytesOf(picture(21)))).toBe(0)
+    const own = koa()
+    await sendFigureThumbnail(own, async () => {}, figure.id, owner, files)
+    expect(Buffer.compare(own.body, bytesOf(picture(22)))).toBe(0)
+  })
+
   it('a figure with no picture, or of a domain the caller cannot read, is 404', async () => {
     const files = mapFiles()
     const mine = await newDomain(),