@things-factory/figure-ui 10.1.147 → 10.1.149

package/test/links.test.ts

@@ -69,7 +69,8 @@ test('움직임 — 미끄러짐 · 돌기, 축, 무엇이 모느냐를 읽는
 
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
-import { choiceOf } from '../client/modeller/links.ts'
+import { alignRowsOf, choiceOf, followCommandOf, ownFacesOf } from '../client/modeller/links.ts'
+import { faceViewOf } from '../client/modeller/fasten-geometry.ts'
 import { moving } from './joints.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
@@ -81,20 +82,6 @@ test('고르개의 값은 지금 따르는 것을 가리킨다', () => {
   assert.equal(choiceOf({ of: 'part', part: 'plate', axis: 'x' }), 'part:plate:x')
 })
 
-test('편집기는 세 칸의 명령을 세션의 이력 하나로 돌리고, 만날 수 있는 거절을 사람의 말로 한다', () => {
-  const editor = read('../client/modeller/editor.ts')
-  assert.match(editor, /@command=\$\{\(e: CustomEvent\) => this\.linkCommand\(e\.detail\.action\)\}/)
-  assert.match(editor, /this\.session!\.command\(action\)/)
-  assert.match(editor, /code === 'DIMENSION_CYCLE'[\s\S]*?figure\.text\.follow-would-loop/)
-  assert.match(editor, /code === 'ATTACH_CYCLE'[\s\S]*?figure\.text\.fasten-would-loop/)
-})
-
-test('떼면 지금 크기로 고정한다 — 따르던 값을 잃지 않는다', () => {
-  const links = read('../client/modeller/figure-links.ts')
-  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(this.revision!, this.partId, axis) ?? boxOf(this.revision!, this.partId)?.dims[AXES.indexOf(axis)] ?? 100'))
-})
-
 test('세 칸의 말은 다섯 말 모두에 있다', () => {
   const links = read('../client/modeller/figure-links.ts')
   const keys = [...links.matchAll(/'(figure\.[a-z.-]*[a-z])'/g)].map(m => m[1])
@@ -142,19 +129,9 @@ test('담는 능력이 없는 도형은 자리가 있어도 보드가 아무것
   asset.document.capabilities.names = ['FlowNode']
   assert.equal(holdsThings(asset), true, 'FlowNode 는 Capacity 를 품는다')
 
-  const links = read('../client/modeller/figure-links.ts')
-  assert.match(links, /holdsThings\(asset\)/)
-  assert.match(links, /kind: 'set-capabilities', names/)
-  const editor = read('../client/modeller/editor.ts')
-  /* A slice and `includes`, not a lazy regex over the whole editor: that hangs when it does not match. */
-  const start = editor.indexOf('<figure-links')
-  const block = editor.slice(start, editor.indexOf('</figure-links>', start))
-  assert.ok(start >= 0 && block.includes('@part-edit=${(e: CustomEvent) => this.run(() => this.session!.edit(e.detail.edit))}'), '자리 절의 능력 선언이 편집기에 닿는다')
 })
 
 test('받는 종류가 없으면 자리를 만들지 않는다 — 형식에 「아무거나」가 없다', () => {
-  const links = read('../client/modeller/figure-links.ts')
-  assert.match(links, /\?disabled=\$\{this\.locked \|\| !accepts\.length \|\| !capacityOk\}/)
   assert.deepEqual(acceptsOf(' , ,'), [])
 })
 
@@ -201,10 +178,32 @@ test('자리를 크기에 비례로 두면 그렇게 읽고, 다시 권하지
   asset = applyFigureAuthoring(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-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('떼면 지금 크기로 고정한다 — 따르던 값을 잃지 않는다', () => {
+  let asset = sizedPair()
+  /* The flange's radius made a fifth of the figure's height: 20 mm now, its width 40. */
+  asset = applyFigureAuthoring(asset, { kind: 'link-dimension', part: 'flange', axis: 'x', source: { of: 'instance', axis: 'y' }, times: 0.2 })
+  const unlink = (a: FigureAsset, part: string, axis: 'x' | 'y') => followCommandOf(revisionOf(a), part, axis, 'own', followOf(a, part, axis))
+  assert.deepEqual(unlink(asset, 'flange', 'x'), { kind: 'unlink-dimension', part: 'flange', axis: 'x', mm: 20 }, 'fixed at its own measure, the radius -- not the 40 it is drawn wide')
+  /* A measure under a millimetre is fixed at one: the kernel takes no size of zero. */
+  const thin = applyFigureAuthoring(asset, { kind: 'link-dimension', part: 'base', axis: 'y', source: { of: 'instance', axis: 'y' }, times: 0.004 })
+  assert.deepEqual(unlink(thin, 'base', 'y'), { kind: 'unlink-dimension', part: 'base', axis: 'y', mm: 1 })
+  assert.equal(unlink(asset, 'base', 'x'), undefined, 'a measure that follows nothing has nothing to let go of')
+  const fixed = applyFigureAuthoring(asset, unlink(asset, 'flange', 'x')!)
+  assert.equal(dimensionNow(revisionOf(fixed), 'flange', 'x'), 20, 'let go, it keeps its size')
+})
+
+test('made to follow in proportion, a measure is the share of the figure size it is now, to a millionth, and keeps its size', () => {
+  const asset = sizedPair()
+  asset.designInputs['size.y'] = 700
+  const share = followCommandOf(revisionOf(asset), 'flange', 'y', 'share:y', followOf(asset, 'flange', 'y'))
+  assert.deepEqual(share, { kind: 'link-dimension', part: 'flange', axis: 'y', source: { of: 'instance', axis: 'y' }, times: 0.014286, replace: false }, 'a length of 10 is 0.014286 of a height of 700')
+  assert.equal(followCommandOf(revisionOf(asset), 'flange', 'y', 'share:x', followOf(asset, 'flange', 'y')), undefined, 'no share of a size the figure does not declare')
+  const linked = applyFigureAuthoring(asset, share!)
+  assert.equal(Math.round(dimensionNow(revisionOf(linked), 'flange', 'y')! * 1000) / 1000, 10, 'following, the length is what it was')
+  /* Following already, the next rule replaces it; another part's measure is named as it is. */
+  assert.deepEqual(followCommandOf(revisionOf(linked), 'flange', 'y', 'part:base:x', followOf(linked, 'flange', 'y')), { kind: 'link-dimension', part: 'flange', axis: 'y', source: { of: 'part', part: 'base', axis: 'x' }, replace: true })
 })
 
 test('놓일 수 있는 크기 — 남은 만큼 채우던 부품을 비례로 바꾸면 다시 재어 넓힌다', () => {
@@ -223,8 +222,6 @@ test('놓일 수 있는 크기 — 남은 만큼 채우던 부품을 비례로
   assert.equal(rangeDiffers(range.declared, range.measured), true)
   asset = applyFigureAuthoring(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/editor.ts')
-  assert.ok(editor.includes("this.linkCommand({ kind: 'declare-instance-size', range: range.measured, replace: true })"))
 })
 
 test('놓일 수 있는 크기 — 저작자가 끝을 적어 좁힌다(갠트리, 09-25)', () => {
@@ -241,9 +238,6 @@ test('놓일 수 있는 크기 — 저작자가 끝을 적어 좁힌다(갠트
   asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: next, replace: true })
   assert.deepEqual(instanceRangeOf(asset)!.declared.x, { min: 150, max: 20000 })
   assert.throws(() => applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: rangeWith(next, 'x', 'min', 300)!, replace: true }), (e: { code?: string }) => e.code === 'INSTANCE_SIZE_RANGE', '저작한 크기(200)를 벗어나면 거절')
-  const editor = read('../client/modeller/editor.ts')
-  assert.ok(editor.includes("const next = rangeWith(range.declared, axis, bound, (e.target as HTMLInputElement).valueAsNumber)"))
-  assert.ok(editor.includes("if (next) this.linkCommand({ kind: 'declare-instance-size', range: next, replace: true })"))
 })
 
 test('한 비율로 커지는 도형 — 자기 숫자인 길이를 세고, 한 번에 따라가게 하며, 무엇이 남는지 이름을 댄다(아키텍트 판정 09-25)', () => {
@@ -261,9 +255,6 @@ test('한 비율로 커지는 도형 — 자기 숫자인 길이를 세고, 한
   asset = applyFigureAuthoring(asset, { kind: 'follow-size-in-proportion' })
   assert.deepEqual(proportionToFollow(asset), { count: 0, kept: ['lamp.motion'] }, '다 따르고, mm 로 움직이는 것만 남는다')
   assert.equal(Math.round(valueNow(revisionOf(asset), 'lamp.dimension.x.value')! * 1e6) / 1e6, 60, '따르게 해도 지금 크기는 그대로')
-  const editor = read('../client/modeller/editor.ts')
-  assert.ok(editor.includes("this.linkCommand({ kind: 'follow-size-in-proportion' })"))
-  assert.ok(editor.includes("?? valueNow(shown, layout?.args[4])"), '길이를 따르는 간격도 숫자로 보인다')
 })
 
 test('관절이 있는 도형에는 한 비율로 키우기를 권하고, 선언하면 규칙으로 보인다(수석 아키텍트 판정 09-24)', () => {
@@ -271,11 +262,6 @@ test('관절이 있는 도형에는 한 비율로 키우기를 권하고, 선언
   assert.equal(turnsAboutAJoint(asset), false)
   asset = moving(asset, 'flange', { kind: 'turn', axis: 'y', id: 'flange.turn', min: 0, max: 90 })
   assert.equal(turnsAboutAJoint(asset), true)
-  const editor = read('../client/modeller/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' })"), '누르면 선언한다 — 사람이 정한다')
 })
 
 
@@ -304,6 +290,20 @@ test('붙일 때 면 위 어디에 — 그 면을 가로지르는 두 축만,
   assert.deepEqual(leaf.pose.t.map(Math.round), [500, 1000, 55], '문짝 아래가 문틀 아래에, 앞이 문틀 앞에')
 })
 
+test('the fastening form asks across the face in rows only where the drawing cannot set it: no drawing, a field followed, a share of the figure size (2026-10-02)', () => {
+  let asset = createFigureAsset('Door')
+  asset = addFigureBox(asset, { id: 'jamb', size: { x: 100, y: 2100, z: 150 }, position: { x: 0, y: 1050, z: 0 } })
+  asset = addFigureBox(asset, { id: 'leaf', size: { x: 900, y: 2000, z: 40 }, position: { x: 600, y: 1000, z: 0 } })
+  const right = { part: 'jamb', face: 'right' }
+  const view = faceViewOf(revisionOf(asset), 'leaf', right)
+  assert.deepEqual(view?.axes, ['y', 'z'])
+  assert.deepEqual(alignRowsOf(asset, 'leaf', right, view, false), [], 'the drawing sets both')
+  assert.deepEqual(alignRowsOf(asset, 'leaf', right, undefined, false), [{ axis: 'y', edges: true }, { axis: 'z', edges: true }], 'with no drawing, both are asked')
+  assert.deepEqual(alignRowsOf(asset, 'leaf', right, view, false, { y: 'leaf.position.y' }), [{ axis: 'y', edges: true }], 'the axis that follows a position field')
+  const sized = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: { x: { min: 100, max: 5000 }, y: { min: 100, max: 5000 }, z: { min: 10, max: 500 } }, at: { x: 1000, y: 2100, z: 150 } })
+  assert.deepEqual(alignRowsOf(sized, 'leaf', right, faceViewOf(revisionOf(sized), 'leaf', right), true).map(r => r.axis), ['y', 'z'], 'the axes a share of the figure size may set')
+})
+
 test('붙여도 제자리 — 폼은 지금 서 있는 자리를 가운데서 거리로 채운다 (문짝이 문틀 앞 100 mm 에서 가운데로 옮겨졌다, 09-26)', async () => {
   const { alignOf, placeKeptOf } = await import('../client/modeller/links.ts')
   const { compileFigureAsset } = await import('@hatiolab/figure-model')
@@ -331,14 +331,6 @@ test('붙여도 제자리 — 폼은 지금 서 있는 자리를 가운데서
   row = applyFigureAuthoring(row, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'plate', face: 'top' } })
   row = applyFigureAuthoring(row, { kind: 'attach', part: 'cap', face: 'bottom', to: { part: 'roller', face: 'top' } })
   assert.deepEqual([hangsFrom(row, 'roller', 'plate'), hangsFrom(row, 'cap', 'plate'), hangsFrom(row, 'plate', 'roller')], [true, true, false])
-  const form = read('../client/modeller/figure-links.ts')
-  /* The target (a part or the plane, user 2026-10-01) and its face: the form is filled in whenever either changes. */
-  assert.ok(form.includes("this.aimAt(asset, value === PLANE ? { ...f, toPlane: true, target: '' } : { ...f, toPlane: false, target: value })"), '상대를 바꿀 때마다')
-  assert.ok(form.includes("this.aimAt(asset, { ...f, targetFace: c.targetFace as FigureFace })"), '상대 면을 바꿀 때마다')
-  assert.ok(!form.includes("figure.label.stands-on-plane"), '부품 붙이기 폼에 모델 설치 기준을 섞지 않는다')
-  /* Kept in the list, not choosable, with the reason (ADR-0097 §5.5). */
-  assert.ok(form.includes('const loops = (one: string) => hangsFrom(asset, one, this.partId)'))
-  assert.ok(form.includes("html`<option value=${one} disabled>${i18next.t('figure.text.target-would-loop'"))
 })
 
 test('따라 움직이는 관절 — 같은 방식으로 움직이고 제 조작값이 있는 관절만 고르고, 기록에는 배율과 더하기만 (집게 두 손가락, 09-25)', async () => {
@@ -563,8 +555,10 @@ test('벽 배치 — 장착 평면은 Z = 0, 등으로 붙이고 가로질러 X
   a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: (await import('@hatiolab/figure-model')).proposeFigureOccupancy(a), placement: 'wall' as never })
   assert.deepEqual(mountingPlaneOf(a), { normal: 'z', faces: ['back'] })
   assert.deepEqual(alignAxesOf(a, 'plate', 'plane').map(x => x.axis), ['x', 'y'])
-  const form = read('../client/modeller/figure-links.ts')
-  assert.ok(form.includes('(!f.toPlane || plane.faces.includes(face as FigureFace))'), '평면에 붙일 때는 평면이 받는 면만')
+  assert.deepEqual(ownFacesOf(a, 'plate', true), ['back'], 'on the plane, only the face the plane takes')
+  assert.deepEqual(ownFacesOf(a, 'plate', false), ['left', 'right', 'bottom', 'top', 'back', 'front', 'centre'], 'to a part, its six outer faces and its centre')
+  const floor = addFigureBox(createFigureAsset('Floor'), { id: 'plate', size: { x: 200, y: 300, z: 20 }, position: { x: 0, y: 0, z: 0 } })
+  assert.deepEqual(ownFacesOf(floor, 'plate', true), ['bottom', 'top'], 'on the floor, its bottom or its top')
 })
 
 test('부품 칸의 두 제목이 같은 말이 아니다 — 자리 숫자는 「위치와 크기」, 붙이기 칸은 「붙이기」 (09-26)', () => {
@@ -593,10 +587,6 @@ test('보이는 때 — 명령이 남긴 것을 읽고, 폼은 그 명령을 낸
   const shown = editFigurePart(asset, { kind: 'set-visibility', target: 'lamp', shownWhen: { input: 'gate-open', atLeast: 9 } })
   assert.deepEqual(shownWhenOf(shown, 'lamp'), { input: 'gate-open', atLeast: 9 })
   assert.equal(shownWhenOf(editFigurePart(shown, { kind: 'set-visibility', target: 'lamp', shownWhen: null }), 'lamp'), null)
-  const form = read('../client/modeller/figure-links.ts')
-  const section = form.slice(form.indexOf('  private renderShown('), form.indexOf('  private renderMotion('))
-  assert.ok(section.includes("kind: 'set-visibility'"), '폼은 그 명령을 낸다')
-  assert.ok(form.includes('${this.renderShown(asset)}'), '움직임 칸에')
 })
 
 /* 문틀은 폭 · 높이 · 깊이로 — 상자처럼 크기를 따르고, 손잡이로 키운다 (figure-model 의 portal 단면, 09-26 · ADR-0100). */
@@ -614,14 +604,6 @@ test('팔레트의 문틀은 문 크기로 서고, 세 축 모두 크기를 따
 
 /* 크기를 따라감 한 번 — 치수 칸의 단추 하나, 크기를 대신 정했으면 한 줄로 말한다 (ADR 판정 Q1, 09-26). */
 test('치수 칸 — 「도형 크기를 따라감」 단추는 follow-size 한 번, 다 따르면 사라진다; 크기를 대신 정하면 한 줄', () => {
-  const form = read('../client/modeller/figure-links.ts')
-  /* The whole method: the resize-with-placement block above the advanced settings made it longer than a fixed slice. */
-  const dims = form.slice(form.indexOf('  private renderDimensions('), form.indexOf('  /** The same source, the same share'))
-  assert.ok(dims.includes("this.command({ kind: 'follow-size', part: this.partId })"))
-  assert.ok(dims.includes("followOf(asset, this.partId, axis).of === 'instance'"), '다 따르면 단추가 없다')
-  const editor = read('../client/modeller/editor.ts')
-  assert.ok(editor.includes("if (action.kind === 'follow-size' && !hadSize)"), '크기를 대신 정했을 때만')
-  assert.ok(editor.includes("notify({ level: 'info', message: this.notice })"), '그 한 줄은 앱의 알림으로')
   const ko = JSON.parse(read('../translations/ko.json'))
   assert.match(ko['figure.text.size-declared-to-follow'], /\{x\} × \{y\} × \{z\} mm/)
 })
@@ -658,9 +640,8 @@ test('붙이기 칸은 부품 제 붙임으로 열린다 — 가운데로 붙은
   const bed = fasteningOf(revisionOf(asset), 'bed')!
   assert.deepEqual([bed.face, bed.toPlane], ['bottom', true])
   assert.equal(fasteningOf(revisionOf(addFigureBox(createFigureAsset('Loose'), { id: 'b', size: { x: 1, y: 1, z: 1 }, position: { x: 0, y: 0, z: 0 } })), 'b'), null, '안 붙은 부품은 기본값으로')
-  const panel = readFileSync(fileURLToPath(new URL('../client/modeller/figure-links.ts', import.meta.url)), 'utf8')
-  assert.ok(panel.includes('fasteningOf(this.revision, this.partId)'), '부품을 고르면 제 붙임으로 연다')
-  assert.ok(panel.includes("...(f.toPlane ? [] : (['centre'] as const))"), '내 면에 가운데가 있다')
+  assert.equal(ownFacesOf(asset, 'roller', false).at(-1), 'centre', 'its own faces include its centre')
+  assert.ok(!ownFacesOf(asset, 'roller', true).includes('centre'), 'on the floor, by a face only')
 })
 
 test('a follower of several leaders and a stroke that is a sum of lengths are written back unchanged by the motion form (ADR-0107)', async () => {

package/test/live.test.ts

@@ -4,8 +4,6 @@
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
 
 import { addFigureBox, applyFigureAuthoring, compileFigureAsset, createFigureAsset } from '@hatiolab/figure-model'
 
@@ -13,8 +11,6 @@ import { liveOverridesOf, liveOverSession, livePartsOf, NOTHING_LIVE, scrubbed,
 import { moving } from './joints.ts'
 import { revisionOf } from './revision-of.ts'
 
-const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
-
 const slider = () => {
   let asset = createFigureAsset('Slider')
   asset = addFigureBox(asset, { id: 'block', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
@@ -69,36 +65,6 @@ test('이름표를 끌면 값이 크기에 맞는 걸음으로 움직인다 —
   assert.equal(scrubbed(0.4, 3, 0.01), 0.43, '0.43000000000000005 가 아니다')
 })
 
-test('속성창 숫자 칸은 치는 동안 알리고, 이름표를 끌 수 있다 — 기록은 change 에서', () => {
-  const editor = read('../client/modeller/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 ['@state-live=', '@states-live=', '@part-live=']) assert.ok(editor.includes(event), event)
-  assert.ok(editor.includes('liveOverSession(shown, this.live)'), '캔버스는 세션 위에 끄는 값을 그린다 (행동은 아래 시험)')
-  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-material-panel.ts')
-  assert.ok(material.includes('@input=${(e: Event) => this.glow(Number((e.target as HTMLInputElement).value), true)}'))
-})
-
-test('슬라이더와 클립 막대는 끄는 동안 알리고, 놓을 때 한 번 기록한다', () => {
-  const controls = read('../client/modeller/figure-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('state-live'"))
-  const clips = read('../client/modeller/figure-clips.ts')
-  assert.ok(clips.includes('@input=${(e: Event) => this.scrub(clip, number(e), true)}'))
-  assert.ok(clips.includes("new CustomEvent('states-live'"))
-})
-
-test('클립 트랙의 머리는 이름 한 줄, 그 아래 반복 방식과 지우기 — 이름이 한 글자씩 쌓이지 않는다', () => {
-  const clips = read('../client/modeller/figure-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;'), '지우기는 작은 버튼')
-})
-
 test('끄는 동안은 세션이 지금 든 자세 위에 그린다 — 다른 관절이 저장된 각도로 돌아가지 않는다', () => {
   /* Two joints: the author turned one with its control; then drags the other. */
   let asset = slider()

package/test/material.test.ts

@@ -6,14 +6,10 @@
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
 
 import { addFigureBox, addFigurePrimitive, compileFigureAsset, createFigureAsset, editFigurePart, figureCostOf } from '@hatiolab/figure-model'
 
-const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
-const material = read('../client/modeller/figure-material-panel.ts')
-const editor = read('../client/modeller/editor.ts')
+import { glowOf, materialEditOf, offeredPaletteOf } from '../client/modeller/material-edit.ts'
 
 const probe = () => {
   let asset = createFigureAsset('Probe')
@@ -41,12 +37,16 @@ test('재질 칸이 보내는 모양 그대로 figure-model 이 받고, 그려
 })
 
 test('발광 세기 0 은 발광을 없앤다 — 빈 칸을 남기지 않는다(형식이 undefined 칸을 거절한다)', () => {
-  assert.match(material, /emissive: intensity > 0 \? \{[^}]*\} : undefined/)
-  assert.match(material, /if \(material\[key\] === undefined\) delete material\[key\]/)
+  const glowing = { token: 'palette.primary', transparent: true, emissive: { token: 'palette.accent', intensity: 0.5, on: true } }
+  const palette = { 'palette.primary': '#477b9e', 'palette.accent': '#f28c28' }
+  const off = materialEditOf('body', glowing, { ...glowOf(glowing, 0), transparent: undefined }, palette, palette) as { material: Record<string, unknown> }
+  assert.deepEqual(off.material, { token: 'palette.primary' }, 'no glow and no empty field left')
+  assert.equal(drawn(editFigurePart(probe(), off as never), 'body').material.emissive, undefined, 'figure-model takes it')
+  assert.deepEqual(glowOf({ token: 'palette.primary' }, 0.4), { emissive: { token: 'palette.primary', intensity: 0.4, on: true } }, 'a new glow takes the part\'s own colour')
+  assert.equal((glowOf(glowing, 0.4).emissive as { token: string }).token, 'palette.accent', 'a glow keeps the colour picked for it')
 })
 
 test('곡면 분할은 둥근 몸체에만 내고, 고르면 삼각형 수가 그만큼 바뀐다', async () => {
-  assert.match(material, /if \(!isRoundBody\(/, 'the panel asks the one rule')
   const { isRoundBody } = await import('../client/modeller/starting-shape.ts')
   const { boxShape, discShape } = await import('../client/modeller/drawn-shapes.ts')
   assert.equal(isRoundBody(discShape(50, 10) as never), true, 'a circle pushed is round')
@@ -57,23 +57,14 @@ test('곡면 분할은 둥근 몸체에만 내고, 고르면 삼각형 수가
   assert.ok(fine > coarse, `48 분할이 8 분할보다 삼각형이 많다 (${coarse} → ${fine})`)
 })
 
-test('색 역할은 날것의 이름이 아니라 쓰임새로 부른다', () => {
-  assert.match(material, /title=\$\{purposeOf\(token\)\}/)
-  assert.doesNotMatch(editor, /token === 'palette\.primary' \? '기본 몸체' : token/, '옛 날것 이름 고르개가 남아 있다')
-})
-
-test('편집기는 재질 칸의 편집을 세션의 이력 하나로 돌린다', () => {
-  assert.match(editor, /<figure-material-panel[\s\S]*?@part-edit=\$\{\(e: CustomEvent\) => this\.run\(\(\) => this\.session!\.edit\(e\.detail\.edit\)\)\}/)
-})
-
 test('자산에 없는 색 역할은 그 색을 함께 보낸다 — 새 도형의 팔레트는 기본색 하나다', () => {
-  assert.match(material, /return \{ \.\.\.\(activePalette\(\) as Record<string, string>\), \.\.\.this\.palette \}/, '앱 팔레트를 보인다')
-  assert.match(material, /this\.palette\[token\] === undefined && offered\[token\] !== undefined/)
-  assert.match(material, /\.\.\.\(Object\.keys\(palette\)\.length \? \{ palette \} : \{\}\)/)
-})
-
-test('분할 수 — 흔한 넷은 다각형 윤곽과 삼각형 수로, 나머지는 접어 둔다', () => {
-  const source = readFileSync(fileURLToPath(new URL('../client/modeller/figure-material-panel.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)'))
+  const asset = probe()
+  const offered = offeredPaletteOf({ 'palette.primary': '#000000', 'palette.accent': '#f28c28', 'palette.dark': '#2b2b2b' }, asset.palette)
+  assert.equal(offered['palette.primary'], asset.palette['palette.primary'], '자산의 색이 앱의 색 위에 선다')
+  assert.equal(offered['palette.accent'], '#f28c28', '앱 팔레트를 보인다')
+  const accent = materialEditOf('body', { token: 'palette.primary' }, { token: 'palette.accent', emissive: { token: 'palette.dark', intensity: 0.5, on: true } }, asset.palette, offered) as { palette?: Record<string, string> }
+  assert.deepEqual(accent.palette, { 'palette.accent': '#f28c28', 'palette.dark': '#2b2b2b' }, '몸체 색과 발광 색 모두')
+  assert.equal(drawn(editFigurePart(asset, accent as never), 'body').material.token, 'palette.accent', 'figure-model 이 받는다')
+  const own = materialEditOf('body', { token: 'palette.accent' }, { token: 'palette.primary' }, asset.palette, offered)
+  assert.equal('palette' in own, false, '자산에 있는 색이면 보낼 것이 없다')
 })

package/test/maturity.test.ts

@@ -19,6 +19,7 @@ import {
   curveLayout,
   decadeSteps,
   GRADE_SCALE,
+  gradeBoundsOf,
   gradeOf,
   FIGURE_BUDGET_KEYS,
   figureReportOf
@@ -204,14 +205,17 @@ test('추이 — 1 에서 1만까지 1·2·5, 삼각형과 draw call 은 오르
   assert.deepEqual(layout.xTicks.map(t => t.label), ['1', '10', '100', '1k', '10k'])
 })
 
-test('화면은 리포트의 차례로 그린다 — 개수 · 축 · 한도 · 그리는 비용 · 추이 · 발행 판정', () => {
-  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('눈금은 등급을 셈한 경계에서 그린다 — 따로 적으면 어긋난다', () => {
+  /* The order of the tab's sections, and that it draws this scale, are the browser check's (test/browser/screen.check.mjs). */
+  const bounds = gradeBoundsOf()
+  assert.deepEqual(bounds.map(([grade]) => grade), ['A', 'B', 'C', 'D'])
+  for (const [grade, said] of bounds.slice(0, -1)) {
+    const bound = Number(/^≤ ([\d.]+)%$/.exec(said)![1]) / 100
+    assert.equal(gradeOf(bound), grade, `${grade} ${said}: 경계에서는 그 등급`)
+    assert.notEqual(gradeOf(bound + 0.001), grade, `${grade} ${said}: 경계를 넘으면 다음 등급`)
+  }
+  assert.deepEqual(bounds.at(-1), ['D', '> 100%'])
+  assert.equal(gradeOf(1.001), 'D')
 })
 
 test('radar 와 추이 그림의 조각은 svg 템플릿이다 — html 로 만들면 소리 없이 안 그려진다', () => {
@@ -252,12 +256,5 @@ test('부품 목록 머리의 값 한 줄 — 삼각형 · 묶음 · 한 화면
   const over = budgetOf(figureReportOf(glass))!
   assert.equal(over.grade, 'D')
   assert.deepEqual(over.tightest, { key: 'transparent', used: 2, limit: 1 })
-
-  const parts = read('../client/modeller/figure-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/editor.ts')
-  assert.ok(editor.includes('.budget=${this.budget}') && editor.includes("@show-maturity=${() => (this.tab = 'verdict')}"))
-  assert.ok(verdict.includes('budget: budgetOf(report)'), '성숙도 탭이 같은 보고서에서 알린다')
+  /* The line drawn in the parts list, and its click to the verdict tab, are the browser check's (test/browser/screen.check.mjs). */
 })

package/test/mesh-import.test.ts

@@ -0,0 +1,76 @@
+/*
+ * A GLB made into a mesh part (ADR-0129): the whole file or one node of it, at 1:1, standing where it stood in the file,
+ * with what the server read of it. The kernel side (mesh@1) is tested in figure-model; the server's reading in
+ * figure-service (figure-glb, figure-mesh-db).
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+import { meshChoicesOf, meshPartIdOf, meshPartOf, type MeshUpload } from '../client/modeller/mesh-import.js'
+
+const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
+const HASH = 'c'.repeat(64)
+const box = (x0: number, y0: number, z0: number, x1: number, y1: number, z1: number) => ({ min: { x: x0, y: y0, z: z0 }, max: { x: x1, y: y1, z: z1 } })
+
+/* A crane: a 6 m girder, a hoist hung 1 m along it and turned a quarter, a marker with no mesh, a sheared node. */
+const upload: MeshUpload = {
+  hash: HASH,
+  summary: {
+    bounds: box(-3000, -800, -400, 3000, 200, 400),
+    triangles: 5000,
+    primitives: 4,
+    unit: 'm',
+    nodes: [
+      { index: 0, name: 'Girder', parent: null, bounds: box(-3000, -800, -400, 3000, 200, 400), triangles: 5000, primitives: 4, position: { x: 0, y: 0, z: 0 }, rotation: { x: 0, y: 0, z: 0 } },
+      { index: 1, name: 'Hoist Unit #2', parent: 0, bounds: box(-200, -300, -150, 200, 0, 150), triangles: 1200, primitives: 2, position: { x: 1000, y: -500, z: 0 }, rotation: { x: 0, y: 90, z: 0 } },
+      { index: 2, name: 'marker', parent: 0, bounds: null, triangles: 0, primitives: 0, position: { x: 0, y: 0, z: 0 }, rotation: { x: 0, y: 0, z: 0 }, refused: 'no-mesh' },
+      { index: 3, name: 'skewed', parent: 0, bounds: null, triangles: 10, primitives: 1, position: { x: 0, y: 0, z: 0 }, rotation: { x: 0, y: 0, z: 0 }, refused: 'sheared' }
+    ]
+  }
+}
+
+test('the whole file first, then each node that can be a part; no marker, nothing sheared', () => {
+  assert.deepEqual(meshChoicesOf(upload), [
+    { name: '', triangles: 5000 },
+    { node: 0, name: 'Girder', triangles: 5000 },
+    { node: 1, name: 'Hoist Unit #2', triangles: 1200 }
+  ])
+})
+
+test('the whole file: at 1:1 along its longest axis, at the origin, with the file named by its hash', () => {
+  const part = meshPartOf(upload, {}, 'crane') as any
+  assert.equal(part.kind, 'mesh')
+  assert.deepEqual(part.dimensions, { size: 6000 })
+  assert.deepEqual(part.mesh, { asset: HASH, format: 'glb', unit: 'm', bounds: upload.summary.bounds, triangles: 5000, primitives: 4 })
+  assert.deepEqual(part.position, { x: 0, y: 0, z: 0 })
+  assert.equal(part.rotation, undefined)
+})
+
+test('a node: its own bounds and counts, standing and turned where the file had it', () => {
+  const part = meshPartOf(upload, { node: 1 }, 'hoist') as any
+  assert.deepEqual(part.dimensions, { size: 400 })
+  assert.equal(part.mesh.node, 1)
+  assert.deepEqual(part.mesh.bounds, box(-200, -300, -150, 200, 0, 150))
+  assert.equal(part.mesh.triangles, 1200)
+  assert.deepEqual(part.position, { x: 1000, y: -500, z: 0 })
+  assert.deepEqual(part.rotation, { x: 0, y: 90, z: 0 })
+  assert.throws(() => meshPartOf(upload, { node: 3 }, 'x'), 'a node that cannot be a part is not made one')
+})
+
+test("a part's id from a node's name: letter-led and clean, another number when taken", () => {
+  assert.equal(meshPartIdOf('Hoist Unit #2', new Set()), 'Hoist-Unit-2')
+  assert.equal(meshPartIdOf('2nd beam', new Set()), 'nd-beam')
+  assert.equal(meshPartIdOf('###', new Set()), 'mesh')
+  assert.equal(meshPartIdOf('hoist', new Set(['hoist', 'hoist-2'])), 'hoist-3')
+})
+
+/* The screen itself -- the palette's button, the upload, the question, the step added -- is driven in browser/places-mesh.check.mjs. */
+test('the mesh words are in every language', () => {
+  for (const lang of ['en', 'es', 'ja', 'ko', 'ms', 'zh']) {
+    const t = JSON.parse(read(`../translations/${lang}.json`))
+    for (const key of ['figure.button.import-mesh', 'figure.text.import-mesh-hint', 'figure.text.mesh-whole-file', 'figure.text.mesh-triangles', 'figure.title.choose-mesh-part'])
+      assert.ok(t[key], `${lang} ${key}`)
+  }
+})

package/test/modeller-route.test.ts

@@ -16,33 +16,17 @@ test('every figure and a new one open the one modeller', () => {
 })
 
 test('one modeller page at one address: the route and the shell table agree', () => {
+  /* The shell's router runs route.ts; this suite has no router to drive it with, so the import is read as it is written. */
   const route = read('../client/route.ts')
-  assert.equal(route.match(/case 'figure-modeller':/g)?.length, 1)
   assert.match(route, /import\('\.\/pages\/figure-modeller-page'\)/)
   const config = read('../things-factory.config.js')
   assert.equal(config.match(/tagname: 'figure-modeller-page', page: 'figure-modeller'/g)?.length, 1)
 })
 
 test('the catalogue opens details first; editing is an explicit action in the detail dock', () => {
+  /* The catalogue page (its grid and the shell) is not driven here; the dock's edit button is, in product-page.check.mjs. */
   const list = read('../client/pages/figure-list-page.ts')
   assert.match(list, /openFigureDetail\(record\)/)
-  const detail = read('../client/viewparts/figure-detail-dock.ts')
-  assert.match(detail, /navigate\(modellerPathOf\(saved\)\)/)
 })
 
-test('reloading or closing the tab with unsaved work asks first — the shell does not ask canDeactivate then (09-26)', () => {
-  const page = read('../client/pages/figure-modeller-page.ts')
-  const hold = page.slice(page.indexOf('private holdUnsaved'), page.indexOf('connectedCallback()'))
-  assert.match(hold, /session\.read\(\)\.dirty/, 'only when there is something unsaved')
-  assert.match(hold, /event\.preventDefault\(\)/)
-  assert.match(page, /addEventListener\('beforeunload', this\.holdUnsaved\)/)
-  assert.match(page, /removeEventListener\('beforeunload', this\.holdUnsaved\)/)
-})
-
-test('기존 도형을 열면 rail 은 카탈로그를 가리킨다 — 「새 Figure」를 가리키지 않는다(2026-10-03)', async () => {
-  const { readFileSync } = await import('node:fs')
-  const page = readFileSync(new URL('../client/pages/figure-modeller-page.ts', import.meta.url), 'utf8')
-  const context = page.slice(page.indexOf('get context()'), page.indexOf('render()', page.indexOf('get context()')))
-  /* The rail's rule (@operato/menu menu-active.ts): a page that names its menu wins over a menu with the same page name. */
-  assert.ok(context.includes("menu: view.id ? 'figure-list' : undefined"), 'id 가 있으면 카탈로그, 새 도형이면 이름을 대지 않는다')
-})
+/* Reloading with unsaved work, and the rail on an opened figure, are checked on the page: test/browser/product-page.check.mjs. */

package/test/package-download.test.ts

@@ -3,14 +3,13 @@
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
 
-const panel = readFileSync(new URL('../client/modeller/figure-history-panel.ts', import.meta.url), 'utf8')
+import { packageHrefOf } from '../client/modeller/modeller-route.ts'
 
+/* The history panel draws the link from this for each released version (product-page.check.mjs reads it there). */
 test('each released version links to the package door by its full reference, only once the figure has a full name', () => {
-  const href = panel.slice(panel.indexOf('private packageHref'), panel.indexOf('private renderVersion'))
-  assert.match(href, /if \(!this\.figureNamespace \|\| !this\.figureType\) return undefined/)
-  assert.match(href, /`\$\{contextPath\}\/figure-package\?refs=\$\{encodeURIComponent\(`\$\{this\.figureNamespace\}\/\$\{this\.figureType\}@\$\{version\}`\)\}`/)
-  const row = panel.slice(panel.indexOf('private renderVersion'), panel.indexOf('private renderKept'))
-  assert.match(row, /<a package download href=/)
+  assert.equal(packageHrefOf('/domain/x', 'acme', 'agv', 3), '/domain/x/figure-package?refs=acme%2Fagv%403')
+  assert.equal(packageHrefOf('', 'acme', 'roller-conveyor', 12), '/figure-package?refs=acme%2Froller-conveyor%4012')
+  assert.equal(packageHrefOf('/domain/x', undefined, 'agv', 3), undefined, 'no namespace yet')
+  assert.equal(packageHrefOf('/domain/x', 'acme', null, 3), undefined, 'no type yet')
 })