@things-factory/figure-ui 10.1.46 → 10.1.48

package/test/v3-links.test.ts

@@ -10,7 +10,7 @@ import assert from 'node:assert/strict'
 import { addV3Box, addV3Primitive, applyV3Authoring, createV3Asset } from '@hatiolab/figure-model'
 import type { V3Asset } from '@hatiolab/figure-model'
 
-import { acceptsOf, canFasten, canFollow, fastenedTo, followOf, hasInstanceSize, holdsThings, motionOf, placeFacesOf, placeIdFor, placesOn, positionsWorkedOut } from '../client/modeller/v3-links.ts'
+import { acceptsOf, canFasten, canFollow, dimensionNow, instanceRangeOf, rangeDiffers, turnsAboutAJoint, fastenedTo, followableAxes, followOf, hasInstanceSize, positionIsShare, holdsThings, motionOf, placeFacesOf, placeIdFor, placesOn, positionsWorkedOut } from '../client/modeller/v3-links.ts'
 
 const pair = (): V3Asset => {
   let asset = createV3Asset('Pair')
@@ -28,7 +28,7 @@ test('크기 — 제 치수 · 인스턴스 크기 · 다른 부품의 치수를
   const asset = pair()
   assert.deepEqual(followOf(asset, 'plate', 'x'), { of: 'own' })
   const byInstance = applyV3Authoring(asset, { kind: 'link-dimension', part: 'plate', axis: 'x', source: { of: 'instance', axis: 'x' } })
-  assert.deepEqual(followOf(byInstance, 'plate', 'x'), { of: 'instance', axis: 'x' })
+  assert.deepEqual(followOf(byInstance, 'plate', 'x'), { of: 'instance', axis: 'x', times: 1 })
   const byPart = applyV3Authoring(byInstance, { kind: 'link-dimension', part: 'block', axis: 'x', source: { of: 'part', part: 'plate', axis: 'x' }, times: 0.5 })
   assert.deepEqual(followOf(byPart, 'block', 'x'), { of: 'part', part: 'plate', axis: 'x' }, '배율이 끼어도 원천을 찾는다')
   const back = applyV3Authoring(byPart, { kind: 'unlink-dimension', part: 'block', axis: 'x', mm: 300 })
@@ -46,7 +46,8 @@ test('붙이기 — 누구에게 붙었나, 붙일 수 있는 모양인가', ()
   const withDrum = addV3Primitive(asset, { id: 'drum', kind: 'cylinder', dimensions: { radius: 50, length: 100 }, position: { x: 0, y: 50, z: 0 } })
   assert.equal(canFasten(withDrum, 'block'), true)
   assert.equal(canFasten(withDrum, 'drum'), true, '원기둥도 면으로 붙인다(figure-model 0.1.47)')
-  assert.equal(canFollow(withDrum, 'drum'), false, '원기둥의 치수 셋은 X·Y·Z 가 아니라 따르기는 상자만')
+  assert.equal(canFollow(withDrum, 'drum'), true, '원기둥은 반지름(X)과 길이(Y)를 따를 수 있다')
+  assert.deepEqual(followableAxes(withDrum, 'drum'), ['x', 'y'], '원기둥에는 제 Z 가 없다')
 })
 
 test('움직임 — 미끄러짐 · 돌기, 축, 무엇이 모느냐를 읽는다', () => {
@@ -81,7 +82,8 @@ const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.m
 
 test('고르개의 값은 지금 따르는 것을 가리킨다', () => {
   assert.equal(choiceOf({ of: 'own' }), 'own')
-  assert.equal(choiceOf({ of: 'instance', axis: 'y' }), 'instance:y')
+  assert.equal(choiceOf({ of: 'instance', axis: 'y', times: 1 }), 'instance:y')
+  assert.equal(choiceOf({ of: 'instance', axis: 'y', times: 0.25 }), 'share:y', '몫은 비례로')
   assert.equal(choiceOf({ of: 'part', part: 'plate', axis: 'x' }), 'part:plate:x')
 })
 
@@ -95,8 +97,8 @@ test('편집기는 세 칸의 명령을 세션의 이력 하나로 돌리고,
 
 test('떼면 지금 크기로 고정한다 — 따르던 값을 잃지 않는다', () => {
   const links = read('../client/modeller/figure-v3-links.ts')
-  assert.match(links, /kind: 'unlink-dimension', part: this\.partId, axis, mm \}/)
-  assert.match(links, /this\.dims\?\.\[AXES\.indexOf\(axis\)\]/)
+  assert.ok(links.includes("this.command({ kind: 'unlink-dimension', part: this.partId, axis, mm: Math.max(1, Math.round(current)) })"))
+  assert.ok(links.includes('const current = dimensionNow(asset, this.partId, axis) ?? this.dims?.[AXES.indexOf(axis)] ?? 100'))
 })
 
 test('세 칸의 말은 다섯 말 모두에 있다', () => {
@@ -161,3 +163,84 @@ test('받는 종류가 없으면 자리를 만들지 않는다 — 형식에 「
   assert.match(links, /\?disabled=\$\{this\.locked \|\| !accepts\.length \|\| !capacityOk\}/)
   assert.deepEqual(acceptsOf(' , ,'), [])
 })
+
+/* ── V2's proportional rules (user 2026-09-24: ROBOT_ARM at twice the size looked broken) ───────────── */
+
+const sizedPair = () => {
+  let asset = createV3Asset('Probe')
+  asset = addV3Box(asset, { id: 'base', size: { x: 200, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
+  asset = addV3Primitive(asset, { id: 'flange', kind: 'cylinder', dimensions: { radius: 20, length: 10 }, position: { x: 0, y: 95, z: 0 } })
+  asset.document.model.inputs.push({ id: 'size.y', unit: 'mm', min: 1, max: 20000, role: 'design' } as never)
+  asset.designInputs['size.y'] = 100
+  return asset
+}
+
+test('비례 — 인스턴스 크기의 몫을 따르는 치수는 비례로 읽고, 「남은 만큼 채우기」는 비례가 아니다', () => {
+  const asset = sizedPair()
+  assert.equal(dimensionNow(asset, 'flange', 'y'), 10, '원기둥의 Y 는 길이')
+  assert.equal(dimensionNow(asset, 'flange', 'x'), 20, '원기둥의 X 는 반지름')
+  const share = applyV3Authoring(asset, { kind: 'link-dimension', part: 'flange', axis: 'y', source: { of: 'instance', axis: 'y' }, times: 0.1 })
+  assert.deepEqual(followOf(share, 'flange', 'y'), { of: 'instance', axis: 'y', times: 0.1 })
+
+  /* V2's span: the size less what the others take -- a sum, not a share (ROBOT_ARM's tool flange). */
+  const fill = structuredClone(asset)
+  const m = fill.document.model as unknown as { nodes: { id: string; op: string; args: string[]; outputs: Record<string, string> }[]; constants: { id: string; unit: string; value: number }[] }
+  m.constants.push({ id: 'k.gaps', unit: 'mm', value: -90 })
+  m.nodes.push({ id: 'flange.free', op: 'add@1', args: ['size.y', 'k.gaps'], outputs: { value: 'flange.free.value' } })
+  m.nodes.push({ id: 'flange.dimension.y', op: 'mul@1', args: ['flange.free.value', m.constants.find(c => c.value === 1)?.id ?? 'k.one'], outputs: { value: 'flange.dimension.y.value' } })
+  if (!m.constants.some(c => c.value === 1)) m.constants.push({ id: 'k.one', unit: 'ratio', value: 1 })
+  assert.deepEqual(followOf(fill as V3Asset, 'flange', 'y'), { of: 'expression' })
+
+  /* Before any link the shape reads the measure directly; a worked-out one there is not 「고정」 (ROBOT_ARM on :3300). */
+  const direct = structuredClone(asset)
+  const d = direct.document.model as unknown as typeof m
+  d.constants.push({ id: 'k.gaps', unit: 'mm', value: -90 })
+  d.nodes.push({ id: 'flange.free', op: 'add@1', args: ['size.y', 'k.gaps'], outputs: { value: 'flange.free.value' } })
+  d.nodes.find(n => n.id === 'flange.shape')!.args[1] = 'flange.free.value'
+  assert.deepEqual(followOf(direct as V3Asset, 'flange', 'y'), { of: 'expression' })
+  assert.deepEqual(followOf(asset, 'flange', 'y'), { of: 'own' }, '제 숫자는 고정')
+})
+
+test('자리를 크기에 비례로 두면 그렇게 읽고, 다시 권하지 않는다', () => {
+  let asset = sizedPair()
+  asset = applyV3Authoring(asset, { kind: 'scale-position', part: 'flange', axis: 'y' })
+  assert.equal(positionIsShare(asset, 'flange', 'y'), true)
+  assert.equal(positionIsShare(asset, 'base', 'y'), false)
+  const links = read('../client/modeller/figure-v3-links.ts')
+  assert.ok(links.includes("hasInstanceSize(asset, axis) && !positionIsShare(asset, this.partId, axis)"))
+  assert.ok(links.includes("this.command({ kind: 'scale-position', part: this.partId, axis })"))
+  assert.ok(links.includes("const times = Math.round((current / size) * 1e6) / 1e6"), '비례는 지금 치수의 몫')
+})
+
+test('놓일 수 있는 크기 — 남은 만큼 채우던 부품을 비례로 바꾸면 다시 재어 넓힌다', () => {
+  assert.equal(instanceRangeOf(createV3Asset('Probe')), undefined, '크기를 선언하지 않은 도형에는 범위가 없다')
+  let asset = sizedPair()
+  for (const axis of ['x', 'z'] as const) {
+    asset.document.model.inputs.push({ id: `size.${axis}`, unit: 'mm', min: 1, max: 20000, role: 'design' } as never)
+    asset.designInputs[`size.${axis}`] = 200
+  }
+  const y = asset.document.model.inputs.find(i => i.id === 'size.y')!
+  y.min = 90
+  y.max = 1000
+  const range = instanceRangeOf(asset)!
+  assert.deepEqual(range.declared.y, { min: 90, max: 1000 })
+  assert.deepEqual(range.measured.y, { min: 1, max: 1000 }, '기본 범위: 1 mm 에서 열 배')
+  assert.equal(rangeDiffers(range.declared, range.measured), true)
+  asset = applyV3Authoring(asset, { kind: 'declare-instance-size', range: range.measured, replace: true })
+  assert.equal(rangeDiffers(instanceRangeOf(asset)!.declared, instanceRangeOf(asset)!.measured), false, '다시 재면 같다')
+  const editor = read('../client/modeller/v3-editor.ts')
+  assert.ok(editor.includes("this.linkCommand({ kind: 'declare-instance-size', range: range.measured, replace: true })"))
+})
+
+test('관절이 있는 도형에는 한 비율로 키우기를 권하고, 선언하면 규칙으로 보인다(수석 아키텍트 판정 09-24)', () => {
+  let asset = sizedPair()
+  assert.equal(turnsAboutAJoint(asset), false)
+  asset = applyV3Authoring(asset, { kind: 'add-motion', part: 'flange', motion: { kind: 'turn', axis: 'y' }, state: { id: 'flange.turn', unit: 'deg', min: 0, max: 90 } })
+  assert.equal(turnsAboutAJoint(asset), true)
+  const editor = read('../client/modeller/v3-editor.ts')
+  const rule = editor.slice(editor.indexOf('  private renderSizingRule('), editor.indexOf('  /** Choose a part,'))
+  assert.ok(rule.includes("asset.sizing === 'uniform'") && rule.includes("'figure.label.sizing-uniform'"), '선언하면 규칙을 말한다')
+  assert.ok(rule.includes("turnsAboutAJoint(asset) ? html`<p hint>${i18next.t('figure.text.sizing-uniform-proposed')}"), '관절이 있으면 권한다')
+  assert.ok(rule.includes("this.linkCommand({ kind: 'scale-uniformly' })"), '누르면 선언한다 — 사람이 정한다')
+})
+

package/test/v3-live.test.ts

@@ -0,0 +1,99 @@
+/*
+ * **끄는 동안 자연스럽게** (사용자 2026-09-24: 「조작값도 인풋값이 변화하는 과정도 모두 이벤트처리해서 편집기에서도
+ * 자연스럽게 움직이면 좋겠다」). 끄는 중간값은 그 자세로 바로 그리고 아무것도 기록하지 않는다; 놓을 때 한 번 기록한다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+import { addV3Box, applyV3Authoring, createV3Asset } from '@hatiolab/figure-model'
+
+import { liveOverridesOf, livePartsOf, NOTHING_LIVE, scrubbed, scrubStep } from '../client/modeller/v3-live.ts'
+
+const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
+
+const slider = () => {
+  let asset = createV3Asset('Slider')
+  asset = addV3Box(asset, { id: 'block', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+  return applyV3Authoring(asset, { kind: 'add-motion', part: 'block', motion: { kind: 'slide', axis: 'x' }, state: { id: 'shift', unit: 'mm', min: 0, max: 60, start: 0 } })
+}
+
+test('끄는 값으로 그 자세를 바로 그린다 — 도형은 그대로', () => {
+  const asset = slider()
+  const before = JSON.stringify(asset)
+  const parts = livePartsOf(asset, { values: { shift: 45 } })!
+  assert.equal(Math.round(parts.find(p => p.id === 'block')!.pose.t[0]!), 45)
+  assert.equal(JSON.stringify(asset), before, '아무것도 기록하지 않는다')
+  assert.equal(livePartsOf(asset, NOTHING_LIVE), null, '끄는 것이 없으면 평소대로')
+})
+
+test('속성창의 설계 값도 치는 동안 그린다 — 크기가 따라 변하고 도형은 그대로', () => {
+  const asset = slider()
+  const before = JSON.stringify(asset)
+  const size = (parts: { id: string; shape?: unknown }[]) => JSON.stringify((parts.find(p => p.id === 'block') as { shape: unknown }).shape)
+  const now = livePartsOf(asset, { values: { 'block.size.x': 100 } })!
+  const wider = livePartsOf(asset, { values: { 'block.size.x': 300 } })!
+  assert.notEqual(size(wider), size(now), '크기 300 이 바로 그려진다')
+  assert.equal(JSON.stringify(asset), before, '기록은 놓을 때')
+})
+
+test('설계 값과 자세를 가른다 — 모르는 이름은 버린다', () => {
+  assert.deepEqual(liveOverridesOf(slider(), { shift: 10, 'block.size.x': 5, nothing: 1 }), { design: { 'block.size.x': 5 }, state: { shift: 10 } })
+})
+
+test('치는 도중 도형이 못 받는 값이면 지금 모습을 그린다 — 지어낸 도형을 보이지 않는다', () => {
+  assert.equal(livePartsOf(slider(), { values: { 'block.size.x': -5 } }), null)
+})
+
+test('재질의 끄는 값(발광)도 그린다 — 편집 하나를 기록 없이 적용해서', () => {
+  const asset = slider()
+  const glowing = livePartsOf(asset, {
+    values: {},
+    edit: { kind: 'set-material', target: 'block', material: { token: 'palette.primary', emissive: { token: 'palette.primary', intensity: 0.5, on: true } } }
+  })!
+  assert.equal(glowing.find(p => p.id === 'block')!.material.emissive?.intensity, 0.5)
+  assert.equal(asset.appearance[0]!.material.emissive, undefined, '도형은 그대로')
+})
+
+test('이름표를 끌면 값이 크기에 맞는 걸음으로 움직인다 — 각도 1°, 길이는 자릿수에 따라, Shift 는 열 배 곱게', () => {
+  assert.equal(scrubStep('deg', 30), 1)
+  assert.equal(scrubStep('mm', 50), 1)
+  assert.equal(scrubStep('mm', 12000), 100)
+  assert.equal(scrubStep('mm', 1200), 10)
+  assert.equal(scrubStep('mm', 1200, true), 1)
+  assert.equal(scrubStep('ratio', 0.4), 0.01)
+  assert.equal(scrubbed(1200, 7, 10), 1270)
+  assert.equal(scrubbed(0.4, 3, 0.01), 0.43, '0.43000000000000005 가 아니다')
+})
+
+test('속성창 숫자 칸은 치는 동안 알리고, 이름표를 끌 수 있다 — 기록은 change 에서', () => {
+  const editor = read('../client/modeller/v3-editor.ts')
+  assert.ok(editor.includes('@input=${(e: Event) => this.typing(group.cells[axis] as never, e)}'))
+  assert.ok(editor.includes('@input=${(e: Event) => this.typing(field as never, e)}'))
+  assert.ok(editor.includes('@pointerdown=${(e: PointerEvent) => this.scrub(group.cells[axis] as never, e, unavailable)}'))
+  for (const event of ['@v3-state-live=', '@v3-states-live=', '@v3-part-live=']) assert.ok(editor.includes(event), event)
+  assert.ok(editor.includes('livePartsOf(asset as V3Asset, this.live)') && editor.includes('.parts=${this.drawnParts(view.geometry, asset)}'), '캔버스가 끄는 값을 그린다')
+  const run = editor.slice(editor.indexOf('  private run(action'), editor.indexOf('  private hold('))
+  assert.ok(run.includes('this.live = NOTHING_LIVE'), '기록하거나 거절되면 끄는 값을 버린다')
+  const material = read('../client/modeller/figure-v3-material.ts')
+  assert.ok(material.includes('@input=${(e: Event) => this.glow(Number((e.target as HTMLInputElement).value), true)}'))
+})
+
+test('슬라이더와 클립 막대는 끄는 동안 알리고, 놓을 때 한 번 기록한다', () => {
+  const controls = read('../client/modeller/figure-v3-controls.ts')
+  assert.ok(controls.includes('@input=${(e: Event) => this.drag(c, number(e))}') && controls.includes('@change=${(e: Event) => this.try(c, number(e))}'))
+  assert.ok(controls.includes("new CustomEvent('v3-state-live'"))
+  const clips = read('../client/modeller/figure-v3-clips.ts')
+  assert.ok(clips.includes('@input=${(e: Event) => this.scrub(clip, number(e), true)}'))
+  assert.ok(clips.includes("new CustomEvent('v3-states-live'"))
+})
+
+test('클립 트랙의 머리는 이름 한 줄, 그 아래 반복 방식과 지우기 — 이름이 한 글자씩 쌓이지 않는다', () => {
+  const clips = read('../client/modeller/figure-v3-clips.ts')
+  const head = clips.slice(clips.indexOf('    div[track-head] {'), clips.indexOf('    div[keys] {'))
+  assert.ok(head.includes('display: grid;') && !head.includes('display: flex;'), '공통 스타일의 폭 100% 가 이름을 누르지 않는다')
+  assert.ok(head.includes('grid-column: 1 / -1;'), '이름은 제 줄')
+  assert.ok(head.includes('width: 30px;'), '지우기는 작은 버튼')
+})
+

package/test/v3-material.test.ts

@@ -66,3 +66,9 @@ test('자산에 없는 색 역할은 그 색을 함께 보낸다 — 새 도형
   assert.match(material, /this\.palette\[token\] === undefined && offered\[token\] !== undefined/)
   assert.match(material, /\.\.\.\(Object\.keys\(palette\)\.length \? \{ palette \} : \{\}\)/)
 })
+
+test('분할 수는 V2 처럼 — 흔한 넷은 다각형 윤곽과 삼각형 수로, 나머지는 접어 둔다', () => {
+  const source = readFileSync(fileURLToPath(new URL('../client/modeller/figure-v3-material.ts', import.meta.url)), 'utf8')
+  assert.ok(source.includes('SEGMENT_PRESETS.slice(0, 4).map(') && source.includes('${silhouette(preset)}'))
+  assert.ok(source.includes('<details free') && source.includes('SEGMENT_PRESETS.slice(4)'))
+})

package/test/v3-maturity.test.ts

@@ -0,0 +1,268 @@
+/*
+ * **V3 성숙도 탭은 V2 리포트를 V3 수로 다시 보인다** (사용자 2026-09-24: 「분석부분도 많이 부족하고, 왜 이렇게 너프되었는지」).
+ *
+ * V2 리포트(figure-report.ts)는 개수 · 등급과 눈금 · 등급을 정한 한도 · 여섯 축 radar · 한도 막대 · 그리는 비용 · 재사용
+ * 추이를 보였다. 여기서는 그 수들이 V3 자산에서 V2 의 셈 그대로 나오는지, V3 렌더러가 실제로 나눠 쓰는 것을 세는지,
+ * 화면이 그 순서와 말로 그리는지를 본다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+import { addV3Box, addV3Primitive, applyV3Authoring, compileV3Asset, createV3Asset, LIMITS, v3ScoreOf } from '@hatiolab/figure-model'
+import type { V3Asset } from '@hatiolab/figure-model'
+import { acquireV3Geometry, releaseV3Geometry } from '@hatiolab/things-scene'
+
+import {
+  BOARD_ASSETS,
+  budgetOf,
+  curveLayout,
+  decadeSteps,
+  GRADE_SCALE,
+  gradeOf,
+  V3_BUDGET_KEYS,
+  v3ReportOf
+} from '../client/modeller/v3-maturity.ts'
+import { capacityFrom } from '../client/modeller/scene-budget.ts'
+
+const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
+const verdict = read('../client/modeller/figure-v3-verdict.ts')
+const maturity = read('../client/modeller/v3-maturity.ts')
+
+/** An asset with the given tokens in its palette, so boxes can differ in colour. */
+function withPalette(...tokens: string[]): V3Asset {
+  const asset = createV3Asset('Probe')
+  for (const token of tokens) asset.palette[token] = '#336699'
+  return asset
+}
+
+const cube = (id: string, x: number, token = 'palette.primary', extra: Record<string, unknown> = {}) => ({
+  id,
+  size: { x: 100, y: 100, z: 100 },
+  position: { x, y: 50, z: 0 },
+  material: { token, ...extra }
+})
+
+test('부품이 없으면 리포트가 없다 — 0 으로 그리지 않는다', () => {
+  assert.equal(v3ReportOf(createV3Asset('Empty')), undefined)
+})
+
+test('등급은 V2 의 눈금이다 — 한도의 절반 A · 4분의 3 B · 한도 C · 넘치면 D', () => {
+  assert.deepEqual(GRADE_SCALE, [
+    ['A', 0.5],
+    ['B', 0.75],
+    ['C', 1]
+  ])
+  assert.equal(gradeOf(0.5), 'A')
+  assert.equal(gradeOf(0.51), 'B')
+  assert.equal(gradeOf(0.75), 'B')
+  assert.equal(gradeOf(1), 'C')
+  assert.equal(gradeOf(1.01), 'D')
+})
+
+test('등급은 figure-model 의 v3ScoreOf 그대로다 — 목록과 이 탭이 한 셈으로 매긴다', () => {
+  let asset = createV3Asset('Probe')
+  asset = addV3Box(asset, cube('a', 0))
+  const one = v3ReportOf(asset)!
+  assert.deepEqual(one.score, v3ScoreOf(asset))
+  assert.deepEqual(V3_BUDGET_KEYS, one.score.budgets.map(b => b.key), '화면이 말을 찾는 키와 셈의 키가 같다')
+})
+
+test('draw call 한도 3 은 없다 — 한 화면 166 대 목표에 견준다(수석 아키텍트 판정 09-24)', () => {
+  let asset = createV3Asset('Probe')
+  for (let i = 0; i < 4; i++) asset = addV3Box(asset, cube(`b${i}`, i * 200))
+  const four = v3ReportOf(asset)!
+  assert.equal(four.score.grade, 'A', '예전 한도 3 으로는 D 였다')
+  const groups = four.score.budgets.find(b => b.key === 'groups')!
+  assert.equal(groups.limit, LIMITS.groupsOnScreen / LIMITS.screenInstances)
+  assert.ok(four.capacity.instances >= 2 * LIMITS.screenInstances, 'A 는 목표의 두 배가 들어간다는 뜻')
+})
+
+test('감춘 부품은 그리지 않으므로 한도에 들지 않는다 — v3CostOf 와 같은 셈', () => {
+  let asset = createV3Asset('Probe')
+  asset = addV3Box(asset, cube('a', 0))
+  asset = addV3Box(asset, cube('b', 200))
+  const report = v3ReportOf(asset)!
+  assert.equal(report.score.budgets.find(b => b.key === 'groups')!.used, report.cost.groups)
+  assert.equal(report.capacity.instances, capacityFrom(report.cost.groups, report.cost.triangles)!.instances)
+})
+
+test('투명 재질은 서로 다른 재질로 센다 — 둘이면 한도 1 을 넘고, 그것이 등급을 정한다', () => {
+  let asset = withPalette('glass.a', 'glass.b')
+  asset = addV3Box(asset, cube('a', 0, 'glass.a', { transparent: true }))
+  asset = addV3Box(asset, cube('b', 200, 'glass.b', { transparent: true }))
+  const report = v3ReportOf(asset)!
+  assert.equal(report.score.budgets.find(b => b.key === 'transparent')!.used, 2)
+  assert.equal(report.score.tightest.key, 'transparent')
+  assert.equal(report.score.grade, 'D')
+
+  let same = withPalette('glass.a')
+  same = addV3Box(same, cube('a', 0, 'glass.a', { transparent: true }))
+  same = addV3Box(same, cube('b', 200, 'glass.a', { transparent: true }))
+  assert.equal(v3ReportOf(same)!.score.budgets.find(b => b.key === 'transparent')!.used, 1, '같은 재질은 하나로 나눠 쓴다')
+})
+
+test('상태를 따라 움직이는 부품을 센다 — V2 의 「따로 움직이는 부품」', () => {
+  let asset = createV3Asset('Probe')
+  asset = addV3Box(asset, cube('base', 0))
+  asset = addV3Box(asset, cube('arm', 200))
+  assert.equal(v3ReportOf(asset)!.score.budgets.find(b => b.key === 'independent')!.used, 0, '전제: 움직임이 없으면 0')
+
+  asset = applyV3Authoring(asset, {
+    kind: 'add-motion',
+    part: 'arm',
+    motion: { kind: 'turn', axis: 'y' },
+    state: { id: 'arm.turn', unit: 'deg', min: 0, max: 90 }
+  })
+  assert.equal(v3ReportOf(asset)!.score.budgets.find(b => b.key === 'independent')!.used, 1, '도는 팔 하나')
+})
+
+test('서로 다른 형상은 things-scene 이 정점 버퍼를 나눠 쓰는 수와 같다', () => {
+  let asset = createV3Asset('Probe')
+  asset = addV3Box(asset, cube('a', 0))
+  asset = addV3Box(asset, cube('b', 200))
+  asset = addV3Box(asset, { id: 'c', size: { x: 100, y: 300, z: 100 }, position: { x: 400, y: 150, z: 0 } })
+  asset = addV3Primitive(asset, { id: 'd', kind: 'cylinder', dimensions: { radius: 40, length: 100 }, position: { x: 600, y: 50, z: 0 } })
+  asset = addV3Primitive(asset, { id: 'e', kind: 'cylinder', dimensions: { radius: 40, length: 100 }, position: { x: 800, y: 50, z: 0 } })
+  asset = addV3Primitive(asset, { id: 'f', kind: 'cylinder', dimensions: { radius: 40, length: 100 }, position: { x: 1000, y: 50, z: 0 } })
+  // The same cylinder, rounder: another vertex buffer in the renderer, so another shape here.
+  asset.appearance.find(look => look.target === 'f')!.segments = 24
+  const report = v3ReportOf(asset)!
+
+  const bodies = compileV3Asset(asset).evaluate().geometry
+  const held = bodies.map(body => acquireV3Geometry((body as { shape: never }).shape, (body as { segments?: number }).segments))
+  try {
+    assert.equal(report.distinctShapes, new Set(held).size, '렌더러의 은행과 같은 키')
+  } finally {
+    held.forEach(geometry => releaseV3Geometry(geometry))
+  }
+  assert.equal(report.distinctShapes, 4, '같은 상자 둘 · 키 큰 상자 · 같은 원기둥 둘 · 분할이 다른 원기둥')
+  assert.deepEqual(report.reuse, { distinct: 4, parts: 6, saved: 2 })
+  assert.equal(report.axes.find(axis => axis.key === 'reuse')!.ratio, 1 - 4 / 6)
+})
+
+test('여섯 축 — V2 의 순서, 잴 수 없는 둘은 비율 없이 까닭을 단다', () => {
+  let asset = withPalette('palette.accent')
+  asset = addV3Box(asset, cube('a', 50))
+  asset = addV3Box(asset, cube('b', 150, 'palette.accent'))
+  const axes = v3ReportOf(asset)!.axes
+
+  assert.deepEqual(
+    axes.map(axis => axis.key),
+    ['scale', 'consistency', 'reuse', 'detail', 'reactive', 'readable']
+  )
+  const byKey = Object.fromEntries(axes.map(axis => [axis.key, axis]))
+  assert.equal(byKey.detail!.ratio, undefined)
+  assert.equal(byKey.detail!.blocked, 'figure.text.maturity-blocked-no-detail-level', '디테일 등급은 V3 에 없다(ADR-0087)')
+  assert.equal(byKey.reactive!.ratio, undefined)
+  assert.equal(byKey.reactive!.blocked, 'figure.text.maturity-blocked-no-binding')
+
+  assert.equal(byKey.scale!.ratio, 1, `두 부품이면 ${BOARD_ASSETS} 개 목표를 넘긴다`)
+  assert.equal(byKey.consistency!.ratio, 1, '재질 둘은 한도 셋 안이다')
+  // Two colours, each half of the footprint, no background: entropy ln 2 over the ceiling ln 4.
+  assert.equal(byKey.readable!.ratio, Math.log(2) / Math.log(LIMITS.distinctMaterials + 1))
+  assert.equal(byKey.readable!.reading, '2')
+})
+
+test('재질이 한도를 넘으면 일관성이 한 칸 내려간다 — V2 의 셋 중 하나', () => {
+  let asset = withPalette('t1', 't2', 't3')
+  asset = addV3Box(asset, cube('a', 0))
+  asset = addV3Box(asset, cube('b', 200, 't1'))
+  asset = addV3Box(asset, cube('c', 400, 't2'))
+  asset = addV3Box(asset, cube('d', 600, 't3'))
+  const report = v3ReportOf(asset)!
+  assert.equal(report.distinctMaterials, 4)
+  const consistency = report.axes.find(axis => axis.key === 'consistency')!
+  assert.equal(consistency.ratio, 2 / 3)
+  assert.equal(consistency.readingKey, 'figure.text.maturity-consistency-faults')
+})
+
+test('한 색이 발자국을 다 덮으면 식별성은 0 이다 — 위에서 보면 한 덩어리', () => {
+  let asset = createV3Asset('Probe')
+  asset = addV3Box(asset, { id: 'slab', size: { x: 400, y: 20, z: 400 }, position: { x: 0, y: 10, z: 0 } })
+  asset = addV3Box(asset, { id: 'under', size: { x: 100, y: 5, z: 100 }, position: { x: 0, y: 2.5, z: 0 } })
+  assert.equal(v3ReportOf(asset)!.axes.find(axis => axis.key === 'readable')!.ratio, 0, '아래 부품은 가려진다')
+})
+
+test('추이 — 1 에서 1만까지 1·2·5, 삼각형과 draw call 은 오르고 정점 버퍼와 재질은 평평하다', () => {
+  assert.deepEqual(decadeSteps(1, 100), [1, 2, 5, 10, 20, 50, 100])
+  let asset = createV3Asset('Probe')
+  asset = addV3Box(asset, cube('a', 0))
+  asset = addV3Box(asset, cube('b', 200))
+  const report = v3ReportOf(asset)!
+  const last = report.curve[report.curve.length - 1]!
+  assert.equal(report.curve[0]!.instances, 1)
+  assert.equal(last.instances, 10000)
+  assert.equal(last.triangles, report.cost.triangles * 10000)
+  assert.equal(last.drawCalls, report.cost.groups * 10000)
+  assert.ok(report.curve.every(p => p.geometries === report.distinctShapes && p.materials === report.distinctMaterials))
+
+  const layout = curveLayout(report.curve)!
+  assert.deepEqual(layout.lines.map(line => [line.key, line.flat, line.dashed]), [
+    ['triangles', false, false],
+    ['drawCalls', false, false],
+    ['geometries', true, false],
+    ['materials', true, true]
+  ])
+  assert.equal(layout.overlap, 1, '형상 하나 · 재질 하나 — 평평한 선이 겹친다고 적는다')
+  assert.deepEqual(layout.xTicks.map(t => t.label), ['1', '10', '100', '1k', '10k'])
+})
+
+test('화면은 V2 리포트의 차례로 그린다 — 개수 · 축 · 한도 · 그리는 비용 · 추이 · 발행 판정', () => {
+  const order = ['this.renderVerdict(report)', 'this.renderAxes(report)', 'this.renderBudgets(report)', 'this.renderMetrics(report)', 'this.renderCurve()', 'this.renderGate()']
+  // From the full report, past the early return that shows only guidance and the release verdict.
+  const at = order.map(call => verdict.indexOf(call, verdict.indexOf('${this.renderVerdict(report)}')))
+  assert.ok(at.every(i => i > 0), `모든 절을 그린다: ${order.filter((_, i) => at[i] < 0)}`)
+  assert.deepEqual([...at].sort((a, b) => a - b), at)
+  assert.ok(verdict.includes('...GRADE_SCALE.map('), '눈금은 등급을 셈한 경계에서 그린다 — 따로 적으면 어긋난다')
+  assert.ok(verdict.includes('SidePanelStyles'), '옆 칸의 한 모양을 쓴다')
+})
+
+test('radar 와 추이 그림의 조각은 svg 템플릿이다 — html 로 만들면 소리 없이 안 그려진다', () => {
+  for (const block of verdict.match(/svg`[\s\S]*?<\/svg>/g) ?? []) {
+    assert.doesNotMatch(block, /html`\s*<\s*(polygon|line|circle|rect|path|text|g)\b/)
+  }
+  assert.ok((verdict.match(/svg`/g) ?? []).length >= 8, '전제: 조각을 센다')
+})
+
+test('화면이 키를 이어 붙여 찾는 말도 다섯 말 모두에 있다', () => {
+  const keys = [
+    ...V3_BUDGET_KEYS.map(key => `figure.label.budget-${key}`),
+    ...['scale', 'consistency', 'reuse', 'detail', 'reactive', 'readable'].flatMap(key => [`figure.label.axis-${key}`, `figure.label.axis-${key}-short`]),
+    'figure.text.bound-by-groups',
+    'figure.text.bound-by-triangles',
+    ...[...maturity.matchAll(/'(figure\.[a-z.-]*[a-z])'/g)].map(m => m[1]!)
+  ]
+  for (const lang of ['ko', 'en', 'ja', 'zh', 'ms']) {
+    const table = JSON.parse(read(`../translations/${lang}.json`))
+    for (const key of keys) assert.ok(table[key], `${lang}: ${key}`)
+  }
+})
+
+test('부품 목록 머리의 값 한 줄 — 삼각형 · 묶음 · 한 화면 몇 대 · 등급, D 면 넘친 한도를 적는다', () => {
+  assert.equal(budgetOf(undefined), undefined, '잴 것이 없으면 줄도 없다')
+  let asset = createV3Asset('Probe')
+  asset = addV3Box(asset, cube('a', 0))
+  const line = budgetOf(v3ReportOf(asset))!
+  assert.deepEqual(
+    { triangles: line.triangles, groups: line.groups, grade: line.grade },
+    { triangles: 12, groups: 1, grade: 'A' }
+  )
+  assert.equal(line.instances, capacityFrom(1, 12)!.instances)
+
+  let glass = withPalette('glass.a', 'glass.b')
+  glass = addV3Box(glass, cube('a', 0, 'glass.a', { transparent: true }))
+  glass = addV3Box(glass, cube('b', 200, 'glass.b', { transparent: true }))
+  const over = budgetOf(v3ReportOf(glass))!
+  assert.equal(over.grade, 'D')
+  assert.deepEqual(over.tightest, { key: 'transparent', used: 2, limit: 1 })
+
+  const parts = read('../client/modeller/figure-v3-parts.ts')
+  const drawn = parts.slice(parts.indexOf('  private renderBudget()'), parts.indexOf('  /** 한꺼번에 감추고'))
+  assert.ok(drawn.includes("const over = b.grade === 'D'") && drawn.includes("'figure.text.parts-budget-over'"), 'D 에서 넘친 한도를 적는다')
+  assert.ok(parts.includes("new CustomEvent('show-maturity'"), '누르면 성숙도로')
+  const editor = read('../client/modeller/v3-editor.ts')
+  assert.ok(editor.includes('.budget=${this.budget}') && editor.includes("@show-maturity=${() => (this.tab = 'verdict')}"))
+  assert.ok(verdict.includes('budget: budgetOf(report)'), '성숙도 탭이 같은 보고서에서 알린다')
+})

package/test/v3-palette-icons.test.ts

@@ -0,0 +1,22 @@
+/*
+ * **팔레트 아이콘은 글꼴에 있는 이름만** (사용자 2026-09-24: 「is this icon proper?」 — 벽 칸에 「AL」이 떴다).
+ *
+ * `md-icon` 은 이름을 합자로 그린다. 글꼴에 없는 이름은 글자 그대로 나오고, 칸에 잘려 「wall」이 「AL」로 보였다.
+ * node 에서는 글꼴을 볼 수 없어, :3300 의 글꼴에서 한 칸 폭(24px)으로 그려지는 것을 잰 이름만 여기에 둔다. 새 아이콘은
+ * 화면에서 재어 보고 이 목록에 더한다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+/** Measured in the app's icon font on :3300, 2026-09-24: each draws one cell wide. `wall` drew 52px -- its letters. */
+const RENDERS = new Set(['deployed_code', 'database', 'crop_square', 'circle', 'change_history', 'hexagon', 'check_box_outline_blank', 'crop_portrait', 'door_front'])
+
+test('every shape in the palette has an icon the font draws', () => {
+  const parts = readFileSync(fileURLToPath(new URL('../client/modeller/figure-v3-parts.ts', import.meta.url)), 'utf8')
+  const recipes = parts.slice(parts.indexOf('const RECIPES'), parts.indexOf(']', parts.indexOf('const RECIPES')))
+  const icons = [...recipes.matchAll(/icon: '([a-z_]+)'/g)].map(m => m[1]!)
+  assert.ok(icons.length >= 9)
+  assert.deepEqual(icons.filter(icon => !RENDERS.has(icon)), [])
+})

package/test/v3-parts-wiring.test.ts

@@ -29,7 +29,9 @@ test('복제 · 순서 · 삭제는 figure-model 의 부품 편집으로, 세션
 })
 
 test('작업대에서 가린 부품은 캔버스에서 빠지고, 다른 도형을 열면 풀린다', () => {
-  assert.match(editor, /drawableV3Parts\(view\.geometry \?\? \[\]\)\.filter\(body => !this\.hiddenParts\.has/)
+  assert.ok(editor.includes('.parts=${this.drawnParts(view.geometry, asset)}'))
+  const drawn = editor.slice(editor.indexOf('  private drawnParts('), editor.indexOf('  private hold('))
+  assert.ok(drawn.includes('parts.filter(body => !this.hiddenParts.has('), '끄는 값을 그릴 때도 가린 부품은 빠진다')
   const reset = editor.slice(editor.indexOf('protected willUpdate'), editor.indexOf('private run('))
   assert.match(reset, /this\.hiddenParts = new Set\(\)/)
 })

package/test/v3-preview.test.ts

@@ -0,0 +1,42 @@
+/*
+ * **미리보기 — V2 의 그것** (사용자 2026-09-24: 「미리보기도 v2 가 낫다」). 저작 중인 도형을 도면처럼 등록하고,
+ * 기준 크기와 한 · 두 · 세 축을 2배로 늘린 일곱을 나란히 FigureInstance 로 세운다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+import { addV3Box, createV3Asset } from '@hatiolab/figure-model'
+
+import { authoredSizeOf, PREVIEW_WAYS, previewInstances } from '../client/modeller/v3-preview-model.ts'
+
+const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
+
+test('여덟 — 기준과 일곱 조합, 한 줄에 넷, 늘린 축만 두 배 · 높이는 늘 적는다', () => {
+  assert.deepEqual(PREVIEW_WAYS.map(w => w.name), ['base', 'x', 'y', 'z', 'x·y', 'x·z', 'y·z', 'x·y·z'])
+  const { components, board } = previewInstances('T', { x: 1000, y: 500, z: 400 })
+  assert.equal(components.length, 8)
+  assert.deepEqual(components.map(c => [c.width, c.depth, c.height]), [
+    [1000, 500, 400], [2000, 500, 400], [1000, 1000, 400], [1000, 500, 800],
+    [2000, 1000, 400], [2000, 500, 800], [1000, 1000, 800], [2000, 1000, 800]
+  ])
+  assert.ok(components.every(c => c.type === 'T'))
+  assert.deepEqual(board, { width: 10000, height: 2000 }, '가장 큰 것이 들어갈 칸 넷씩 두 줄')
+})
+
+test('크기를 선언하지 않은 도형은 부품이 차지하는 범위를 기준 크기로', () => {
+  const asset = addV3Box(createV3Asset('Fixed'), { id: 'body', size: { x: 300, y: 200, z: 100 }, position: { x: 0, y: 100, z: 0 } })
+  assert.deepEqual(authoredSizeOf(asset), { x: 300, y: 200, z: 100 })
+})
+
+test('편집 | 미리보기 — 띠에서 오가고, 미리보기는 도면처럼 등록해 세우며 제 타입으로 남의 도면을 건드리지 않는다', () => {
+  const editor = read('../client/modeller/v3-editor.ts')
+  assert.ok(editor.includes("(['edit', 'preview'] as const).map("))
+  assert.ok(editor.includes('<figure-v3-preview'))
+  const preview = read('../client/modeller/figure-v3-preview.ts')
+  assert.ok(preview.includes('registerFigureV3(type, asset)') && preview.includes('unregisterFigureV3(this.registered)'))
+  assert.ok(preview.includes('`figure-v3-preview-${this.context || \'new\'}`'))
+  assert.ok(preview.includes("kind: 'set-state-defaults'"), '이 자세를 기본으로')
+  assert.ok(preview.includes('dialShape('), '각도는 다이얼로')
+})

package/test/v3-properties.test.ts

@@ -61,8 +61,10 @@ test('태그 줄은 V2 와 같은 규칙으로 목록이 된다', () => {
 const page = read('../client/pages/figure-v3-modeller-page.ts')
 
 test('화면이 속성 탭을 걸고, 명령은 세션의 이력 하나로, 분류 · 태그는 행으로 간다', () => {
-  assert.ok(/renderTab\('properties', 'tune'/.test(page), '속성 탭')
-  assert.ok(/<figure-v3-properties\s+\?off=/.test(page), '감추되 떼지 않는다')
+  const editor = read('../client/modeller/v3-editor.ts')
+  assert.ok(/renderTab\('properties', 'tune'/.test(editor), '속성 탭은 편집기의 오른쪽 칸에')
+  assert.ok(/<figure-v3-properties\s+slot="figure"/.test(page), '도형 속성은 부품을 고르지 않았을 때 속성 탭에 선다')
+  assert.ok(editor.includes('<slot name="figure"></slot>'))
   assert.ok(/@v3-command=\$\{this\.onCommand\}/.test(page) && /@v3-catalog=\$\{this\.onCatalog\}/.test(page))
   const run = page.slice(page.indexOf('private runCommand'), page.indexOf('private onCatalog'))
   assert.ok(/this\.session\.command\(actionOf\(\)\)/.test(run), '명령은 세션을 지난다 — 되돌리기가 먹는다')