@things-factory/figure-ui 10.1.16 → 10.1.18

package/test/figure-source.test.ts

@@ -0,0 +1,572 @@
+import assert from 'node:assert/strict'
+import { fileURLToPath } from 'node:url'
+import { describe, it, test } from 'node:test'
+
+import { expect } from './expect.ts'
+
+import { existsSync, readFileSync } from 'fs'
+import { dirname, join } from 'path'
+
+import { toFigureSource, fromFigureSource, partToFigure, partFromFigure } from '../client/modeller/figure-source.ts'
+import type { FigureDraft, PartModel } from '../client/modeller/figure-source.ts'
+import type { FigurePlacement, FigureSource } from '@hatiolab/figure-model'
+
+/**
+ * 씬 모델 ↔ `FigureSource`.
+ *
+ * 저작 중의 정본은 씬 모델이고, 형식은 저장하거나 판정할 때 접어서 만든다. 두 어휘가
+ * 다르므로 **옮기는 일이 한 곳에만** 있어야 하고, 그 한 곳이 맞는지를 여기서 못 박는다.
+ *
+ * 가장 중요한 것은 왕복이다. 접었다 펴면 같아야 하고 펴서 접어도 같아야 한다 —
+ * 어느 한쪽에서만 맞으면 AI 가 제안해 온 정본을 편집하는 순간 값이 샌다.
+ */
+
+/** 판 3000 x 2000 x 800 — 세 축이 다 달라야 축을 바꿔 써도 시험이 잡는다. */
+const DRAFT: FigureDraft = {
+  width: 3000,
+  height: 2000,
+  depth: 800,
+  figureType: 'AGV',
+  detailLevel: 'L'
+}
+
+const PART: PartModel = {
+  type: 'figure-part',
+  name: 'deck',
+  primitive: 'cube',
+  left: 1100,
+  top: 700,
+  width: 800,
+  height: 600,
+  zPos: 300,
+  depth: 200,
+  token: 'palette.primary'
+}
+
+describe('접기 — 씬 모델을 형식으로', () => {
+  it('판이 기준 상자가 된다 — 높이는 판의 depth 다', () => {
+    const { base } = toFigureSource(DRAFT, [])
+    expect(base).toEqual({ x: 3000, y: 800, z: 2000 })
+  })
+
+  it('부품 자리가 판 중심 기준이 된다', () => {
+    const [part] = toFigureSource(DRAFT, [PART]).parts
+
+    // 평면 중심 (1100+400, 700+300) = (1500, 1000), 판 중심 (1500, 1000) → 원점
+    expect(part.transform.position.x).toBe(0)
+    expect(part.transform.position.z).toBe(0)
+  })
+
+  it('zPos 는 밑면이다 — 중심으로 올려 적는다', () => {
+    const [part] = toFigureSource(DRAFT, [PART]).parts
+
+    // 밑면 300 + 두께 200/2 = 중심 400. 판 높이 800 의 절반을 빼면 0
+    expect(part.transform.position.y).toBe(0)
+  })
+
+  it('가운데를 벗어난 부품이 그만큼 어긋나 적힌다', () => {
+    const moved = { ...PART, left: 1200, top: 900, zPos: 500 }
+    const [part] = toFigureSource(DRAFT, [moved]).parts
+
+    expect(part.transform.position).toEqual({ x: 100, y: 200, z: 200 })
+  })
+
+  it('크기가 축 이름으로 바뀐다 — 두께가 y 다', () => {
+    const [part] = toFigureSource(DRAFT, [PART]).parts
+    expect(part.transform.size).toEqual({ x: 800, y: 200, z: 600 })
+  })
+
+  /*
+    씬은 라디안을 쓰고 이름이 뒤섞여 있다 — rotationY 가 three 의 z 로 간다.
+    형식은 도를 쓰고 축 이름이 그대로다.
+  */
+  it('회전이 도로 바뀌고 축이 제자리를 찾는다', () => {
+    const turned = { ...PART, rotationX: Math.PI / 6, rotation: Math.PI / 2, rotationY: Math.PI }
+    const [part] = toFigureSource(DRAFT, [turned]).parts
+
+    expect(part.transform.rotation).toEqual({ x: 30, y: -90, z: 180 })
+  })
+
+  it('회전이 없으면 필드를 두지 않는다', () => {
+    const [part] = toFigureSource(DRAFT, [PART]).parts
+    expect(part.transform.rotation).toBeUndefined()
+  })
+
+  it('재질이 한 덩어리로 모인다', () => {
+    const [part] = toFigureSource(DRAFT, [{ ...PART, preset: 'metal', flatShading: false }]).parts
+    expect(part.material).toEqual({ token: 'palette.primary', preset: 'metal', flatShading: false })
+  })
+
+  it('단면 값이 shape 으로 모인다', () => {
+    const [part] = toFigureSource(DRAFT, [{ ...PART, primitive: 'rect', round: 40 }]).parts
+    expect(part.shape).toEqual({ round: 40 })
+  })
+
+  it('단면 값이 없으면 shape 을 두지 않는다', () => {
+    expect(toFigureSource(DRAFT, [PART]).parts[0].shape).toBeUndefined()
+  })
+})
+
+describe('펴기 — 형식을 씬 모델로', () => {
+  const SOURCE: FigureSource = {
+    type: 'AGV',
+    base: { x: 3000, y: 800, z: 2000 },
+    detailLevel: 'L',
+    parts: [
+      {
+        name: 'deck',
+        primitive: 'cube',
+        transform: { position: { x: 100, y: 200, z: 200 }, size: { x: 800, y: 200, z: 600 } },
+        material: { token: 'palette.primary' }
+      }
+    ]
+  }
+
+  it('기준 상자가 판이 된다', () => {
+    const { draft } = fromFigureSource(SOURCE)
+    expect(draft).toMatchObject({ width: 3000, height: 2000, depth: 800 })
+  })
+
+  it('중심 기준 자리가 씬의 모서리·밑면으로 바뀐다', () => {
+    const [part] = fromFigureSource(SOURCE).parts
+    expect(part).toMatchObject({ left: 1200, top: 900, zPos: 500 })
+  })
+
+  it('부품이 씬 타입을 갖는다 — 판에 그대로 놓을 수 있어야 한다', () => {
+    expect(fromFigureSource(SOURCE).parts[0].type).toBe('figure-part')
+  })
+})
+
+/*
+  왕복.
+
+  이것이 이 모듈의 존재 이유다. 한쪽에서만 맞으면 AI 가 제안해 온 정본을 펴서
+  편집하고 다시 접는 순간 값이 샌다 — 그것도 조용히.
+*/
+/**
+ * 형식이 가진 것을 되도록 다 담은 정본. 안 쓰이는 필드도 넣는다.
+ *
+ * describe 밖에 둔다 — 아래 「픽스처가 형식을 다 담는다」가 이것을 형식의 필드 목록과
+ * 맞대어 본다.
+ */
+/** 형식이 가진 것을 되도록 다 담은 정본. 안 쓰이는 필드도 넣는다. */
+const FULL: FigureSource = {
+  version: 1,
+  type: 'AGV',
+  base: { x: 3000, y: 800, z: 2000 },
+  placement: 'floor',
+  detailLevel: 'L',
+  styleKit: 'factory',
+  parts: [
+    {
+      name: 'deck',
+      primitive: 'cube',
+      transform: { position: { x: 100, y: 200, z: 200 }, size: { x: 800, y: 200, z: 600 } },
+      material: { token: 'palette.primary', preset: 'metal', flatShading: true }
+    },
+    {
+      name: 'wheel',
+      primitive: 'cylinder',
+      segments: 24,
+      transform: {
+        position: { x: -700, y: -260, z: 420 },
+        size: { x: 180, y: 70, z: 180 },
+        rotation: { z: 90 }
+      },
+      material: { token: 'palette.dark', preset: 'rubber' }
+    },
+    {
+      name: 'panel',
+      primitive: 'rect',
+      // 속을 판 단면. 한 겹 안이라 처음 판 시험이 못 봤던 자리다.
+      shape: { round: 40, hollow: { wall: 8, floor: 4 } },
+      transform: {
+        position: { x: 0, y: 260, z: -500 },
+        size: { x: 400, y: 30, z: 200 },
+        rotation: { x: 15, y: -30, z: 45 }
+      },
+      material: { token: 'palette.accent', transparent: true },
+      // 아직 아무 일도 안 하는 필드들. 잃어버리면 안 된다.
+      materialSlot: 'cap',
+      keepRound: false,
+      sizing: 'fixed',
+      anchor: { x: 'span', y: 'max', z: 'center' },
+      label: { name: 'rpm', source: 'speed', when: 'zoomed' }
+    },
+    {
+      name: 'foot',
+      primitive: 'polygon',
+      shape: {
+        path: [
+          { x: -60, y: -40 },
+          { x: 60, y: -40 },
+          { x: 0, y: 40 }
+        ]
+      },
+      transform: { position: { x: 900, y: -340, z: -600 }, size: { x: 120, y: 80, z: 80 } },
+      material: { token: 'palette.neutral' },
+      sizing: 'repeat',
+      repeat: { axis: 'x', pitch: 200 }
+    },
+    {
+      /*
+        물건을 놓는 자리이면서 드나드는 문이다 — AGV 의 상판이 그렇다. **그려지지 않으므로**
+        재질이 없다.
+
+        그리지 않는 것이라 화면으로는 왕복에서 누락됐는지 알 수 없다. 자리를 잃어버린 도형은
+        멀쩡해 보이면서 아무것도 받지 못한다.
+      */
+      name: 'seat',
+      primitive: 'cube',
+      transform: { position: { x: 0, y: 420, z: 0 }, size: { x: 700, y: 500, z: 500 } },
+      capability: { roles: ['slot', 'port-in', 'port-out'], accepts: ['PALLET'], capacity: 2 }
+    }
+  ],
+  /* 이 도형이 지는 능력. 부품이 아니라 도형 전체의 것이다. */
+  capabilities: ['FlowNode'],
+  /*
+    움직임. 편집면이 아직 안 만지는 자리이며, **바로 그래서 여기 있다.**
+
+    이 픽스처가 「형식이 가진 것을 되도록 다 담은 정본」인데 clip 이 빠져 있었고, 그
+    사이 `toFigureSource` 가 clip 을 안 실었다. 시험은 초록이었다 — 픽스처에 없는 것은
+    시험이 못 본다. 표본 롤러에 clip 을 적고 미리보기에서 아무것도 안 돌고 나서야 알았다.
+  */
+  animations: [
+    {
+      name: 'spin',
+      channels: [
+        {
+          target: 'wheel',
+          path: 'rotation',
+          pivot: { x: 0, y: 0, z: 0 },
+          keys: [
+            { at: 0, value: { x: 0, y: 0, z: 0 } },
+            { at: 1, value: { x: 0, y: 360, z: 0 } }
+          ]
+        }
+      ]
+    }
+  ],
+  /*
+    값이 만드는 자세. 애니메이션과 **다른 칸이라** 따로 담는다 — 같은 이유로 여기 있다.
+    한 칸이 새면 열었다 저장하는 것만으로 조용히 지워진다.
+  */
+  parameters: [
+    {
+      name: 'lift',
+      label: '포크 높이',
+      range: { unit: 'mm', min: 0, max: 1800 },
+      default: 0,
+      clip: {
+        channels: [
+          {
+            target: 'wheel',
+            path: 'translation',
+            keys: [
+              { at: 0, value: { x: 0, y: 0, z: 0 } },
+              { at: 2.5, value: { x: 0, y: 1800, z: 0 } }
+            ]
+          }
+        ]
+      }
+    }
+  ]
+}
+
+describe('왕복해도 같다', () => {
+
+  it('펴서 접으면 그대로다', () => {
+    const { draft, parts } = fromFigureSource(FULL)
+    expect(toFigureSource(draft, parts)).toEqual(FULL)
+  })
+
+  it('접어서 펴면 그대로다', () => {
+    const { draft, parts } = fromFigureSource(FULL)
+    const again = fromFigureSource(toFigureSource(draft, parts))
+
+    expect(again.draft).toEqual(draft)
+    expect(again.parts).toEqual(parts)
+  })
+
+  it('두 번 왕복해도 값이 밀리지 않는다 — 라디안·도를 오가도', () => {
+    let source = FULL
+    for (let i = 0; i < 5; i++) {
+      const { draft, parts } = fromFigureSource(source)
+      source = toFigureSource(draft, parts)
+    }
+    expect(source).toEqual(FULL)
+  })
+
+  it('움직임도 살아남는다 — 열었다 저장하는 것만으로 지워지던 자리다', () => {
+    const { draft, parts } = fromFigureSource(FULL)
+
+    expect(toFigureSource(draft, parts).animations).toEqual(FULL.animations)
+  })
+
+  it('값이 만드는 자세도 살아남는다 — 애니메이션과 다른 칸이라 따로 샐 수 있다', () => {
+    const { draft, parts } = fromFigureSource(FULL)
+
+    expect(toFigureSource(draft, parts).parameters).toEqual(FULL.parameters)
+  })
+
+  it('안 쓰이는 필드도 살아남는다 — 조용히 사라지면 저작자가 알 길이 없다', () => {
+    const { draft, parts } = fromFigureSource(FULL)
+    const panel = toFigureSource(draft, parts).parts.find(part => part.name === 'panel')!
+
+    expect(panel.materialSlot).toBe('cap')
+    expect(panel.sizing).toBe('fixed')
+    expect(panel.label).toEqual({ name: 'rpm', source: 'speed', when: 'zoomed' })
+  })
+})
+
+/*
+  픽스처가 형식을 따라가는지.
+
+  **이 파일에서 필드가 네 번 샜다** — `ports` · `animations` · `anchor` · `shape.hollow`.
+  네 번 다 왕복 시험은 초록이었다. 위의 `FULL` 이 「형식이 가진 것을 되도록 다 담은
+  정본」이라고 적혀 있었지만 실제로는 그때그때 손으로 채운 것이라, 형식에 필드가 늘면
+  픽스처는 그대로 있고 시험은 늘어난 자리를 보지 못했다.
+
+  네 번째 것은 **한 겹 안**이라 최상위만 세던 첫 판이 놓쳤다. 그래서 픽스처의 키를
+  깊이 상관없이 다 모아 놓고 맞댄다.
+
+  그래서 픽스처를 믿지 않고 **형식이 스스로 밝힌 필드 목록**을 읽는다. 형식이 붙은
+  타입 선언(`dist/types.d.ts`)이 정본이고, 거기 적힌 이름이 픽스처에 없으면 여기서
+  깨진다. 다음 번 필드는 화면이 아니라 이 시험이 먼저 잡는다.
+*/
+describe('픽스처가 형식을 다 담는다', () => {
+  /**
+   * 형식이 붙여 보낸 타입 선언 파일.
+   *
+   * `require.resolve` 로는 못 잡는다 — jest 의 resolver 가 `.d.ts` 를 모듈로 보지
+   * 않는다. 올라가면서 찾고, 못 찾으면 조용히 건너뛰지 않고 여기서 깨진다.
+   */
+  function declarationPath(): string {
+    const here = dirname(fileURLToPath(import.meta.url))
+    for (let at = here; at !== dirname(at); at = dirname(at)) {
+      const candidate = join(at, 'node_modules/@hatiolab/figure-model/dist/types.d.ts')
+      if (existsSync(candidate)) return candidate
+    }
+    throw new Error('figure-model 의 타입 선언을 못 찾았다 — 이 시험은 그것이 정본이다')
+  }
+
+  /** 붙은 타입 선언에서 한 인터페이스의 필드 이름을 뽑는다. */
+  function fieldsOf(name: string): string[] {
+    const declared = readFileSync(declarationPath(), 'utf-8')
+    const start = declared.indexOf(`export interface ${name} {`)
+    expect(start).toBeGreaterThan(-1)
+
+    // 중첩이 없는 평평한 인터페이스다. 다음 닫는 중괄호가 끝이다.
+    const body = declared.slice(start, declared.indexOf('\n}', start))
+    return [...body.matchAll(/^\s{4}(\w+)\??:/gm)].map(m => m[1])
+  }
+
+  /** 픽스처가 쓴 키를 깊이 상관없이 모은다 — 흘린 필드가 한 겹 안에 있었다. */
+  function keysDeep(value: unknown, into = new Set<string>()): Set<string> {
+    if (Array.isArray(value)) value.forEach(one => keysDeep(one, into))
+    else if (value && typeof value === 'object') {
+      for (const [key, one] of Object.entries(value)) {
+        into.add(key)
+        keysDeep(one, into)
+      }
+    }
+    return into
+  }
+
+  const WRITTEN = keysDeep(FULL)
+
+  /*
+    `fold` 가 실제로 낱개로 푸는 것들이다. 통째로 나르는 구조(`transform` 처럼)는 필드가
+    늘어도 안 새므로 여기 없다.
+  */
+  for (const name of ['FigureSource', 'FigurePart', 'PartShape', 'HollowSpec']) {
+    it(`${name} 가 가진 모든 필드가 왕복 픽스처에 있다`, () => {
+      expect(fieldsOf(name).filter(field => !WRITTEN.has(field))).toEqual([])
+    })
+  }
+})
+
+/*
+ * ── The placement is a height, not a flip ────────────────────────────────────
+ *
+ * `placement` says which reference surface a figure of this kind attaches to. It is a fact about
+ * the figure *type*, and what acts on it is the scene placing an instance: a floor figure stands on
+ * the ground, a ceiling one hangs at ceiling height less its own. `operato-scene`'s archetype says
+ * the same — *ceiling: zPos derived from ceiling minus depth* (`archetypes.ts`).
+ *
+ * **Nothing about the authored shape depends on it.** The format measures every part from the box
+ * centre, so two figures with identical parts and different placements have identical `parts`.
+ *
+ * It was wired the other way for a while: the editing canvas fed the figure's placement to the
+ * model layer's `state.placement`, a scene-wide coordinate mode that flips what `zPos` names for
+ * everything in that layer. It stood in for the archetype because the modeller holds one figure —
+ * and every number the author had typed then meant a different face depending on a dropdown, while
+ * what got saved never changed. These four tests hold that line.
+ */
+test('배치를 바꿔도 부품의 자리는 한 글자도 안 바뀐다', () => {
+  const source: FigureSource = {
+    type: 'OHT_TEST',
+    base: { x: 2, y: 3, z: 2 },
+    parts: [
+      /* 두께가 서로 달라야 한다 — 두께에 비례하는 어긋남은 통째로 옮기는 것과 달리 형상을 벌린다. */
+      { name: 'rail', primitive: 'cube', transform: { position: { x: 0, y: 1.425, z: 0 }, size: { x: 2, y: 0.15, z: 0.4 } }, material: { token: 'palette.primary' } },
+      { name: 'belt', primitive: 'cube', transform: { position: { x: 0, y: 0, z: 0 }, size: { x: 0.1, y: 1, z: 0.1 } }, material: { token: 'palette.neutral' } }
+    ]
+  }
+
+  const authored = JSON.stringify(source.parts)
+
+  for (const placement of ['floor', 'ceiling', 'center'] as const) {
+    const { draft, parts } = fromFigureSource({ ...source, placement })
+    assert.equal(
+      JSON.stringify(toFigureSource(draft, parts).parts),
+      authored,
+      `${placement}: 배치가 저작한 자리를 바꿨다`
+    )
+  }
+})
+
+test('편집 캔버스의 zPos 는 배치와 무관하게 밑면이다', () => {
+  /*
+    저작자가 인스펙터에 적는 수다. 그 뜻이 드롭다운에 따라 밑면↔윗면으로 바뀌면, 아무것도
+    안 고쳤는데 모든 부품의 높이가 달라진 것으로 보인다. OHT 에서 실제로 그랬다 —
+    overhead-rail 이 1.35 에서 -1.5 가 되었다.
+  */
+  const part: PartModel = { type: 'figure-part', name: 'rail', primitive: 'cube', left: 0, top: 0, width: 2, height: 0.4, zPos: 1.35, depth: 0.15 }
+  const draft: FigureDraft = { width: 2, height: 2, depth: 3 }
+
+  for (const placement of [undefined, 'floor', 'ceiling', 'center'] as const) {
+    const written = partToFigure(part, { ...draft, placement })
+    /* 밑면 1.35 + 두께 0.15/2 = 중심 1.425. 상자 높이 3 의 절반을 빼면 -0.075. */
+    assert.equal(written.transform.position.y, -0.075, `${placement}: 접는 쪽이 배치를 봤다`)
+    assert.equal(partFromFigure(written, { ...draft, placement }).zPos, 1.35, `${placement}: 펴는 쪽이 배치를 봤다`)
+  }
+})
+
+describe('배치는 씬의 좌표 모드가 아니다', () => {
+  const read = (rel: string) => readFileSync(join(dirname(fileURLToPath(import.meta.url)), rel), 'utf8')
+
+  /*
+    소스를 읽는 검사다. Lit 컴포넌트가 document 없이 안 뜨는 자리라 그렇고, 무엇보다
+    **없어야 하는 것이 없는지**를 묻는 검사는 호출로는 물을 수가 없다.
+  */
+  it('변환이 좌표 모드를 아예 모른다', () => {
+    const source = read('../client/modeller/figure-source.ts')
+
+    assert.doesNotMatch(source, /zPosOffset|toScenePlacement/, '변환에 좌표 모드가 다시 들어왔다')
+    assert.doesNotMatch(
+      source,
+      /placement.*=>.*'inverted'|'inverted'.*:/,
+      '씬의 좌표 낱말이 변환에 들어왔다'
+    )
+  })
+
+  it('편집 캔버스가 씬에 배치를 안 싣는다', () => {
+    const source = read('../client/modeller/figure-canvas.ts')
+
+    assert.doesNotMatch(
+      source,
+      /placement:/,
+      '편집 캔버스가 배치를 씬에 실으면 저작자가 적은 높이의 뜻이 드롭다운마다 바뀐다'
+    )
+  })
+
+  it('setPlacement 가 부품을 안 건드린다', () => {
+    const source = read('../client/modeller/figure-inspector.ts')
+    const body = source.slice(source.indexOf('private setPlacement'), source.indexOf('private setPlacement') + 500)
+
+    assert.match(body, /detail: \{ draft \}/, '배치는 필드 하나만 쓴다')
+    assert.doesNotMatch(body, /zPos/, '배치를 바꾸면서 부품 높이를 다시 계산하면 안 된다')
+  })
+})
+
+describe('미리보기가 높이를 씬에게 맡긴다', () => {
+  const read = (rel: string) => readFileSync(join(dirname(fileURLToPath(import.meta.url)), rel), 'utf8')
+  const preview = read('../client/modeller/figure-preview.ts')
+
+  /*
+    배치 기준을 높이로 옮기는 규칙은 씬이 갖는다 — `FigureRealObject.effectiveZPos` 가 청사진의
+    `placement` 와 레이어의 `heights` 로 정한다(ADR-0045). 미리보기는 「보드에 놓았을 때」를
+    말하는 자리이므로 보드와 같은 길로 세워야 한다.
+
+    이 화면이 규칙을 한 벌 더 들고 있었다. 그러면 씬의 규칙이 바뀌어도 이 화면만 옛 답을 내고,
+    저작자는 보드에 놓고 나서야 다르다는 것을 안다.
+  */
+  it('인스턴스에 zPos 를 적지 않는다 — 적으면 적은 값이 이긴다', () => {
+    const at = preview.indexOf('const components = PREVIEW_WAYS.map')
+    const built = preview.slice(at, preview.indexOf('const draft = {', at))
+
+    assert.doesNotMatch(built, /zPos/, '여기서 높이를 정하면 씬이 무엇을 할지가 이 화면에서만 안 보인다')
+  })
+
+  it('배치를 높이로 옮기는 계산을 들고 있지 않다', () => {
+    assert.doesNotMatch(preview, /bottomOf|zPosOf/, '규칙이 두 벌이면 갈린다')
+  })
+
+  it('천장 높이를 씬에 실어 준다 — 값이 사는 자리가 거기다', () => {
+    assert.match(preview, /heights: \{ floor: 0, ceiling: view\.ceilingHeight \}/)
+  })
+
+  it('미리보기가 좌표 모드를 보기 설정에서 받는다 — 도형에서가 아니라', () => {
+    assert.match(preview, /placement: view\.placement/, '보기 설정의 좌표 모드를 씬에 실어야 한다')
+    assert.doesNotMatch(preview, /placement: (source|toScenePlacement)/, '도형의 배치를 씬 모드로 쓰면 안 된다')
+  })
+
+  it('미리보기가 보기 설정의 조명·환경을 따른다', () => {
+    assert.match(preview, /\.\.\.sceneLook\(view\)/, '하드코딩하면 편집 캔버스와 두 화면이 갈린다')
+    assert.doesNotMatch(preview, /environment: 'studio'/, '환경이 하드코딩으로 남아 있다')
+  })
+})
+
+describe('보기 설정이 편집 캔버스로 새지 않는다', () => {
+  const read = (rel: string) => readFileSync(join(dirname(fileURLToPath(import.meta.url)), rel), 'utf8')
+
+  it('sceneLook 이 좌표 모드와 천장 높이를 뺀다', () => {
+    const view = read('../client/modeller/figure-view.ts')
+    assert.match(view, /const \{ placement, ceilingHeight, \.\.\.look \} = view/)
+  })
+
+  it('편집 캔버스가 rest spread 로 보기 설정을 넘기지 않는다', () => {
+    /*
+      한동안 `const { grid, ..., ...light } = view` 였다. 그러면 설정을 하나 더할 때마다
+      그것이 두 화면에 **말없이** 실린다 — 좌표 모드가 바로 그 길로 들어갈 뻔했다.
+    */
+    const canvas = read('../client/modeller/figure-canvas.ts')
+    const fn = canvas.slice(canvas.indexOf('private sceneView'), canvas.indexOf('private sceneView') + 200)
+
+    assert.match(fn, /sceneLook\(/)
+    assert.doesNotMatch(fn, /\.\.\.light/, '나머지를 통째로 넘기면 새 설정이 조용히 실린다')
+  })
+})
+
+/*
+ * ── 막는 것과 알리는 것을 화면이 갈라야 한다 ──────────────────────────────────
+ *
+ * 판정 패널은 위반을 전부 같은 `info` 로 그렸다. 기준 상자 위반 둘이 발행을 막게 된 뒤에도
+ * 그대로라, 저작자는 다섯 줄의 알림을 보고 **발행을 눌러 보고 나서야** 막힌 것을 안다.
+ *
+ * 등급은 형식이 안다(`blocksRelease`). 화면이 제 목록을 들면 코드가 하나 늘 때 조용히
+ * 「알림」 쪽으로 떨어진다 — 안전하지 않은 쪽으로 기우는 기본값이다.
+ */
+describe('판정 패널이 발행을 막는 것을 갈라 보인다', () => {
+  const read = (rel: string) => readFileSync(join(dirname(fileURLToPath(import.meta.url)), rel), 'utf8')
+  const report = read('../client/modeller/figure-report.ts')
+
+  it('등급을 형식에서 받는다 — 제 목록을 들지 않는다', () => {
+    assert.match(report, /blocksRelease/, '형식이 어느 위반이 막는지 안다')
+    assert.doesNotMatch(
+      report,
+      /'part-outside-base'|'parts-off-placement-face'/,
+      '화면이 코드 이름을 적으면 형식과 두 벌이 된다'
+    )
+  })
+
+  it('막는 것은 다른 아이콘으로 그린다', () => {
+    assert.match(report, /v\.blocking \? 'block' : 'info'/, '같은 아이콘이면 갈린 뜻이 화면에 안 나온다')
+  })
+
+  it('얼마나 넘쳤는지 보여 준다', () => {
+    /* 「상자를 벗어난다」만으로는 2mm 인지 250mm 인지 모르고, 그 둘은 고치는 품이 다르다. */
+    assert.match(report, /v\.actual/, '넘친 양을 버리면 저작자가 무엇부터 고칠지 못 고른다')
+  })
+})

package/test/i18n-prefix-guard.test.ts

@@ -6,7 +6,7 @@
  * 여럿이면 마지막이 이기고 아무 경고도 없다. 그래서 내 파일을 읽어도 화면에 뜨는 값을 알 수
  * 없다 — 내가 적은 값이 아니라 이긴 값이 뜬다.
  *
- * 실제로 그랬다. figure 앱의 발행 단추가 「배포」로 떴다(board-ui 의 `button.release` 가 이겼다).
+ * 실제로 그랬다. figure 앱의 발행 단추가 「배포」로 떴다(draft-ui 의 `button.release` 가 이겼다).
  * 그때 figure 의 266개 키 중 아홉이 **다른 뜻으로** 겹쳐 있었다 — 모델러가 자기 부품을 board 의
  * 낱말인 「품목」이라 부르고 있었고 아무것도 그것을 말해 주지 않았다.
  *
@@ -28,7 +28,7 @@ import { readFileSync, readdirSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import { join } from 'node:path'
 
-import { CHANNEL_PATHS, CLIP_DRIVES, INTERPOLATIONS } from '@hatiolab/figure-model'
+import { CHANNEL_PATHS, INTERPOLATIONS } from '@hatiolab/figure-model'
 
 const HERE = fileURLToPath(new URL('.', import.meta.url))
 const TRANSLATIONS = join(HERE, '../translations')
@@ -125,23 +125,22 @@ test('★ 통이 갈린 짝 — 사다리 이름과 설명', () => {
 /*
   애니메이션 탭도 열거 값을 키에 이어 붙인다. 사다리와 **같은 모양의 함정**이라 같은 못을 박는다.
 
-  갈린 통이 둘이다 — 구동은 이름(`label`)과 설명(`text.…-note`), 경로는 이름(`label`)과
-  단위 설명(`text.…-unit`). 한쪽만 넣으면 화면에 키가 그대로 뜨고, 넓은 앞머리가 위의
-  미사용 검사를 덮어 통과시킨다.
+  경로는 이름(`label`)과 단위 설명(`text.…-unit`)으로 갈린다. 한쪽만 넣으면 화면에 키가
+  그대로 뜨고, 넓은 앞머리가 위의 미사용 검사를 덮어 통과시킨다.
+
+  `CLIP_DRIVES` 는 여기 없다. 구동 갈래는 화면에서 고르는 것이 아니라 **어느 목록에
+  적었는가**가 되었다 — 애니메이션이면 시각이 흐르고 파라미터면 값이 자세를 만든다
+  (ADR-0051 ①).
 
   열거 값을 여기 다시 적지 않고 형식에서 읽는다. 적어 두면 형식에 값을 하나 더할 때
   검사가 조용히 통과한다.
 */
-test('★ 열거 값마다 짝이 다 있다 — 구동 · 경로 · 보간', () => {
+test('★ 열거 값마다 짝이 다 있다 — 경로 · 보간', () => {
   const missing: string[] = []
   const want = (key: string) => {
     if (!(key in KO)) missing.push(key)
   }
 
-  for (const drive of CLIP_DRIVES) {
-    want(`figure.label.drive-${drive}`)
-    want(`figure.text.drive-${drive}-note`)
-  }
   for (const path of CHANNEL_PATHS) {
     want(`figure.label.path-${path}`)
     want(`figure.text.path-${path}-unit`)
@@ -156,8 +155,6 @@ test('★ 열거 값마다 짝이 다 있다 — 구동 · 경로 · 보간', ()
 test('★ 애니메이션 탭이 그 통에서 찾는다 — 이름은 label, 설명은 text', () => {
   const source = readFileSync(join(CLIENT, 'modeller/figure-animations.ts'), 'utf-8')
 
-  assert.ok(source.includes("'figure.label.drive-' + drive"), '구동 이름을 label 통에서 찾지 않는다')
-  assert.ok(source.includes("'figure.text.drive-'"), '구동 설명을 text 통에서 찾지 않는다')
   assert.ok(source.includes("'figure.label.path-' + path"), '경로 이름을 label 통에서 찾지 않는다')
   assert.ok(source.includes("'figure.text.path-' + channel.path + '-unit'"), '단위 설명을 text 통에서 찾지 않는다')
 })