@things-factory/figure-ui 10.1.43 → 10.1.45

package/test/joint-edits.test.ts

@@ -1,165 +0,0 @@
-import assert from 'node:assert/strict'
-import { describe, it } from 'node:test'
-
-import { validate } from '@hatiolab/figure-model'
-import type { FigurePart } from '@hatiolab/figure-model'
-
-import { parentChoices, patchJoint, setJointType, jointOf } from '../client/modeller/joint-edits.ts'
-import { fromFigureSource, partToFigure, toFigureSource } from '../client/modeller/figure-source.ts'
-import type { FigureDraft, PartModel } from '../client/modeller/figure-source.ts'
-
-/*
- * Editing joints (ADR-0066). Every result is checked against the format's own validate, so an edit that
- * produces a source the format refuses fails here instead of on save.
- */
-
-const part = (name: string, zPos: number, depth: number, parent?: string): PartModel => ({
-  type: 'figure-part',
-  name,
-  primitive: 'cube',
-  left: 50,
-  top: 50,
-  width: 100,
-  height: 100,
-  zPos,
-  depth,
-  token: 'palette.primary',
-  ...(parent ? { parent } : {})
-})
-
-const PARTS: PartModel[] = [part('base', 0, 100), part('arm', 100, 400, 'base'), part('tip', 500, 100, 'arm')]
-const DRAFT: FigureDraft = { version: 2, figureType: 'ARM', width: 200, height: 200, depth: 600, detailLevel: 'M' }
-
-const figurePart = (draft: FigureDraft, name: string): FigurePart => partToFigure(PARTS.find(p => p.name === name)!, draft)
-const errorsOf = (draft: FigureDraft) => validate(toFigureSource(draft, PARTS)).errors.map(e => `${e.code}@${e.path}`)
-
-describe('joint edits', () => {
-  it('offers as parents every part except itself and what hangs below it', () => {
-    assert.deepEqual(parentChoices(PARTS, 'arm'), ['base'])
-    // arm and tip hang below base, so base has nothing to attach to
-    assert.deepEqual(parentChoices(PARTS, 'base'), [])
-    assert.deepEqual(parentChoices([...PARTS, part('lamp', 0, 10)], 'arm'), ['base', 'lamp'])
-    assert.deepEqual(parentChoices(PARTS, 'tip'), ['base', 'arm'])
-  })
-
-  it('adds a joint where the part meets its parent, with a parameter that drives it', () => {
-    const draft = setJointType(DRAFT, figurePart(DRAFT, 'arm'), 'revolute', figurePart(DRAFT, 'base'))
-    const joint = jointOf(draft, 'arm')!
-    assert.deepEqual(joint, {
-      name: 'arm-joint',
-      child: 'arm',
-      type: 'revolute',
-      origin: { x: 0, y: 100, z: 0 },
-      axis: { x: 0, y: 1, z: 0 },
-      limits: { min: -90, max: 90 }
-    })
-    assert.deepEqual(draft.parameters, [
-      {
-        name: 'arm-joint',
-        range: { unit: 'deg', min: -90, max: 90 },
-        default: 0,
-        clip: { channels: [{ target: 'arm-joint', keys: [{ at: 0, value: -90 }, { at: 1, value: 90 }] }] }
-      }
-    ])
-    assert.deepEqual(errorsOf(draft), [])
-  })
-
-  it('moves a plain driving parameter to millimetres when the joint starts sliding', () => {
-    const turning = setJointType(DRAFT, figurePart(DRAFT, 'arm'), 'revolute')
-    const sliding = setJointType(turning, figurePart(turning, 'arm'), 'prismatic')
-    assert.deepEqual(jointOf(sliding, 'arm')!.limits, { min: 0, max: 500 })
-    assert.deepEqual(sliding.parameters![0]!.range, { unit: 'mm', min: 0, max: 500 })
-    assert.deepEqual(errorsOf(sliding), [])
-  })
-
-  it('drops limits for a continuous joint and still validates', () => {
-    const turning = setJointType(DRAFT, figurePart(DRAFT, 'arm'), 'revolute')
-    const endless = setJointType(turning, figurePart(turning, 'arm'), 'continuous')
-    assert.equal('limits' in jointOf(endless, 'arm')!, false)
-    assert.deepEqual(endless.parameters![0]!.range, { unit: 'deg', min: -360, max: 360 })
-    assert.deepEqual(errorsOf(endless), [])
-  })
-
-  it('moves a plain driving parameter with new limits, and leaves one the author reshaped alone', () => {
-    const turning = setJointType(DRAFT, figurePart(DRAFT, 'arm'), 'revolute')
-    const wider = patchJoint(turning, 'arm-joint', { limits: { min: -120, max: 150 } })
-    assert.deepEqual(wider.parameters![0]!.range, { unit: 'deg', min: -120, max: 150 })
-    assert.deepEqual(errorsOf(wider), [])
-
-    const reshaped: FigureDraft = {
-      ...turning,
-      parameters: [
-        {
-          ...turning.parameters![0]!,
-          clip: { channels: [{ target: 'arm-joint', keys: [{ at: 0, value: 0 }, { at: 0.5, value: 45 }, { at: 1, value: 90 }] }] }
-        }
-      ]
-    }
-    const kept = patchJoint(reshaped, 'arm-joint', { limits: { min: -120, max: 150 } })
-    assert.deepEqual(kept.parameters, reshaped.parameters)
-  })
-
-  it('clearing the joint removes it and every channel that drove it, and nothing else', () => {
-    const turning = setJointType(DRAFT, figurePart(DRAFT, 'arm'), 'revolute')
-    const withClip: FigureDraft = {
-      ...turning,
-      animations: [
-        {
-          name: 'wiggle',
-          channels: [
-            { target: 'arm-joint', keys: [{ at: 0, value: 0 }, { at: 1, value: 30 }] },
-            { target: 'tip', path: 'rotation', keys: [{ at: 0, value: { x: 0, y: 0, z: 0 } }, { at: 1, value: { x: 0, y: 90, z: 0 } }] }
-          ]
-        }
-      ]
-    }
-    const cleared = setJointType(withClip, figurePart(withClip, 'arm'), undefined)
-    assert.equal(cleared.joints, undefined)
-    assert.deepEqual(cleared.parameters, [])
-    assert.deepEqual(cleared.animations![0]!.channels.map(c => c.target), ['tip'])
-    assert.deepEqual(errorsOf(cleared), [])
-  })
-
-  /*
-   * 관절은 두 부품이 **맞닿는 자리**에 선다. 위로 쌓은 부품에서는 아랫면이지만, 옆에 달린
-   * 부품에서는 옆면이다 — 그 구분이 없으면 캐비닛 문의 축이 문 바닥에 생긴다.
-   */
-  describe('새 관절이 서는 자리', () => {
-    const at = (over: Partial<PartModel>): PartModel => ({ ...part('door', 0, 100), ...over })
-
-    it('위에 쌓인 부품은 아랫면에서 만난다', () => {
-      /* arm 은 base(0..100) 위 100..500 이다. 맞닿는 면이 100 이고, 가로로는 둘이 겹치는 가운데다. */
-      const joint = jointOf(setJointType(DRAFT, figurePart(DRAFT, 'arm'), 'revolute', figurePart(DRAFT, 'base')), 'arm')!
-      assert.deepEqual(joint.origin, { x: 0, y: 100, z: 0 })
-    })
-
-    it('옆에 달린 부품은 옆면에서 만난다 — 아랫면이 아니다', () => {
-      /* 문은 몸통(가운데 0, 폭 100)의 오른쪽에 붙어 선다. 축은 문의 왼쪽 면, 높이는 겹치는 가운데. */
-      const body = at({ name: 'body', left: 0, top: 0, width: 100, height: 100, zPos: 0, depth: 400 })
-      const door = at({ name: 'door', left: 100, top: 0, width: 20, height: 100, zPos: 40, depth: 320, parent: 'body' })
-      const parts = [body, door]
-      const draft: FigureDraft = { ...DRAFT, width: 400, height: 400, depth: 400 }
-      const shown = (one: PartModel) => partToFigure(one, draft)
-
-      const joint = jointOf(setJointType(draft, shown(door), 'revolute', shown(body)), 'door')!
-      const half = draft.width / 2
-
-      assert.equal(joint.origin.x, 100 - half, '문의 왼쪽 면에 선다')
-      assert.equal(joint.origin.y, 200, '겹치는 높이(40..360 과 0..400)의 한가운데다')
-      assert.deepEqual(parts.map(one => one.name), ['body', 'door'])
-    })
-
-    it('붙은 부품이 없으면 아랫면이다 — 그때 맞닿는 것은 바닥이다', () => {
-      const joint = jointOf(setJointType(DRAFT, figurePart(DRAFT, 'base'), 'revolute'), 'base')!
-      assert.equal(joint.origin.y, 0)
-    })
-  })
-
-  it('a joint survives opening and saving', () => {
-    const turning = setJointType(DRAFT, figurePart(DRAFT, 'arm'), 'revolute')
-    const saved = toFigureSource(turning, PARTS)
-    const { draft, parts } = fromFigureSource(saved)
-    assert.deepEqual(toFigureSource(draft, parts), saved)
-    assert.equal(saved.parts.find(p => p.name === 'tip')!.parent, 'arm')
-  })
-})

package/test/joint-gizmo.test.ts

@@ -1,174 +0,0 @@
-import assert from 'node:assert/strict'
-import { describe, it } from 'node:test'
-
-import type { FigureJoint } from '@hatiolab/figure-model'
-
-import { axisName, gizmoPart, JOINT_GIZMO } from '../client/modeller/joint-gizmo.ts'
-import type { FigureDraft, PartModel } from '../client/modeller/figure-source.ts'
-
-/*
- * 관절이 도는 자리를 저작면에 그리는 부채꼴.
- *
- * 저작자가 축을 고를 때 보는 것이라, **잘못 그리면 틀린 쪽을 가리킨다** — 아무것도 안 그리는
- * 것보다 나쁘다. 그래서 그릴 수 없는 축은 그리지 않는다.
- */
-
-const DRAFT: FigureDraft = { version: 2, figureType: 'ARM', width: 400, height: 400, depth: 1200, detailLevel: 'M' }
-
-const ARM: PartModel = {
-  type: 'figure-part',
-  name: 'arm',
-  primitive: 'cube',
-  left: 150,
-  top: 150,
-  width: 100,
-  height: 100,
-  zPos: 200,
-  depth: 500,
-  token: 'palette.primary'
-}
-
-const joint = (over: Partial<FigureJoint> = {}): FigureJoint => ({
-  name: 'arm-joint',
-  child: 'arm',
-  type: 'revolute',
-  origin: { x: 0, y: 200, z: 0 },
-  axis: { x: 0, y: 1, z: 0 },
-  limits: { min: -90, max: 90 },
-  ...over
-})
-
-/** 부채꼴 점들이 도는 각. 0 도에서 시작해 어디까지 벌어졌나. */
-function angles(path: { x: number; y: number }[]) {
-  const arc = path.filter(point => Math.hypot(point.x, point.y) > 1)
-  return arc.map(point => Math.round((Math.atan2(point.y, point.x) * 180) / Math.PI))
-}
-
-describe('관절 부채꼴', () => {
-  it('축 벡터를 이름으로 옮긴다', () => {
-    assert.equal(axisName({ x: 0, y: 1, z: 0 }), '+y')
-    assert.equal(axisName({ x: -1, y: 0, z: 0 }), '-x')
-    assert.equal(axisName({ x: 0, y: 0, z: 1 }), '+z')
-  })
-
-  it('비스듬한 축은 이름이 없고, 그리지도 않는다 — 아무 쪽이나 고르면 틀린 쪽을 가리킨다', () => {
-    const slanted = { x: 0.7, y: 0.7, z: 0 }
-    assert.equal(axisName(slanted), undefined)
-    assert.equal(gizmoPart(joint({ axis: slanted }), ARM, DRAFT), undefined)
-  })
-
-  it('가동 범위만큼 벌어지고, 가운데 점이 하나 있다', () => {
-    const part = gizmoPart(joint(), ARM, DRAFT)!
-    const path = part.path!
-
-    assert.equal(part.name, JOINT_GIZMO)
-    assert.deepEqual(path[0], { x: 0, y: 0 }, '부채꼴은 가운데에서 시작한다')
-
-    const turned = angles(path)
-    const span = Math.abs(turned[turned.length - 1]! - turned[0]!)
-    assert.equal(span, 180, '−90 에서 90 까지면 180 도 벌어진다')
-  })
-
-  it('무한 회전은 온전한 원이라 가운데 점이 없다', () => {
-    const part = gizmoPart(joint({ type: 'continuous', limits: undefined }), ARM, DRAFT)!
-    const path = part.path!
-
-    assert.ok(path.every(point => Math.hypot(point.x, point.y) > 1), '가운데 점이 없다')
-    assert.ok(path.length >= 60, '한 바퀴를 6도씩 그린다')
-  })
-
-  it('반지름은 도는 부품의 크기를 따라간다 — 부품보다 작으면 무엇이 도는지 안 읽힌다', () => {
-    const big = gizmoPart(joint(), ARM, DRAFT)!
-    const small = gizmoPart(joint(), { ...ARM, width: 40, height: 40, depth: 40 }, DRAFT)!
-
-    assert.equal(big.width, 2 * Math.round(500 * 0.6))
-    assert.equal(small.width, 2 * 60, '작은 부품에도 눈에 보이는 최소 크기가 있다')
-  })
-
-  it('관절의 기준점에 선다', () => {
-    const part = gizmoPart(joint({ origin: { x: 50, y: 300, z: -20 } }), ARM, DRAFT)!
-    /* 저작면은 왼쪽 위 기준이고 z 는 밑면이다. 기준점이 가운데로 가야 맞다. */
-    assert.equal(part.left + part.width / 2, DRAFT.width / 2 + 50)
-    assert.equal(part.top + part.height / 2, DRAFT.height / 2 - 20)
-    assert.equal(part.zPos + part.depth / 2, 300)
-  })
-
-  it('저작면에만 있고, 씬이 집지 않는다', () => {
-    const part = gizmoPart(joint(), ARM, DRAFT)!
-    assert.equal(part.locked, true)
-    assert.equal(part.transparent, true)
-  })
-
-  /*
-   * 가리키는 쪽이 맞나 — **이것이 이 부채꼴의 전부다.**
-   *
-   * 반대로 벌어진 부채꼴은 없느니만 못하다. 저작자가 그것을 보고 축을 고르기 때문이다. 축마다
-   * 씬의 회전과 단면의 각이 도는 쪽이 갈려서, 여섯 축을 하나씩 런타임이 도는 식(로드리게스)과
-   * 맞대 본다.
-   */
-  describe('벌어진 쪽이 실제로 도는 쪽과 같다', () => {
-    const AXES: [string, { x: number; y: number; z: number }][] = [
-      ['+x', { x: 1, y: 0, z: 0 }],
-      ['-x', { x: -1, y: 0, z: 0 }],
-      ['+y', { x: 0, y: 1, z: 0 }],
-      ['-y', { x: 0, y: -1, z: 0 }],
-      ['+z', { x: 0, y: 0, z: 1 }],
-      ['-z', { x: 0, y: 0, z: -1 }]
-    ]
-
-    /** 로드리게스 — 런타임이 관절을 돌리는 식(`setFromAxisAngle`)과 같은 회전이다. */
-    function turned(v: { x: number; y: number; z: number }, axis: { x: number; y: number; z: number }, degrees: number) {
-      const t = (degrees * Math.PI) / 180
-      const c = Math.cos(t)
-      const s = Math.sin(t)
-      const dot = axis.x * v.x + axis.y * v.y + axis.z * v.z
-      const cross = {
-        x: axis.y * v.z - axis.z * v.y,
-        y: axis.z * v.x - axis.x * v.z,
-        z: axis.x * v.y - axis.y * v.x
-      }
-      return {
-        x: v.x * c + cross.x * s + axis.x * dot * (1 - c),
-        y: v.y * c + cross.y * s + axis.y * dot * (1 - c),
-        z: v.z * c + cross.z * s + axis.z * dot * (1 - c)
-      }
-    }
-
-    /** 단면의 점을 부품 회전까지 태워 figure 좌표로. 단면은 부품의 x–z 평면에 눕는다. */
-    function inFigure(part: PartModel, point: { x: number; y: number }) {
-      const v = { x: point.x, y: 0, z: point.y }
-      const rx = part.rotationX ?? 0
-      const rz = part.rotationY ?? 0
-      const afterZ = { x: v.x * Math.cos(rz) - v.y * Math.sin(rz), y: v.x * Math.sin(rz) + v.y * Math.cos(rz), z: v.z }
-      return { x: afterZ.x, y: afterZ.y * Math.cos(rx) - afterZ.z * Math.sin(rx), z: afterZ.y * Math.sin(rx) + afterZ.z * Math.cos(rx) }
-    }
-
-    for (const [name, axis] of AXES) {
-      it(`${name} 축`, () => {
-        const limits = { min: -90, max: 90 }
-        const part = gizmoPart(joint({ axis, limits }), ARM, DRAFT)!
-        /* 가운데 점 하나에 호가 이어진다. 한 바퀴가 아니면 늘 그렇다. */
-        const arc = part.path!.slice(1)
-        const at = (degrees: number) =>
-          inFigure(part, arc[Math.round(((degrees - limits.min) / (limits.max - limits.min)) * (arc.length - 1))]!)
-
-        /* 조각이 6 도씩이라 48 도가 점 하나에 정확히 떨어진다 — 사이 값을 쓰면 반올림이 섞인다. */
-        const zero = at(0)
-        const swung = at(48)
-        const runtime = turned(zero, axis, 48)
-        const flipped = turned(zero, axis, -48)
-
-        const off = Math.hypot(swung.x - runtime.x, swung.y - runtime.y, swung.z - runtime.z)
-        const offFlipped = Math.hypot(swung.x - flipped.x, swung.y - flipped.y, swung.z - flipped.z)
-
-        assert.ok(off < 0.5, `${name}: 부채꼴이 ${off.toFixed(1)}mm 어긋난다 — 반대로 재면 ${offFlipped.toFixed(1)}mm`)
-      })
-    }
-  })
-
-  it('수평축 관절은 눕는다 — 도는 평면이 세로다', () => {
-    const part = gizmoPart(joint({ axis: { x: 1, y: 0, z: 0 } }), ARM, DRAFT)!
-    /* 씬은 라디안을 쓴다. z 90 도가 `rotationY` 로 간다(`figure-source.ts`). */
-    assert.equal(Math.round(((part.rotationY ?? 0) * 180) / Math.PI), 90)
-  })
-})

package/test/joint-needle.test.ts

@@ -1,162 +0,0 @@
-import assert from 'node:assert/strict'
-import { describe, it } from 'node:test'
-
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-
-import { compile, validate } from '@hatiolab/figure-model'
-import type { FigureSource } from '@hatiolab/figure-model'
-
-import { jointNeedles, NEEDLE } from '../client/modeller/joint-gizmo.ts'
-
-/*
- * 미리보기에서 관절이 돌았다는 것을 보이게 하는 바늘.
- *
- * 이 시험이 지키는 것은 하나다 — **축에서 비켜나 있을 것.** 축 위에 붙으면 대칭인 부품과 같이
- * 돌면서 같은 그림이 되고, 그러면 바늘을 붙인 뜻이 없어진다. 없는 것보다 나쁘다: 화면에 무엇이
- * 하나 더 생겼는데 여전히 아무것도 안 움직인다.
- */
-
-const source = (over: Partial<FigureSource> = {}): FigureSource => ({
-  version: 2,
-  type: 'ARM',
-  base: { x: 400, y: 1200, z: 400 },
-  placement: 'floor',
-  detailLevel: 'M',
-  parts: [
-    {
-      name: 'post',
-      primitive: 'cylinder',
-      transform: { position: { x: 0, y: 100, z: 0 }, size: { x: 200, y: 200, z: 200 } },
-      material: { token: 'palette.dark' }
-    },
-    {
-      name: 'arm',
-      primitive: 'cylinder',
-      transform: { position: { x: 0, y: 400, z: 0 }, size: { x: 120, y: 400, z: 120 } },
-      material: { token: 'palette.primary' },
-      parent: 'post'
-    }
-  ],
-  joints: [
-    {
-      name: 'turn',
-      child: 'arm',
-      type: 'revolute',
-      origin: { x: 0, y: 200, z: 0 },
-      axis: { x: 0, y: 1, z: 0 },
-      limits: { min: -90, max: 90 }
-    }
-  ],
-  ...over
-})
-
-describe('관절 바늘', () => {
-  it('관절이 모는 부품에 자식으로 붙는다 — 그래야 관절이 도는 만큼 같이 돈다', () => {
-    const [needle] = jointNeedles(source())
-
-    assert.equal(needle!.parent, 'arm')
-    assert.equal(needle!.name, `${NEEDLE}turn`)
-  })
-
-  it('축에서 비켜나 선다 — 축 위에 있으면 대칭인 부품과 같은 그림이다', () => {
-    const [needle] = jointNeedles(source())
-    const { position, size } = needle!.transform
-
-    /* y 축으로 도는 관절: 바늘은 x 로 비켜나고 x 로 길다. */
-    assert.ok(position.x > 0, '축에서 비켜났다')
-    assert.equal(position.y, 200, '기준점 높이 그대로')
-    assert.ok(size.x > size.y && size.x > size.z, 'x 로 길다')
-  })
-
-  it('가로축으로 도는 관절은 z 로 비켜난다', () => {
-    const [needle] = jointNeedles(source({ joints: [{ ...source().joints![0]!, axis: { x: 1, y: 0, z: 0 } }] }))
-    const { position, size } = needle!.transform
-
-    assert.ok(position.z > 0)
-    assert.ok(size.z > size.x && size.z > size.y)
-  })
-
-  it('세로축(z)으로 도는 관절은 x 로 비켜난다', () => {
-    const [needle] = jointNeedles(source({ joints: [{ ...source().joints![0]!, axis: { x: 0, y: 0, z: 1 } }] }))
-    assert.ok(needle!.transform.position.x > 0)
-  })
-
-  it('비스듬한 축은 그리지 않는다 — 비켜날 쪽을 못 고른다', () => {
-    const oblique = source({ joints: [{ ...source().joints![0]!, axis: { x: 1, y: 1, z: 0 } }] })
-    assert.deepEqual(jointNeedles(oblique), [])
-  })
-
-  it('길이는 도는 부품에서 온다. 작은 부품에서도 보일 만큼은 된다', () => {
-    const [big] = jointNeedles(source())
-    assert.equal(big!.transform.size.x, Math.round(400 * 0.6))
-
-    const small = source({
-      parts: source().parts.map(part =>
-        part.name === 'arm'
-          ? { ...part, transform: { ...part.transform, size: { x: 10, y: 10, z: 10 } } }
-          : part
-      )
-    })
-    assert.equal(jointNeedles(small)[0]!.transform.size.x, 60)
-  })
-
-  it('굵기는 길이에 견준다 — 8mm 로 고정했더니 미리보기에서 한 픽셀이 안 됐다', () => {
-    const [needle] = jointNeedles(source())
-    const { size } = needle!.transform
-
-    /* 길이 240 짜리 막대는 48 로 두껍다. 부품이 작아도 6 밑으로는 안 내려간다. */
-    assert.equal(size.y, Math.round(size.x / 5))
-    assert.equal(size.z, size.y)
-
-    const small = source({
-      parts: source().parts.map(part =>
-        part.name === 'arm' ? { ...part, transform: { ...part.transform, size: { x: 10, y: 10, z: 10 } } } : part
-      )
-    })
-    assert.equal(jointNeedles(small)[0]!.transform.size.y, Math.max(6, Math.round(60 / 5)))
-  })
-
-  it('관절이 없으면 바늘도 없다', () => {
-    assert.deepEqual(jointNeedles(source({ joints: [] })), [])
-    assert.deepEqual(jointNeedles(source({ joints: undefined })), [])
-  })
-
-  it('바늘을 붙인 형식이 그대로 선다 — 미리보기가 이것을 compile 한다', () => {
-    const shown: FigureSource = { ...source(), parts: [...source().parts, ...jointNeedles(source())] }
-
-    assert.deepEqual(validate(shown).errors, [])
-    assert.doesNotThrow(() => compile(shown))
-  })
-})
-
-/*
- * 바늘은 **미리보기에만** 있다. 저장 형식으로 새어 나가면 발행된 도형에 없던 막대가 생기고,
- * 계약 판정에서는 부품이 하나 늘어난 것으로 읽힌다.
- */
-describe('바늘이 미리보기 밖으로 안 나간다', () => {
-  const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
-
-  it('미리보기가 붙여서 세운다', () => {
-    const preview = read('../client/modeller/figure-preview.ts')
-
-    assert.ok(/jointNeedles\(source\)/.test(preview), '붙인다')
-    assert.ok(/registerFigure\(compile\(shown\)/.test(preview), '붙인 것을 세운다')
-  })
-
-  it('저작면과 저장은 원본 그대로다', () => {
-    const page = read('../client/pages/figure-modeller-page.ts')
-    const canvas = read('../client/modeller/figure-canvas.ts')
-
-    assert.ok(!/jointNeedles/.test(page), '페이지는 바늘을 모른다')
-    assert.ok(!/jointNeedles/.test(canvas), '저작 캔버스는 바늘을 모른다')
-  })
-
-  it('원본 목록을 건드리지 않는다 — 같은 배열에 밀어 넣으면 저장에 들어간다', () => {
-    const original = source()
-    const before = original.parts.length
-    jointNeedles(original)
-
-    assert.equal(original.parts.length, before)
-  })
-})

package/test/modeller-undo-redo.test.ts

@@ -1,33 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { test } from 'node:test'
-import { fileURLToPath } from 'node:url'
-
-test('상단 별도 헤더를 없애고 모드 툴바(div[modes])에 저장 및 실행 취소/다시 실행을 배치한다', () => {
-  const path = fileURLToPath(new URL('../client/pages/figure-modeller-page.ts', import.meta.url))
-  const source = readFileSync(path, 'utf8')
-
-  // 상단 <div header> 제거 검증
-  assert.equal(source.includes('<div header>'), false)
-  assert.equal(source.includes('button ai-support'), false)
-
-  // 모드 툴바(div[modes])에 실행 취소(undo), 다시 실행(redo) 버튼 배치 및 편집 모드 조건 검증
-  assert.match(source, /this\.mode === 'edit' && !this\.proposalSession/)
-  assert.match(source, /button\s+history[\s\S]*figure\.button\.undo[\s\S]*this\.undo\(\)/)
-  assert.match(source, /button\s+history[\s\S]*figure\.button\.redo[\s\S]*this\.redo\(\)/)
-
-  // 저장 버튼 및 미저장 표시(dirty)가 모드 툴바에 위치하는지 검증
-  assert.match(source, /<div modes>[\s\S]*button save[\s\S]*this\.save\(\)[\s\S]*<\/div>/)
-  assert.match(source, /<div modes>[\s\S]*span dirty[\s\S]*figure\.text\.unsaved-changes[\s\S]*<\/div>/)
-
-  // 실행 취소/다시 실행 메서드 및 상태 검증
-  assert.match(source, /private undoStack:/)
-  assert.match(source, /private redoStack:/)
-  assert.match(source, /private undo\(\)/)
-  assert.match(source, /private redo\(\)/)
-  assert.match(source, /private recordHistory\(/)
-
-  // 키보드 단축키(Cmd/Ctrl+Z, Cmd+Shift+Z / Ctrl+Y) 핸들러 검증
-  assert.match(source, /handleKeyDown = \(e: KeyboardEvent\)/)
-  assert.match(source, /e\.key === 'z' && !e\.shiftKey[\s\S]*this\.undo\(\)/)
-})

package/test/new-figure-entry.test.ts

@@ -1,15 +0,0 @@
-import assert from 'node:assert/strict'
-import { test } from 'node:test'
-import { shouldStartNewFigure } from '../client/modeller/new-figure-entry.ts'
-
-test('entering new Figure replaces a previous unsaved draft', () => {
-  assert.equal(shouldStartNewFigure({ active: true }, true, ''), true)
-})
-test('removing resource ID replaces a saved model', () => {
-  assert.equal(shouldStartNewFigure({ resourceId: undefined }, true, 'saved'), true)
-})
-test('first entry starts empty but ordinary updates retain current work', () => {
-  assert.equal(shouldStartNewFigure({}, false), true)
-  assert.equal(shouldStartNewFigure({}, true, ''), false)
-  assert.equal(shouldStartNewFigure({ query: {} }, true, ''), false)
-})

package/test/pose-defaults.test.ts

@@ -1,71 +0,0 @@
-import assert from 'node:assert/strict'
-import { describe, it } from 'node:test'
-
-import { poseAsDefaults, poseChanges } from '../client/modeller/pose-defaults.ts'
-import type { FigureDraft } from '../client/modeller/figure-source.ts'
-
-/*
- * 미리보기에서 세운 자세를 기본값으로 앉힌다.
- *
- * 관절 도형의 휴지 자세(값 0)는 곧게 선 기둥이라, 기본값이 없으면 목록에서도 도면에서도 그
- * 모양으로 선다. 옮겨 적는 일을 손으로 하면 여섯 축에 여섯 번이고, 옮기는 사이 화면의 자세와
- * 적은 수가 갈린다.
- */
-
-const DRAFT: FigureDraft = {
-  version: 2,
-  figureType: 'ARM',
-  width: 900,
-  height: 900,
-  depth: 1900,
-  detailLevel: 'L',
-  parameters: [
-    { name: 'shoulder', range: { unit: 'deg', min: -120, max: 120 }, default: 0, clip: { channels: [] } },
-    { name: 'elbow', range: { unit: 'deg', min: -150, max: 150 }, default: 0, clip: { channels: [] } },
-    /* 기본값을 안 적은 파라미터. 형식은 그때 범위의 처음에 선다. */
-    { name: 'hoist', range: { unit: 'mm', min: 0, max: 1800 }, clip: { channels: [] } }
-  ]
-}
-
-describe('이 자세를 기본으로', () => {
-  it('민 것만 앉히고 나머지는 건드리지 않는다', () => {
-    const next = poseAsDefaults(DRAFT, { shoulder: -35 })
-
-    assert.equal(next.parameters![0]!.default, -35)
-    assert.equal(next.parameters![1], DRAFT.parameters![1], '안 민 파라미터는 같은 객체 그대로다')
-    assert.equal(next.parameters![2], DRAFT.parameters![2])
-  })
-
-  it('이미 그 값이면 초안을 그대로 돌려준다 — 고친 것이 없는데 「저장 안 됨」이 붙지 않게', () => {
-    assert.equal(poseAsDefaults(DRAFT, { shoulder: 0 }), DRAFT)
-    assert.equal(poseAsDefaults(DRAFT, {}), DRAFT)
-    /* 기본값을 안 적은 파라미터는 범위의 처음에 서 있다. 그 값을 다시 적지 않는다. */
-    assert.equal(poseAsDefaults(DRAFT, { hoist: 0 }), DRAFT)
-  })
-
-  it('기본값을 안 적었던 파라미터에도 앉는다', () => {
-    const next = poseAsDefaults(DRAFT, { hoist: 1200 })
-    assert.equal(next.parameters![2]!.default, 1200)
-  })
-
-  it('범위 밖은 끝에서 문다 — 다른 길로 들어온 값도 형식을 지나야 한다', () => {
-    const next = poseAsDefaults(DRAFT, { elbow: 400 })
-    assert.equal(next.parameters![1]!.default, 150)
-  })
-
-  it('수가 아닌 값은 안 말한 것으로 친다', () => {
-    for (const bad of [NaN, Infinity, undefined as unknown as number]) {
-      assert.equal(poseAsDefaults(DRAFT, { shoulder: bad }), DRAFT, String(bad))
-    }
-  })
-
-  it('무엇이 달라지는지 먼저 말할 수 있다 — 단추를 띄울지 이것으로 정한다', () => {
-    assert.deepEqual(poseChanges(DRAFT, { shoulder: -35, elbow: 0 }), [{ name: 'shoulder', from: 0, to: -35 }])
-    assert.deepEqual(poseChanges(DRAFT, { shoulder: 0 }), [])
-    assert.deepEqual(poseChanges(undefined, { shoulder: -35 }), [])
-  })
-
-  it('없는 파라미터 이름은 무시한다 — 후보를 보다 남은 값이 섞여도 초안을 늘리지 않는다', () => {
-    assert.equal(poseAsDefaults(DRAFT, { 'no-such-thing': 42 }), DRAFT)
-  })
-})

package/test/preview-board-depth.test.ts

@@ -1,27 +0,0 @@
-import assert from 'node:assert/strict'
-import { describe, it } from 'node:test'
-
-import { previewBoardDepth } from '../client/modeller/figure-view.ts'
-
-describe('preview board depth', () => {
-  it('a floor figure gets room for its tallest instance, not the ceiling', () => {
-    // AGV: base 460 tall, shown up to twice. The board was 4400 and the camera aimed at 2200.
-    assert.equal(previewBoardDepth({ placement: 'floor', base: { y: 460 } }, 4000, 2), 1012)
-  })
-
-  it('a figure with no placement stands on the floor', () => {
-    assert.equal(previewBoardDepth({ base: { y: 460 } }, 4000, 2), 1012)
-  })
-
-  it('a center figure has no default height, so it stands on the floor too', () => {
-    assert.equal(previewBoardDepth({ placement: 'center', base: { y: 460 } }, 4000, 2), 1012)
-  })
-
-  it('a ceiling figure gets room up to the ceiling it hangs from', () => {
-    assert.equal(previewBoardDepth({ placement: 'ceiling', base: { y: 460 } }, 4000, 2), 4400)
-  })
-
-  it('a ceiling figure taller than the ceiling still fits', () => {
-    assert.equal(previewBoardDepth({ placement: 'ceiling', base: { y: 2500 } }, 4000, 2), 5500)
-  })
-})