@things-factory/figure-ui 10.1.43 → 10.1.45

package/client/modeller/joint-gizmo.ts

@@ -1,180 +0,0 @@
-/*
- * Copyright © HatioLab Inc. All rights reserved.
- */
-
-import type { FigureJoint, FigurePart, FigureSource } from '@hatiolab/figure-model'
-
-import { partFromFigure } from './figure-source.js'
-import type { FigureDraft, PartModel } from './figure-source.js'
-
-/**
- * 관절이 **어느 자리에서 어느 쪽으로 얼마나 도는지**를 저작면에 그린다.
- *
- * 축은 `+x · -x · +y …` 중에서 고른다. 이름만 보고 어느 쪽으로 도는지 아는 사람은 없고, 지금은
- * 미리보기로 건너가 막대를 끝까지 밀어 봐야 안다 — 여섯 축짜리 로봇에서는 그 왕복이 여섯 번이다.
- * 도는 자리를 그 자리에 그려 두면 고르는 순간 보인다.
- *
- * ## 부채꼴 하나다
- *
- * 관절의 기준점에 **가동 범위만큼 벌어진 얇은 부채꼴**을 눕힌다. 부채꼴의 면이 도는 평면이고,
- * 두께 방향이 축이며, 벌어진 각이 `limits` 다. 무한 회전(`continuous`)은 온전한 원이다.
- *
- * 부품 하나로 그린다 — 씬에 겹쳐 그리는 길을 따로 뚫지 않는다. 저작면은 부품을 컴포넌트로
- * 세우는 자리이고, 이 부채꼴도 그 규칙을 그대로 따른다. `locked` 라 클릭·마퀴·기즈모가 집지
- * 않고, 저장 형식으로는 나가지 않는다(저작면 안에서만 만들어 붙인다).
- */
-
-/** 저작면에만 있는 이름. 부품 목록에는 없다. */
-export const JOINT_GIZMO = '__joint-gizmo'
-
-/** 부채꼴을 몇 조각으로 그리나. 한 조각이 6도쯤이면 원이 원으로 보인다. */
-const STEP = 6
-
-/** 두께. 얇아야 부품을 가리지 않고, 너무 얇으면 옆에서 볼 때 사라진다. */
-const THICKNESS = 6
-
-/**
- * 도는 평면과 두께 방향을 축에 맞춘다.
- *
- * 부채꼴은 단면이 눕고 **제 y 방향으로** 밀려 두꺼워지는 도형이라, 기본 상태의 축이 +y 다.
- * 다른 축은 부품 회전으로 눕힌다 — 부품이 제 회전을 지는 것과 같은 방법이고, 형식이 이미
- * 아는 길이다.
- *
- * `turn` 은 단면 안에서 각을 재는 방향이다. 씬의 회전과 단면의 각이 도는 쪽이 반대인 축이
- * 있어서, 그것을 여기 한 곳에 적어 둔다 — 부채꼴이 실제로 도는 쪽과 반대로 벌어지면
- * 가리키는 뜻이 뒤집힌다.
- */
-const AXIS_LAY: Record<string, { rotation?: FigurePart['transform']['rotation']; turn: 1 | -1 }> = {
-  '+y': { turn: -1 },
-  '-y': { turn: 1 },
-  '+x': { rotation: { z: 90 }, turn: 1 },
-  '-x': { rotation: { z: 90 }, turn: -1 },
-  '+z': { rotation: { x: 90 }, turn: -1 },
-  '-z': { rotation: { x: 90 }, turn: 1 }
-}
-
-/** 축 벡터를 `+x` 꼴의 이름으로. 형식은 단위 벡터를 쓰고 저작면은 여섯 중 하나를 고른다. */
-export function axisName(axis: { x: number; y: number; z: number }): string | undefined {
-  const named = [
-    ['x', axis.x],
-    ['y', axis.y],
-    ['z', axis.z]
-  ] as const
-  const on = named.filter(([, value]) => value !== 0)
-  if (on.length !== 1) return undefined
-  const [name, value] = on[0]!
-  return `${value > 0 ? '+' : '-'}${name}`
-}
-
-/** 이 관절이 도는 범위. 무한 회전은 한 바퀴다. */
-function span(joint: FigureJoint): { from: number; to: number } {
-  if (joint.type === 'continuous' || !joint.limits) return { from: -180, to: 180 }
-  return { from: joint.limits.min, to: joint.limits.max }
-}
-
-/** 부채꼴의 단면. 점은 부품 중심 기준의 밀리미터다. */
-function sector(from: number, to: number, radius: number, turn: 1 | -1): { x: number; y: number }[] {
-  const path: { x: number; y: number }[] = []
-  const full = Math.abs(to - from) >= 359.999
-
-  if (!full) path.push({ x: 0, y: 0 })
-
-  const steps = Math.max(2, Math.ceil(Math.abs(to - from) / STEP))
-  for (let i = 0; i <= steps; i++) {
-    const degrees = from + ((to - from) * i) / steps
-    const rad = (degrees * Math.PI * turn) / 180
-    path.push({ x: +(Math.cos(rad) * radius).toFixed(3), y: +(Math.sin(rad) * radius).toFixed(3) })
-  }
-
-  return path
-}
-
-/**
- * 관절 하나를 그리는 부품. 그릴 수 없으면 `undefined` — 축이 비스듬하면 부채꼴로 그릴 수 없고,
- * 그때 아무 쪽이나 골라 그리면 **틀린 방향을 가리킨다.**
- */
-export function gizmoPart(joint: FigureJoint, child: PartModel | undefined, draft: FigureDraft): PartModel | undefined {
-  const lay = AXIS_LAY[axisName(joint.axis) ?? '']
-  if (!lay) return undefined
-
-  /* 반지름은 **도는 부품의 크기**에서 온다. 부채꼴이 그 부품보다 작으면 무엇이 도는지 안 읽힌다. */
-  const reach = child ? Math.max(child.width, child.height, child.depth) : 0
-  const radius = Math.max(60, Math.round(reach * 0.6))
-
-  const { from, to } = span(joint)
-  const part: FigurePart = {
-    name: JOINT_GIZMO,
-    primitive: 'polygon',
-    transform: {
-      position: { ...joint.origin },
-      size: { x: radius * 2, y: THICKNESS, z: radius * 2 },
-      ...(lay.rotation ? { rotation: lay.rotation } : {})
-    },
-    shape: { path: sector(from, to, radius, lay.turn) },
-    material: { token: 'palette.accent', transparent: true }
-  }
-
-  return { ...partFromFigure(part, draft), locked: true }
-}
-
-/*
- * 미리보기에서 **관절이 돌았다는 것**을 보이게 하는 바늘.
- *
- * 상자 위에 원기둥을 얹고 그 축으로 돌리면 화면이 그대로다 — 원기둥은 제 축에서 대칭이라
- * 돌아도 같은 그림이다. 저작자는 막대를 76도까지 밀고도 아무것도 못 보고 「관절이 안 먹는다」로
- * 읽는다. 값은 제대로 갔고 부품도 돌았는데 볼 것이 없었을 뿐이다.
- *
- * 그래서 관절이 모는 부품에 얇은 막대 하나를 **자식으로** 붙인다. 부모가 관절의 자식이라
- * 관절이 도는 만큼 같이 돌고, 축에서 비켜나 있어 대칭인 부품에서도 움직임이 보인다. 매 프레임
- * 무엇을 다시 그릴 일도, 막대를 밀 때마다 씬을 다시 세울 일도 없다.
- *
- * **미리보기에만 붙인다.** 저장 형식에도, 저작면에도, 카드 그림에도 안 들어간다 — 미리보기는
- * 크기 반응을 보는 작업대이고 거기서만 쓰는 표시다.
- */
-
-/** 미리보기에만 있는 이름. 저장 형식에는 없다. */
-export const NEEDLE = '__needle-'
-
-/**
- * 막대의 굵기 — **길이에 견주어** 잡는다.
- *
- * 8mm 로 고정했더니 미리보기에서 안 보였다. 미리보기는 여덟 대를 한 화면에 세우는 자리라
- * 100mm 짜리 부품이 화면에서 20 픽셀쯤이고, 그 위의 8mm 는 한 픽셀이 안 된다. 세어 보면
- * 막대는 분명히 서 있는데(부품 둘짜리 표본의 인스턴스에 mesh 셋 · 삼각형 72) 눈에 안 띈다.
- */
-const needleThick = (radius: number) => Math.max(6, Math.round(radius / 5))
-
-/** 축에서 비켜날 방향. 그 축과 직각이어야 도는 것이 보인다. */
-const ASIDE: Record<string, 'x' | 'z'> = { x: 'z', y: 'x', z: 'x' }
-
-export function jointNeedles(source: FigureSource): FigurePart[] {
-  const byName = new Map(source.parts.map(part => [part.name, part]))
-
-  return (source.joints ?? []).flatMap(joint => {
-    const axis = axisName(joint.axis)
-    if (!axis) return []
-
-    const child = byName.get(joint.child)
-    const size = child?.transform.size
-    const reach = size ? Math.max(size.x, size.y, size.z) : 0
-    const radius = Math.max(60, Math.round(reach * 0.6))
-    const aside = ASIDE[axis.slice(1)]!
-    const thick = needleThick(radius)
-
-    return [
-      {
-        name: `${NEEDLE}${joint.name}`,
-        primitive: 'cube' as const,
-        transform: {
-          position: { ...joint.origin, [aside]: joint.origin[aside] + radius / 2 },
-          size:
-            aside === 'x'
-              ? { x: radius, y: thick, z: thick }
-              : { x: thick, y: thick, z: radius }
-        },
-        material: { token: 'palette.accent' },
-        parent: joint.child
-      }
-    ]
-  })
-}

package/client/modeller/maturity.ts

@@ -1,288 +0,0 @@
-import { LIMITS, PART_LIMIT, SEGMENT_PRESETS, materialKeyOf } from '@hatiolab/figure-model'
-import type { DetailLevel, FigureCost, FigureScore, FigureSource } from '@hatiolab/figure-model'
-
-import { capacityFrom } from './scene-budget.js'
-
-/**
- * 성숙도 — 이 형상이 얼마나 잘 만들어졌나.
- *
- * ## 축이 여럿이어야 하는 이유
- *
- * 「몇 개까지 편한가」 하나로는 좋은 형상과 나쁜 형상이 구분되지 않는다. 부품 하나짜리
- * 상자도 그 축에서는 만점이다. 잘 만들어졌다는 것은 **여러 물음에 각각 답하는 것**이고,
- * 그것을 한 숫자로 뭉개면 무엇을 고쳐야 할지 알 수 없다.
- *
- * ## 축을 지어내지 않았다
- *
- * `docs/design/component-authoring-tool.md` 의 「인정받을 수 있는 최소 품질 — 기준선」
- * 다섯이 이미 있다. 그것을 잴 수 있는 형태로 옮기고, 이미 셈이 있는 것(규모·되쓰기)을
- * 더했다.
- *
- *   기준선 1 실루엣으로 알아본다      → readable   **아직 측정하지 못한다**
- *   기준선 2 상태가 색으로 구분된다    → reactive   **아직 측정하지 못한다**
- *   기준선 3 다른 자산과 한 세트로 보인다 → consistency
- *   기준선 4 확대해도 안 깨진다        → consistency (텍스처 0)
- *   기준선 5 라벨이 읽힌다            → reactive
- *
- * ## 못 재는 축을 지어내지 않는다
- *
- * 두 축은 지금 잴 수 없다. 하나는 그리기가 필요하고(실루엣), 하나는 형식에 길이
- * 없다(상태 바인딩 — figure-model#2). **그것을 0점으로도 만점으로도 두지 않는다.**
- * 「아직 측정하지 못한다」고 알리고 이유를 붙인다. 측정하지 못한 것을 점수로 만들면 그 점수가 거짓말을
- * 한다.
- *
- * ## 이 파일은 임시다
- *
- * 셈은 figure-model 것이어야 한다 — 거기가 `costOf` · `scoreOf` 를 갖고 있다.
- * 형식 쪽 결정(#2 · #4)이 서면 이 파일을 지우고 그쪽으로 옮긴다.
- */
-
-export type AxisKey = 'scale' | 'consistency' | 'reuse' | 'detail' | 'reactive' | 'readable'
-
-export interface MaturityAxis {
-  key: AxisKey
-  /** 0~1. 못 재면 없다. */
-  ratio?: number
-  /** 지금 이 축의 값. 그대로 보여 준다. */
-  reading?: string
-  /** 값이 숫자가 아니라 말일 때의 문구 키. `reading` 과 함께 쓰지 않는다. */
-  readingKey?: string
-  /** 왜 이 값인가. */
-  because?: string
-  /** 못 재면 그 이유. 있으면 `ratio` 가 없다. */
-  blocked?: string
-}
-
-/** 한 도면에 이만큼 놓는 것을 본다. 설계 문서 §4.15 의 「자산 500 개」. */
-const BOARD_ASSETS = 500
-
-/**
- * 여섯 축을 측정한다.
- *
- * 한 숫자로 합치지 않는다. 합치면 「무엇을 고쳐야 하나」가 사라진다 — 그것이 이
- * 리포트의 존재 이유다.
- */
-export function maturityOf(source: FigureSource, cost: FigureCost, score: FigureScore): MaturityAxis[] {
-  return [scale(cost), consistency(source, cost), reuse(score), detail(source, cost), reactive(source), readable(source, cost)]
-}
-
-/** 규모 — 한 도면에 얼마나 놓을 수 있나. */
-function scale(cost: FigureCost): MaturityAxis {
-  const capacity = capacityFrom(cost.groups, cost.triangles)
-  if (!capacity) {
-    return { key: 'scale', blocked: 'figure.text.maturity-blocked-no-parts' }
-  }
-
-  return {
-    key: 'scale',
-    // 한 도면 목표치(500)를 채우면 1 이다. 그보다 많이 놓을 수 있어도 1 을 넘기지 않는다 —
-    // 목표를 넘긴 여유는 다른 축을 고치는 데 쓰는 편이 낫다.
-    ratio: Math.min(1, capacity.instances / BOARD_ASSETS),
-    reading: String(capacity.instances),
-    because: 'figure.text.maturity-scale-because'
-  }
-}
-
-/**
- * 한 세트로 보이나. 기준선 3·4.
- *
- * 셋을 본다. 팔레트 밖 표면이 없나(텍스처 0 — 확대해도 안 깨진다), 분할 수가
- * 프리셋인가, 투명 재질을 아끼나. 셋 다 이미 형식이 위반으로 세고 있는 것들이다.
- */
-function consistency(source: FigureSource, cost: FigureCost): MaturityAxis {
-  const offPreset = source.parts.filter(
-    part => part.segments !== undefined && !SEGMENT_PRESETS.includes(part.segments)
-  ).length
-
-  const faults =
-    (cost.surfaceTextures > 0 ? 1 : 0) +
-    (offPreset > 0 ? 1 : 0) +
-    (cost.distinctMaterials > LIMITS.materialGroups ? 1 : 0)
-
-  return {
-    key: 'consistency',
-    ratio: (3 - faults) / 3,
-    readingKey: faults === 0 ? 'figure.text.maturity-consistency-clean' : 'figure.text.maturity-consistency-faults',
-    because: 'figure.text.maturity-consistency-because'
-  }
-}
-
-/**
- * 되쓰나 — 같은 형상을 몇 번 다시 쓰나.
- *
- * `scoreOf` 가 이미 재고 있으나 **점수에는 넣지 않는다**고 선언돼 있다(한도가 아니라
- * 덤이다). 축으로는 뜻이 있다 — 되쓰기가 많은 형상이 잘 짜인 형상이다. 다만 부품마다
- * 형상이 달라도 잘못이 아니므로 **낮다고 나무라지 않는다.**
- */
-function reuse(score: FigureScore): MaturityAxis {
-  const { distinct, parts, saved } = score.reuse
-  if (parts === 0) {
-    return { key: 'reuse', blocked: 'figure.text.maturity-blocked-no-parts' }
-  }
-
-  return {
-    key: 'reuse',
-    // ratio 가 낮을수록 많이 되쓴다 — 뒤집어서 높은 쪽이 좋게 만든다
-    ratio: 1 - distinct / parts,
-    reading: String(saved),
-    because: 'figure.text.maturity-reuse-because'
-  }
-}
-
-/**
- * 정밀도 — 밝힌 등급에 걸맞게 만들어졌나.
- *
- * 등급(S·M·L)은 「어느 거리에서 읽히도록 만든 것인가」를 밝히는 것이다. 그런데 등급만
- * 올려 놓고 부품 셋으로 끝내면 그 약속을 안 지킨 것이다. **한도를 얼마나 썼나**로 본다.
- *
- * 이 축은 「많이 쓸수록 좋다」가 아니다. 등급에 맞게 채웠나를 본다 — 그래서 넘치면
- * 다시 내려간다.
- */
-function detail(source: FigureSource, cost: FigureCost): MaturityAxis {
-  const level = (source.detailLevel ?? 'M') as DetailLevel
-  const limit = PART_LIMIT[level]
-  const used = cost.parts / limit
-
-  return {
-    key: 'detail',
-    // 절반쯤 쓴 것을 제일 좋게 본다. 텅 비어도, 넘쳐도 등급과 안 맞는다.
-    ratio: used > 1 ? Math.max(0, 2 - used) : Math.min(1, used * 2),
-    reading: `${cost.parts} / ${limit}`,
-    because: 'figure.text.maturity-detail-because'
-  }
-}
-
-/**
- * 살아 있나 — 기준선 2·5. 상태가 색으로 구분되고 라벨이 읽히나.
- *
- * **지금 잴 수 없다.** 형식에 `slot` 이 있지만 그리는 쪽이 읽지 않고(선언 한 줄이
- * 전부다), 상태를 부품에 잇는 길 자체가 아직 정해지지 않았다(figure-model#2).
- *
- * 0 점으로 두지 않는다. 0 은 「이 형상이 상태를 안 보여 준다」는 뜻이 되는데, 사실은
- * **아무 형상도 보여 줄 수 없는 상태**다. 축 자체가 아직 없는 것이다.
- */
-function reactive(source: FigureSource): MaturityAxis {
-  return { key: 'reactive', blocked: 'figure.text.maturity-blocked-no-binding' }
-}
-
-/**
- * 식별성 — 기준선 1. 위에서 볼 때 무엇인지 알아보나.
- *
- * ## 시점 엔트로피를 빌린다
- *
- * 「어느 시점에서 얼마나 알아볼 수 있나」는 이미 연구된 물음이다. Vázquez 등의
- * **viewpoint entropy** 는 시점에서 보이는 각 면의 투영 면적 비율로 섀넌 엔트로피를
- * 낸다. 모든 면이 같은 면적으로 보일 때가 최대이고, 한 면이 화면을 다 덮으면 0 이다.
- *
- *     H = -Σ (Ai / At) · log(Ai / At)
- *
- * ## 다만 면으로 세지 않는다
- *
- * 그 문헌이 스스로 밝히는 한계가 **폴리곤 분할에 좌우된다**는 것이다 — 같은 형상도
- * 잘게 쪼개면 엔트로피가 올라간다. 우리에게는 그 한계가 치명적이다. 분할 수를 8 에서
- * 16 으로 올리는 것은 형상을 알아보기 쉽게 만드는 일이 아닌데, 면으로 세면 점수가
- * 오른다.
- *
- * 그래서 **면이 아니라 색 구역으로 센다.** 눈이 구별하는 것은 삼각형이 아니라 색이
- * 다른 덩어리다. 같은 토큰을 쓰는 부품 둘이 붙어 있으면 눈에는 한 덩어리다.
- * 이렇게 하면 분할 수에 좌우되지 않으면서 원래 물음에 답한다.
- *
- * ## 기준값도 지어내지 않는다
- *
- * 정규화 분모를 `log(재질 group 한도 + 1)` 로 둔다. 이 형식이 허용하는 재질 group 이
- * 셋이고 거기에 배경을 더하면 넷이므로, **이 형식에서 도달 가능한 최대**가 곧
- * 기준이다. 임의로 고른 수가 아니다.
- *
- * ## 그리지 않고 셈으로 낸다
- *
- * 저작 중에 매번 렌더링할 수 없다. 대신 부품의 발자국(x·y·너비·높이)을 위에서
- * 겹쳐 본다 — 위에 있는 것이 아래를 가린다. 축에 정렬된 상자이므로 격자에 찍어
- * 세면 된다.
- *
- * 이 근사가 실제 렌더링과 맞는지는 하네스가 따로 확인한다
- * (`test/browser/check-silhouette.mjs`).
- */
-function readable(source: FigureSource, cost: FigureCost): MaturityAxis {
-  const regions = topViewRegions(source)
-  if (regions.total === 0) {
-    return { key: 'readable', blocked: 'figure.text.maturity-blocked-no-parts' }
-  }
-
-  // 배경도 한 구역으로 센다 — 발자국을 얼마나 채우나가 식별성의 일부다.
-  // Vázquez 의 「열린 장면」 형태와 같다(최대가 log(면 수 + 1)).
-  const shares = [...regions.byMaterial.values(), regions.background]
-    .map(area => area / regions.footprint)
-    .filter(share => share > 0)
-
-  const entropy = -shares.reduce((sum, p) => sum + p * Math.log(p), 0)
-  const ceiling = Math.log(LIMITS.materialGroups + 1)
-
-  return {
-    key: 'readable',
-    ratio: Math.min(1, entropy / ceiling),
-    reading: `${regions.byMaterial.size}`,
-    because: 'figure.text.maturity-readable-because'
-  }
-}
-
-/**
- * 위에서 내려다볼 때 어느 재질이 얼마나 보이나.
- *
- * 부품 발자국을 격자에 찍되 **높은 것이 이긴다.** 축에 정렬된 상자만 다루므로
- * 이것으로 충분하다 — 회전한 부품은 발자국을 크게 잡아 보수적으로 본다.
- */
-function topViewRegions(source: FigureSource) {
-  const GRID = 64
-  const cells = new Array<string | null>(GRID * GRID).fill(null)
-  const height = new Float32Array(GRID * GRID)
-
-  // 톱뷰의 두 축은 x 와 z 다. y 는 높이라 위에서 보면 보이지 않는다.
-  // 원점은 기준 상자의 중심이므로 격자의 가운데가 0 이다.
-  const sx = GRID / source.base.x
-  const sz = GRID / source.base.z
-
-  for (const part of source.parts) {
-    const { position, size } = part.transform
-    const top = position.y + size.y / 2
-    const key = materialKeyOf(part)
-
-    const x0 = Math.max(0, Math.floor((position.x - size.x / 2 + source.base.x / 2) * sx))
-    const x1 = Math.min(GRID, Math.ceil((position.x + size.x / 2 + source.base.x / 2) * sx))
-    const y0 = Math.max(0, Math.floor((position.z - size.z / 2 + source.base.z / 2) * sz))
-    const y1 = Math.min(GRID, Math.ceil((position.z + size.z / 2 + source.base.z / 2) * sz))
-
-    for (let y = y0; y < y1; y++) {
-      for (let x = x0; x < x1; x++) {
-        // 원기둥·구는 발자국 상자를 다 채우지 않는다. 모서리를 깎아 근사한다.
-        if (ROUND_FOOTPRINT.includes(part.primitive)) {
-          const cxp = (x + 0.5 - (x0 + x1) / 2) / ((x1 - x0) / 2 || 1)
-          const cyp = (y + 0.5 - (y0 + y1) / 2) / ((y1 - y0) / 2 || 1)
-          if (cxp * cxp + cyp * cyp > 1) continue
-        }
-        const i = y * GRID + x
-        if (cells[i] === null || top > height[i]) {
-          cells[i] = key
-          height[i] = top
-        }
-      }
-    }
-  }
-
-  const byMaterial = new Map<string, number>()
-  let covered = 0
-  for (const key of cells) {
-    if (key === null) continue
-    covered++
-    byMaterial.set(key, (byMaterial.get(key) ?? 0) + 1)
-  }
-
-  return {
-    byMaterial,
-    total: covered,
-    background: GRID * GRID - covered,
-    footprint: GRID * GRID
-  }
-}
-
-/** 위에서 보면 발자국 상자를 다 채우지 않는 도형. */
-const ROUND_FOOTPRINT: string[] = ['cylinder', 'sphere']

package/client/modeller/new-figure-entry.ts

@@ -1,4 +0,0 @@
-/** A route entry starts a new document; ordinary updates must preserve edits. */
-export function shouldStartNewFigure(changes: Record<string, unknown>, hasFigure: boolean, savedId?: string): boolean {
-  return !hasFigure || !!savedId || changes.active === true || Object.prototype.hasOwnProperty.call(changes, 'resourceId')
-}

package/client/modeller/pose-defaults.ts

@@ -1,67 +0,0 @@
-/*
- * Copyright © HatioLab Inc. All rights reserved.
- */
-
-import type { FigureDraft } from './figure-source.js'
-
-/**
- * 지금 세워 둔 자세를 **기본값으로 앉힌다.**
- *
- * ## 왜 필요한가
- *
- * 관절의 휴지 자세는 값이 0 인 자세다(ADR-0066). 팔이 여섯 마디면 그 자세는 곧게 선 기둥이라,
- * 목록에서도 도면에서도 로봇으로 안 보인다. 로봇다운 자세는 **파라미터의 기본값**이 만든다 —
- * 어깨 -35, 팔꿈치 70 을 적어 두면 아무도 값을 주지 않을 때 그 자세로 선다.
- *
- * 그것을 손으로 적으려면 미리보기에서 막대를 맞춘 뒤 그 수를 읽어 파라미터 칸마다 옮겨야 한다.
- * 여섯 축이면 여섯 번이고, 옮기는 동안 화면의 자세와 적은 수가 갈린다. 여기서 하는 일은 그
- * 옮겨 적기 하나다.
- *
- * ## 무엇을 건드리나
- *
- * **막대를 민 파라미터만** 건드린다. 안 민 것은 이미 제 기본값에 서 있으므로 적을 것이 없다.
- * 값이 지금 기본값과 같으면 그 파라미터는 **그대로 둔다** — 새 객체로 바꾸면 고친 것이 없는데도
- * 「저장 안 됨」이 붙는다. 하나도 안 바뀌면 받은 초안을 그대로 돌려준다.
- */
-
-type Parameter = NonNullable<FigureDraft['parameters']>[number]
-
-/** 지금 이 파라미터가 서는 값. 형식의 `valueOf` 와 같은 순서로 읽는다. */
-function standing(parameter: Parameter): number {
-  return parameter.default ?? parameter.range?.min ?? 0
-}
-
-/** 범위 밖은 끝에서 문다. 막대는 범위 안에서만 움직이지만, 값은 다른 길로도 들어온다. */
-function settled(value: number, parameter: Parameter): number {
-  const range = parameter.range
-  const bound = range ? Math.min(Math.max(value, range.min), range.max) : value
-  return Math.round(bound * 10000) / 10000
-}
-
-/** 무엇이 달라지나 — 이름과 바뀔 값. 비어 있으면 앉힐 것이 없다. */
-export function poseChanges(
-  draft: FigureDraft | undefined,
-  values: Record<string, number>
-): { name: string; from: number; to: number }[] {
-  return (draft?.parameters ?? []).flatMap(parameter => {
-    const given = values[parameter.name]
-    if (given === undefined || !Number.isFinite(given)) return []
-
-    const to = settled(given, parameter)
-    const from = standing(parameter)
-    return to === from ? [] : [{ name: parameter.name, from, to }]
-  })
-}
-
-/** 지금 자세를 기본값으로 앉힌 초안. 앉힐 것이 없으면 **받은 초안 그대로**다. */
-export function poseAsDefaults(draft: FigureDraft, values: Record<string, number>): FigureDraft {
-  const changes = new Map(poseChanges(draft, values).map(change => [change.name, change.to]))
-  if (changes.size === 0) return draft
-
-  return {
-    ...draft,
-    parameters: (draft.parameters ?? []).map(parameter =>
-      changes.has(parameter.name) ? { ...parameter, default: changes.get(parameter.name)! } : parameter
-    )
-  }
-}