@things-factory/figure-service 10.1.66 → 10.1.68

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

@@ -1,392 +0,0 @@
-import { blocksRelease, compile, contractChanges, sizingReport, validate } from '@hatiolab/figure-model'
-import type { Axis, FigureSource } from '@hatiolab/figure-model'
-
-/** Service transport shape. It deliberately contains only an explicit, reversible FigureSource edit. */
-export interface GateFix {
-  findingWay: string
-  part: string
-  axis: Axis
-  from?: string
-  to: 'min' | 'center' | 'max' | 'span'
-  resolved: number
-  /** True only when rechecking every sizing case leaves no release-blocking split. */
-  safe: boolean
-}
-
-/**
- * A coordinated repair, measured from the current source all the way through the sizing suite.
- * A split often involves several independently anchored parts, so no single anchor edit can be
- * called a solution. This remains a draft-only edit; it is never saved or released by the gate.
- */
-export interface GateFixPlan {
-  fixes: GateFix[]
-  resolved: number
-  /** True only after the complete plan leaves no release-blocking sizing split. */
-  safe: boolean
-}
-
-/**
- * 발행해도 되나 — **서버가 판정한다.**
- *
- * ## 왜 서버인가
- *
- * 이 검사는 브라우저 하네스에만 있었다(`test/browser/check-figure-scaling.mjs`). 사람이 돌릴 때만
- * 돌았고, 발행 경로에는 아무 검사도 없었다 — 형식만 맞으면 무엇이든 발행되었다. 발행은 소비처에게
- * 하는 약속이므로, 그 약속을 지킬 수 있는지는 약속하는 자리가 재야 한다.
- *
- * ## 무엇을 막고 무엇을 알리나
- *
- * 판정은 `figure-model` 의 `gate.ts` 가 이미 문서로 정해 두었다. 여기서 새로 정하지 않는다.
- *
- *   sizing-splits              크기를 바꾸면 조각이 갈라진다      **막는다**
- *   part-outside-base          부품이 기준 상자를 넘는다          **막는다**
- *   parts-off-placement-face   기준면에 안 닿는다                 **막는다**
- *   sizing-loose               1배에서 이미 여러 조각이다         알린다
- *   그 밖의 violations          형식이 권하지 않는 것              알린다 (저장 때 이미 보여 준 것들)
- *
- * 갈라짐을 막는 이유는 사람 눈에 「부서졌다」로 보이기 때문이다 — 시그널타워를 3배로 세우니 램프가
- * 기둥 위 공중에 떴던 그것이고, 앵커 규칙이 생긴 이유다. 소비처가 형상을 늘려 쓰는 것은 막을 수
- * 없으니(그것이 이 형식의 값이다), 늘려도 견디는지를 발행 전에 본다.
- *
- * ## 몇 개가 걸리나는 여기 안 적는다
- *
- * 한동안 「표본 15개 중 갈라짐 1 · 조용함 14」를 적어 두고 **게이트가 벽이 아니라는 근거**로
- * 삼았다. 수는 굳고 카탈로그는 움직인다 — 기준 상자 판정이 붙자 그 비율이 하루 만에 뒤집혔다.
- * 굳은 수를 근거로 든 문장은 그때부터 사실이 아닌 채로 사람을 안심시킨다.
- *
- * 무엇이 걸리고 얼마나 넘쳤나는 **저작 도구가 재서 보여 준다.** 그것을 볼 사람은 고치는
- * 사람이고, 그 사람이 보는 자리는 여기가 아니다.
- */
-
-/** 게이트가 낸 한 가지. `blocking` 이 참이면 발행이 안 된다. */
-export interface GateFinding {
-  code: string
-  message: string
-  /**
-   * **왜 그것이 문제인가.** 잰 것만 보여 주면 읽는 사람이 「그래서?」에서 멈춘다 — 화면에
-   * 「1 조각이 2 조각으로 갈라진다」만 떴을 때 실제로 그랬다.
-   */
-  why?: string
-  /** **무엇을 바꾸면 되나.** 부품 이름과 값으로. 형식이 만든 문장을 그대로 옮긴다. */
-  how?: string
-  /** 어디를 가리키나 — 갈라짐은 갈라진 부품 이름들, 형식 위반은 정본 안의 경로. */
-  at?: string
-  /**
-   * 실제로 재 본, 되돌릴 수 있는 한 앵커 수정안들. 문장을 파싱해서 고치는 것이 아니라
-   * FigureSource 에 적용할 정확한 값만 내보낸다. 화면은 이것을 후보로만 보여 주고 저작자가
-   * 수락하기 전에는 정본을 바꾸지 않는다.
-   */
-  fixes?: GateFix[]
-  /** The one-click, fully remeasured repair when individual candidates are insufficient. */
-  fixPlan?: GateFixPlan
-  blocking: boolean
-}
-
-export interface Inspection {
-  findings: GateFinding[]
-  /** 막는 것이 하나라도 있나. 화면이 이것으로 단추를 잠근다. */
-  blocked: boolean
-}
-
-/**
- * Figure model publishes the same capability for direct model consumers. Keep the service calculation
- * here as well because this package is deployed independently and receives a compiled local model package.
- * Each alternative is remeasured; prose from `how` is never parsed into an edit.
- */
-function measuredFixes(source: FigureSource, factor: number): GateFix[] {
-  const baseline = sizingReport(compile(source), factor)
-  const baselineCount = baseline.findings.filter(finding => finding.code === 'sizing-splits').length
-  const seen = new Set<string>()
-  const fixes: GateFix[] = []
-
-  for (const finding of baseline.findings) {
-    if (finding.code !== 'sizing-splits' || !finding.way) continue
-    const axes = finding.way.split('-').filter((axis): axis is Axis => ['x', 'y', 'z'].includes(axis))
-    const names = new Set(finding.clumps.flat())
-
-    for (const part of source.parts) {
-      if (!names.has(part.name)) continue
-      for (const axis of axes) {
-        for (const to of ['min', 'center', 'max', 'span'] as const) {
-          if (part.anchor?.[axis] === to) continue
-          const changed: FigureSource = {
-            ...source,
-            parts: source.parts.map(one => one.name === part.name ? { ...one, anchor: { ...(one.anchor ?? {}), [axis]: to } } : one)
-          }
-          const afterCount = sizingReport(compile(changed), factor).findings.filter(one => one.code === 'sizing-splits').length
-          const resolved = baselineCount - afterCount
-          const key = `${finding.way}:${part.name}:${axis}:${to}`
-          if (resolved <= 0 || seen.has(key)) continue
-          seen.add(key)
-          fixes.push({
-            findingWay: finding.way,
-            part: part.name,
-            axis,
-            from: part.anchor?.[axis],
-            to,
-            resolved,
-            /* 한 finding만 없앤 것이 아니라 전수 검사에서 막는 split이 0일 때만 원클릭 후보가 된다. */
-            safe: afterCount === 0
-          })
-        }
-      }
-    }
-  }
-
-  return fixes.sort((a, b) => b.resolved - a.resolved || a.part.localeCompare(b.part)).slice(0, 12)
-}
-
-function sourceWithFix(source: FigureSource, fix: Pick<GateFix, 'part' | 'axis' | 'to'>): FigureSource {
-  return {
-    ...source,
-    parts: source.parts.map(part => part.name === fix.part
-      ? { ...part, anchor: { ...(part.anchor ?? {}), [fix.axis]: fix.to } }
-      : part)
-  }
-}
-
-function splitCount(source: FigureSource, factor: number) {
-  return sizingReport(compile(source), factor).findings.filter(finding => finding.code === 'sizing-splits').length
-}
-
-/**
- * Find a small coordinated repair by repeatedly choosing the measured anchor edit that removes
- * the most remaining splits. Every step is evaluated against the real compiler; prose is never
- * interpreted. If the complete suite is not clear, no "recommended" button is exposed.
- */
-function measuredFixPlan(source: FigureSource, factor: number): GateFixPlan | undefined {
-  const originalCount = splitCount(source, factor)
-  if (originalCount === 0) return undefined
-
-  let working = source
-  let remaining = originalCount
-  const used = new Set<string>()
-  const fixes: GateFix[] = []
-
-  for (let step = 0; step < source.parts.length * 3 && remaining > 0; step++) {
-    const report = sizingReport(compile(working), factor)
-    let best: GateFix | undefined
-
-    for (const finding of report.findings) {
-      if (finding.code !== 'sizing-splits' || !finding.way) continue
-      const axes = finding.way.split('-').filter((axis): axis is Axis => ['x', 'y', 'z'].includes(axis))
-      const names = new Set(finding.clumps.flat())
-
-      for (const part of working.parts) {
-        if (!names.has(part.name)) continue
-        for (const axis of axes) {
-          const key = `${part.name}:${axis}`
-          if (used.has(key)) continue
-          for (const to of ['min', 'center', 'max', 'span'] as const) {
-            if (part.anchor?.[axis] === to) continue
-            const afterCount = splitCount(sourceWithFix(working, { part: part.name, axis, to }), factor)
-            const resolved = remaining - afterCount
-            if (resolved <= 0) continue
-            const candidate: GateFix = {
-              findingWay: finding.way,
-              part: part.name,
-              axis,
-              from: source.parts.find(one => one.name === part.name)?.anchor?.[axis],
-              to,
-              resolved,
-              safe: false
-            }
-            if (!best || candidate.resolved > best.resolved ||
-              (candidate.resolved === best.resolved && `${candidate.part}:${candidate.axis}:${candidate.to}` < `${best.part}:${best.axis}:${best.to}`)) {
-              best = candidate
-            }
-          }
-        }
-      }
-    }
-
-    if (!best) break
-    fixes.push(best)
-    used.add(`${best.part}:${best.axis}`)
-    working = sourceWithFix(working, best)
-    remaining = splitCount(working, factor)
-  }
-
-  if (remaining === 0 && fixes.length > 0) {
-    return { fixes: fixes.map(fix => ({ ...fix, safe: true })), resolved: originalCount, safe: true }
-  }
-
-  /*
-   * Some assemblies need two anchors to move together. Neither first move removes a whole split,
-   * so greedy improvement alone cannot see the repair. Search a small, deterministic beam of those
-   * coordinated moves, and still return only a plan that the compiler proves clear.
-   */
-  const firstReport = sizingReport(compile(source), factor)
-  const candidates = new Map<string, { part: string; axis: Axis }>()
-  for (const finding of firstReport.findings) {
-    if (finding.code !== 'sizing-splits' || !finding.way) continue
-    const axes = finding.way.split('-').filter((axis): axis is Axis => ['x', 'y', 'z'].includes(axis))
-    const names = new Set(finding.clumps.flat())
-    for (const part of source.parts) {
-      if (!names.has(part.name)) continue
-      for (const axis of axes) candidates.set(`${part.name}:${axis}`, { part: part.name, axis })
-    }
-  }
-
-  type SearchState = { source: FigureSource; fixes: GateFix[]; used: Set<string>; remaining: number }
-  let frontier: SearchState[] = [{ source, fixes: [], used: new Set(), remaining: originalCount }]
-  const visited = new Set<string>()
-  for (let depth = 0; depth < 8 && frontier.length; depth++) {
-    const next: SearchState[] = []
-    for (const state of frontier) {
-      for (const [key, target] of candidates) {
-        if (state.used.has(key)) continue
-        const current = state.source.parts.find(part => part.name === target.part)
-        if (!current) continue
-        for (const to of ['min', 'center', 'max', 'span'] as const) {
-          if (current.anchor?.[target.axis] === to) continue
-          const changed = sourceWithFix(state.source, { ...target, to })
-          const signature = JSON.stringify(changed.parts.map(part => [part.name, part.anchor]))
-          if (visited.has(signature)) continue
-          visited.add(signature)
-          const after = splitCount(changed, factor)
-          const fix: GateFix = {
-            findingWay: 'coordinated', part: target.part, axis: target.axis,
-            from: source.parts.find(part => part.name === target.part)?.anchor?.[target.axis], to,
-            resolved: state.remaining - after, safe: false
-          }
-          const fixes = [...state.fixes, fix]
-          if (after === 0) return { fixes: fixes.map(one => ({ ...one, safe: true })), resolved: originalCount, safe: true }
-          next.push({ source: changed, fixes, used: new Set([...state.used, key]), remaining: after })
-        }
-      }
-    }
-    /* Keep enough alternatives to discover a paired repair without making release inspection expensive. */
-    frontier = next.sort((a, b) => a.remaining - b.remaining || a.fixes.length - b.fixes.length ||
-      JSON.stringify(a.fixes).localeCompare(JSON.stringify(b.fixes))).slice(0, 24)
-  }
-
-  return undefined
-}
-
-/**
- * 정본 하나를 판정한다.
- *
- * 정본이 없거나(아직 저장 전) JSON 이 아니면 **막는다** — 발행할 대상이 없는 것이다. 그 경우를
- * 조용히 통과시키면 빈 것이 발행된다.
- *
- * `releasedJson` 은 **직전 발행판의 정본**이다. 주면 그것과 견주어 「이미 놓인 인스턴스를 깨는
- * 발행인가」를 함께 낸다(ADR-0063 결정 3). 한 번도 발행된 적 없으면 견줄 것이 없으므로 안 준다.
- */
-export function inspectSource(sourceJson?: string | null, releasedJson?: string | null): Inspection {
-  if (!sourceJson) {
-    return {
-      blocked: true,
-      findings: [
-        {
-          code: 'no-source',
-          message: '저장된 정본이 없다. 저장하면 발행할 수 있다',
-          blocking: true
-        }
-      ]
-    }
-  }
-
-  let parsed: unknown
-  try {
-    parsed = JSON.parse(sourceJson)
-  } catch (e) {
-    return {
-      blocked: true,
-      findings: [{ code: 'source-not-json', message: `정본이 JSON 이 아니다: ${(e as Error).message}`, blocking: true }]
-    }
-  }
-
-  const result = validate(parsed)
-  const findings: GateFinding[] = []
-
-  /*
-    형식 오류는 **저장을 통과할 수 없다**(`parseSource` 가 거절한다). 그래도 여기서 다시 보는 이유는,
-    이 판정이 저장 경로와 독립이어야 하기 때문이다 — 옛 정본이 남아 있거나 형식이 엄해진 뒤라면
-    저장 때는 맞았던 것이 지금은 틀릴 수 있다. 그때 발행이 통과하면 안 된다.
-  */
-  for (const error of result.errors) {
-    findings.push({ code: error.code, message: error.message, at: error.path, blocking: true })
-  }
-
-  for (const violation of result.violations) {
-    findings.push({
-      code: violation.code,
-      message: violation.message,
-      /*
-        왜·어떻게는 형식이 만든 것을 그대로 옮긴다. 여기서 서버가 다시 쓰면 두 벌이 되고 곧 어긋난다 —
-        크기 반응 판정이 이미 그 규율이다(아래 `report.findings`).
-
-        이 두 줄이 없던 동안 발행 화면은 막는 위반에 문장 하나만 보여 줬다. 표본 47 개를 게이트에 넣어
-        보니 막는 판정 99 건 중 왜·어떻게를 가진 것이 2 건이었고, 나머지 97 건은 저작자가 상자를 키울지
-        부품을 옮길지 알 길이 없었다(2026-09-19, figure-model 0.1.29 가 그 값을 싣기 시작했다).
-      */
-      why: violation.why,
-      how: violation.how,
-      /* 어느 위반이 막나는 형식이 안다 — 여기 목록을 또 들면 둘이 갈린다(ADR-0044 결정 ②). */
-      blocking: blocksRelease(violation.code)
-    })
-  }
-
-  if (result.errors.length === 0) {
-    const source = parsed as FigureSource
-    const report = sizingReport(compile(source))
-    const fixes = measuredFixes(source, report.factor)
-    const fixPlan = measuredFixPlan(source, report.factor)
-
-    for (const finding of report.findings) {
-      findings.push({
-        code: finding.code,
-        message: finding.message,
-        /* 왜·어떻게는 형식이 소유한다. 서버가 다시 쓰면 두 벌이 되고 곧 어긋난다. */
-        why: finding.why,
-        how: finding.how,
-        /* 숫자가 아니라 자리를 말한다 — 어느 부품들이 갈라져 나왔나. */
-        at: finding.clumps.map(clump => [...clump].sort().join('+')).join(' | ') || undefined,
-          fixes: finding.code === 'sizing-splits' ? fixes.filter(fix => fix.findingWay === finding.way) : undefined,
-          /* A plan is attached once: it clears the full suite, not merely this card's symptom. */
-          fixPlan: finding.code === 'sizing-splits' && finding === report.findings.find(one => one.code === 'sizing-splits') ? fixPlan : undefined,
-        blocking: finding.code === 'sizing-splits'
-      })
-    }
-
-    findings.push(...contractFindings(source, releasedJson))
-  }
-
-  return { findings, blocked: findings.some(finding => finding.blocking) }
-}
-
-/**
- * 직전 발행판과 견준 것 — **약속을 깨는 발행인가**(ADR-0063 결정 3).
- *
- * 무엇이 달라졌고 그것이 막는 것인지는 형식이 정한다(`contractChanges`). 여기서는 화면과 발행 문이
- * 읽는 모양으로 옮기기만 한다.
- *
- * **앞 판을 오늘 형식으로 못 읽으면 조용히 넘어가지 않는다.** 판 1 은 오늘 형식이 거절하는 판으로
- * 적혀 있을 수 있고, 그때 견주기를 건너뛰면 아무 말 없이 관문이 없는 것이 된다. 막지는 않는다 —
- * 그러면 그 도형은 영영 다시 발행할 수 없다.
- */
-function contractFindings(source: FigureSource, releasedJson?: string | null): GateFinding[] {
-  if (!releasedJson) return []
-
-  let released: FigureSource
-  try {
-    released = JSON.parse(releasedJson) as FigureSource
-    return contractChanges(released, source).map(change => ({
-      code: change.code,
-      message: change.message,
-      why: change.why,
-      at: change.subject,
-      blocking: change.blocking
-    }))
-  } catch (e) {
-    return [
-      {
-        code: 'released-unreadable',
-        message: `직전 발행판을 오늘 형식으로 읽을 수 없어 견주지 못했다: ${(e as Error).message}`,
-        why: '이 발행이 이미 놓인 인스턴스를 깨는지는 확인되지 않았다.',
-        blocking: false
-      }
-    ]
-  }
-}

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

@@ -1,149 +0,0 @@
-/**
- * figure-source — 정본이 들어오는 문에서 무엇을 막고 무엇을 알리나.
- *
- * 이 파일이 지키는 것은 하나다. **서버가 형식을 어긴 정본을 저장하지 않는다.**
- * 저작 화면이 검증하니 서버는 믿어도 된다는 말이 안 되는 이유는, 저작 화면을 거치지
- * 않는 길(가져오기·API·AI 어시스턴트)이 있기 때문이다.
- *
- * 그리고 파생값(`score`·`triangles`·`groups`)을 **클라이언트에서 받지 않는다**는 것도
- * 여기서 지킨다. 받으면 목록 화면이 실물과 다른 것을 보여 준다.
- */
-import { FigureSourceError, parseSource } from './figure-source'
-
-/**
- * 온전한 부품 하나. 시험할 필드만 덮어쓴다.
- *
- * `y: -350` 은 `source()` 의 상자(높이 800)의 밑면 -400 에 딱 붙어 서는 자리다. 바닥 기반
- * 도형이 상자 밑면에 안 닿으면 `parts-off-placement-face` 가 난다 — 픽스처가 그걸 달고
- * 있으면 「위반이 없다」를 보는 시험이 그 하나 때문에 빨개진다.
- */
-function part(over: Record<string, unknown> = {}) {
-  return {
-    name: 'body',
-    primitive: 'cube',
-    transform: { position: { x: 0, y: 50, z: 0 }, size: { x: 100, y: 100, z: 100 } },
-    material: { token: 'palette.primary' },
-    ...over
-  }
-}
-
-/** 온전한 정본 하나. */
-function source(over: Record<string, unknown> = {}) {
-  return {
-    version: 2,
-    type: 'MIXER',
-    base: { x: 300, y: 800, z: 300 },
-    detailLevel: 'M',
-    parts: [part()],
-    ...over
-  }
-}
-
-const json = (v: unknown) => JSON.stringify(v)
-
-describe('figure-source — 들어오는 문', () => {
-  describe('막는다', () => {
-    it('JSON 이 아니면 던진다 — 무엇이 잘못됐는지 말한다', () => {
-      let thrown: FigureSourceError | undefined
-      try {
-        parseSource('{ 이건 JSON 이 아니다')
-      } catch (e) {
-        thrown = e as FigureSourceError
-      }
-
-      expect(thrown).toBeInstanceOf(FigureSourceError)
-      expect(thrown!.findings[0].code).toBe('source-not-json')
-      // 조용히 빈 값으로 넘기지 않는다
-      expect(thrown!.findings[0].message).toContain('JSON')
-    })
-
-    it('객체가 아니면 던진다', () => {
-      for (const bad of ['null', '42', '"x"', '[]']) {
-        expect(() => parseSource(bad)).toThrow(FigureSourceError)
-      }
-    })
-
-    it('형식을 어기면 던지고, figure-model 의 코드를 그대로 전한다', () => {
-      let thrown: FigureSourceError | undefined
-      try {
-        parseSource(json(source({ parts: [] })))
-      } catch (e) {
-        thrown = e as FigureSourceError
-      }
-
-      expect(thrown).toBeInstanceOf(FigureSourceError)
-      expect(thrown!.findings[0].code).toBe('missing-parts')
-    })
-
-    it('필수 필드가 빠지면 던진다', () => {
-      // type 없음
-      expect(() => parseSource(json({ base: { x: 1, y: 1, z: 1 }, parts: [part()] }))).toThrow(FigureSourceError)
-    })
-
-    it('오류의 위치(at)를 알린다 — 어느 부품인지 저작 화면이 짚을 수 있다', () => {
-      let thrown: FigureSourceError | undefined
-      try {
-        parseSource(json(source({ parts: [part({ transform: { position: { x: 0, y: 0, z: 0 }, size: { x: -1, y: 1, z: 1 } } })] })))
-      } catch (e) {
-        thrown = e as FigureSourceError
-      }
-
-      expect(thrown).toBeInstanceOf(FigureSourceError)
-      expect(thrown!.findings.some(f => !!f.at)).toBe(true)
-    })
-  })
-
-  describe('통과시킨다', () => {
-    it('온전한 정본은 그대로 통과한다', () => {
-      const result = parseSource(json(source()))
-      expect(result.violations).toEqual([])
-    })
-
-    it('정본을 다시 직렬화하지 않는다 — 들어온 문자열을 그대로 저장한다', () => {
-      // 이미 version이 있는 정본은 키 순서·공백을 그대로 보존한다
-      const raw = json(source())
-      expect(parseSource(raw).source).toBe(raw)
-    })
-
-    /*
-      A source without a version was written before edition 2, with y measured from the box centre.
-      It is refused rather than stamped with the current edition, which would move every part.
-    */
-    it('refuses a source without a version instead of stamping the current edition on it', () => {
-      const withoutVersion = json({ type: 'MIXER', base: { x: 300, y: 800, z: 300 }, detailLevel: 'M', parts: [part()] })
-      expect(() => parseSource(withoutVersion)).toThrow(FigureSourceError)
-      try {
-        parseSource(withoutVersion)
-      } catch (e) {
-        expect((e as FigureSourceError).findings.map(one => one.code)).toContain('source-version-unsupported')
-      }
-    })
-  })
-
-  describe('파생값은 서버가 계산한다', () => {
-    it('점수·삼각형 수·묶음 수가 채워진다', () => {
-      const { derived } = parseSource(json(source()))
-
-      expect(typeof derived.score).toBe('number')
-      expect(derived.score).toBeGreaterThanOrEqual(0)
-      expect(derived.score).toBeLessThanOrEqual(100)
-      expect(derived.triangles).toBeGreaterThan(0)
-      expect(derived.groups).toBeGreaterThan(0)
-    })
-
-    it('클라이언트가 보낸 값은 쓰이지 않는다 — 정본만 본다', () => {
-      // 정본 안에 거짓 파생값을 심어도 셈은 부품에서 나온다
-      const lying = json(source({ score: 100, triangles: 1, groups: 1 } as Record<string, unknown>))
-      const honest = json(source())
-
-      expect(parseSource(lying).derived).toEqual(parseSource(honest).derived)
-    })
-
-    it('부품이 늘면 삼각형 수도 는다 — 셈이 정본을 실제로 읽는다', () => {
-      const one = parseSource(json(source())).derived.triangles
-      const two = parseSource(json(source({ parts: [part(), part({ name: 'lid' })] }))).derived.triangles
-
-      expect(two).toBeGreaterThan(one)
-    })
-  })
-})

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

@@ -1,94 +0,0 @@
-import { compile, costOf, scoreOf, validate } from '@hatiolab/figure-model'
-
-import { FigureFinding } from './figure-type.js'
-
-/**
- * 정본을 받아 **검증하고 파생값을 계산한다.**
- *
- * ## 왜 서버가 검증하나
- *
- * 저작 화면을 못 믿어서가 아니다. **저작 화면을 거치지 않는 길이 있다** — 가져오기,
- * API 직접 호출, AI 어시스턴트. 그 길로 들어온 정본이 형식을 어기면 도면에서 조용히
- * 안 그려진다. 들어오는 문에서 막는다.
- *
- * ## 막는 것과 알리는 것
- *
- * `figure-model` 이 두 단계로 나눠 놓았고, 서버가 그 경계를 다시 정하지 않는다.
- *
- *   errors      형식을 어긴 것. **거절한다**
- *   violations  한도를 넘은 것. 거절하지 않고 **함께 돌려준다**
- *
- * ## 파생값은 서버가 계산한다
- *
- * `score`·`triangles`·`groups` 를 클라이언트에서 받지 않는다. 받으면 거짓이 들어오고
- * 목록 화면이 실물과 다른 것을 보여 준다. 정본에서 계산한다.
- */
-export interface ParsedSource {
-  /** 저장할 정본 JSON 문자열. 들어온 것을 그대로 쓴다 — 단, version 누락 시에만 정규화 직렬화한다. */
-  source: string
-  /** 목록 화면이 정렬·필터에 쓰는 파생값. */
-  derived: { score: number; triangles: number; groups: number }
-  /** 막지 않는 발견. 호출한 쪽이 응답에 실어 보낸다. */
-  violations: FigureFinding[]
-}
-
-/** 정본이 형식을 어겼다. 저장하지 않는다. */
-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
-  }
-}
-
-/**
- * 정본 JSON 문자열을 검증하고 파생값을 계산한다.
- *
- * @throws {FigureSourceError} JSON 이 아니거나 형식을 어긴 경우
- */
-export function parseSource(sourceJson: string): ParsedSource {
-  let parsed: unknown
-  try {
-    parsed = JSON.parse(sourceJson)
-  } catch (e) {
-    throw new FigureSourceError([
-      { code: 'source-not-json', message: `정본이 JSON 이 아니다: ${(e as Error).message}`, at: 'source' }
-    ])
-  }
-
-  const result = validate(parsed)
-  if (result.errors.length > 0) {
-    throw new FigureSourceError(
-      result.errors.map(e => ({ code: e.code, message: e.message, at: e.path }))
-    )
-  }
-
-  /*
-    No version is stamped here. validate has already refused a source without one: every source saved
-    without a version was written with y measured from the box centre, and stamping the current
-    edition on it would move every part (ADR-0065).
-  */
-  const normalizedSource = sourceJson
-
-  // 여기까지 왔으면 형식은 맞다. 청사진을 만들어 셈에 쓴다.
-  // 청사진 자체는 **저장하지 않는다** — 파생 캐시이므로 소비하는 쪽이 다시 만든다.
-  const blueprint = compile(parsed as any)
-  const cost = costOf(blueprint, 1)
-  const score = scoreOf(blueprint)
-
-  return {
-    source: normalizedSource,
-    derived: {
-      score: score.score,
-      triangles: cost.triangles,
-      groups: cost.groups
-    },
-    violations: result.violations.map(v => ({
-      code: v.code,
-      message: v.message,
-      at: undefined
-    }))
-  }
-}