@things-factory/figure-ui 10.1.146 → 10.1.149

package/test/refusals.test.ts

@@ -1,159 +1,135 @@
 /*
- * 크기 범위 거절을 사람의 말로 (사용자 2026-09-24: 「what is this warning message means?」 — 커널의 영어 원문이 떴다).
+ * A refused command said in the author's words (user 2026-09-24: 「what is this warning message means?」 -- the kernel's
+ * English was on the screen). Every refusal here is a real one from figure-model, and the words are made from its code
+ * and details (ADR-0127): the kernel's English is never read, so a sentence the kernel changes cannot silence the screen
+ * (2026-10-11: three INSTANCE_SIZE_RANGE sentences showed only 「이 편집은 할 수 없습니다」).
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
+import { readdirSync, readFileSync, statSync } from 'node:fs'
+import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
-import { sizeRangeRefusalOf } from '../client/modeller/refusals.ts'
+import * as fm from '@hatiolab/figure-model'
+import type { FigureAsset } from '@hatiolab/figure-model'
+import {
+  editRefusalOf,
+  inDeclaredRoom,
+  inputRangeRefusalOf,
+  narrowingRetryOf,
+  partNameRefusalOf,
+  partRefusalOf,
+  placedRefusalOf,
+  placementRefusalOf,
+  recipeRefusalOf,
+  removalNoticeOf,
+  repeatPitchRefusalOf,
+  sizeRangeRefusalOf
+} from '../client/modeller/refusals.ts'
 
 const ko = JSON.parse(readFileSync(fileURLToPath(new URL('../translations/ko.json', import.meta.url)), 'utf8'))
-const say = (key: string, params: Record<string, string>) => ko[key].replace(/\{(\w+)\}/g, (_: string, k: string) => params[k] ?? '')
-const refusal = (message: string) => Object.assign(new Error(message), { code: 'INSTANCE_SIZE_RANGE' })
+const say = (key: string, params: Record<string, string>) => {
+  assert.ok(key in ko, `no words for ${key}`)
+  return ko[key].replace(/\{(\w+)\}/g, (_: string, k: string) => params[k] ?? '')
+}
+/** The key and its values, to see which words were chosen. */
+const keyed = (key: string, p: Record<string, string>) => `${key} ${JSON.stringify(p)}`
 
-test('화성 트레이의 거절 — 축 · 숫자 · 부품 · 고치는 곳', () => {
-  const said = sizeRangeRefusalOf(refusal('INSTANCE_SIZE_RANGE: size.x: below 8.82353 mm a length goes to zero (cell); declare the smallest size at 8.82353 mm or more'), say)!
-  assert.ok(said.includes('X 축을') && said.includes('8.8 mm') && said.includes('cell 부품') && said.includes('다시 재기'), said)
-  assert.ok(!/declare|below/.test(said))
-})
-
-test('위쪽 끝도, 부품 이름이 없어도', () => {
-  const said = sizeRangeRefusalOf(refusal('INSTANCE_SIZE_RANGE: size.y: above 15000 mm the figure cannot be drawn; declare the largest size at 15000 mm or less'), say)!
-  assert.ok(said.includes('Y 축을') && said.includes('15,000 mm'), said)
-})
-
-/*
- * 범위가 지금 크기를 담지 않는 거절도 숫자와 함께 (Figure 레인 인계, 2026-10-11: 400 mm 상자에 가장 작은 크기 500 을
- * 넣으면 「이 편집은 할 수 없습니다. (INSTANCE_SIZE_RANGE)」만 떴다 — 이 문장은 below/above 꼴이 아니라 읽히지 않았다).
- */
-test('범위가 지금 크기를 담지 않으면 축 · 지금 크기 · 범위를 말한다', () => {
-  const said = sizeRangeRefusalOf(refusal('INSTANCE_SIZE_RANGE: size.x: the authored size 400 mm must lie within 500…4000 mm'), say)!
-  assert.ok(said.includes('X') && said.includes('400 mm') && said.includes('500') && said.includes('4,000'), said)
-  assert.ok(!/authored|lie within/.test(said), said)
-})
-
-test('가장 작은 크기가 0 이하이면 그렇게 말한다', () => {
-  const said = sizeRangeRefusalOf(refusal('INSTANCE_SIZE_RANGE: size.z: the smallest size must be above zero; got 0'), say)!
-  assert.ok(said.includes('Z') && said.includes('0 보다'), said)
-  assert.ok(!/smallest|above zero/.test(said), said)
-})
-
-test('지금 크기에서 이미 길이가 없는 부품이 있으면 그렇게 말한다', () => {
-  const said = sizeRangeRefusalOf(refusal('INSTANCE_SIZE_RANGE: size.y: the figure is authored at 120 mm, where a length is already gone; change the link or the size'), say)!
-  assert.ok(said.includes('Y') && said.includes('120 mm'), said)
-  assert.ok(!/authored|already gone/.test(said), said)
-})
-
-test('INSTANCE_SIZE_RANGE 의 문장 넷이 모두 사람의 말이 된다 — 커널이 쓰는 꼴 그대로', async () => {
-  const { addFigureBox, applyFigureAuthoring, createFigureAsset } = await import('@hatiolab/figure-model')
-  const box = addFigureBox(createFigureAsset('Box'), { id: 'box', size: { x: 400, y: 300, z: 200 }, position: { x: 0, y: 150, z: 0 } })
-  const refused = (action: unknown) => {
-    try {
-      applyFigureAuthoring(box, action as never)
-    } catch (e) {
-      return e
-    }
-    assert.fail('the kernel took it')
-  }
-  const range = (x: { min: number; max: number }) => ({ kind: 'declare-instance-size', range: { x, y: { min: 100, max: 3000 }, z: { min: 100, max: 3000 } } })
-  for (const error of [refused(range({ min: 500, max: 4000 })), refused(range({ min: 0, max: 4000 }))]) {
-    assert.equal((error as { code?: string }).code, 'INSTANCE_SIZE_RANGE', String(error))
-    assert.ok(sizeRangeRefusalOf(error, say), `not read: ${(error as Error).message}`)
+const act = (asset: FigureAsset, action: object) => fm.applyFigureAuthoring(asset, action as never)
+function refusalOf(run: () => unknown): unknown {
+  try {
+    run()
+  } catch (e) {
+    assert.ok((e as { code?: string }).code, String(e))
+    return e
   }
-})
+  assert.fail('the kernel took it')
+}
 
-test('다른 거절은 건드리지 않는다', () => {
-  assert.equal(sizeRangeRefusalOf(Object.assign(new Error('x'), { code: 'EDIT_TARGET' }), say), null)
+const box = () => fm.addFigureBox(fm.createFigureAsset('Box'), { id: 'box', size: { x: 400, y: 300, z: 200 }, position: { x: 0, y: 150, z: 0 } })
+function panel(): FigureAsset {
+  const a = fm.addFigureBox(fm.createFigureAsset('Panel'), { id: 'panel', size: { x: 400, y: 400, z: 400 }, position: { x: 0, y: 0, z: 0 } })
+  const range = { min: 1, max: 4000 }
+  return act(a, { kind: 'declare-instance-size', range: { x: range, y: range, z: range }, at: { x: 400, y: 400, z: 400 } })
+}
+const followsWidth = (plus: number, extra: object = {}) => ({ kind: 'link-dimension' as const, part: 'panel', axis: 'x' as const, source: { of: 'instance' as const, axis: 'x' as const }, plus, ...extra })
+const declaring = (x: { min: number; max: number }) => ({ kind: 'declare-instance-size', range: { x, y: { min: 100, max: 3000 }, z: { min: 100, max: 3000 } } })
+function conveyor(): FigureAsset {
+  let a = fm.createFigureAsset('Conveyor')
+  a = fm.addFigureBox(a, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 0, z: 0 } })
+  a = fm.addFigureBox(a, { id: 'roller', size: { x: 60, y: 60, z: 560 }, position: { x: 0, y: 0, z: 0 } })
+  a = act(a, { kind: 'attach', part: 'frame', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = act(a, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  return act(a, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 200 })
+}
+
+test('크기 범위의 거절 다섯 — 축 · 숫자 · 부품을 커널이 넘긴 값으로 말한다', () => {
+  const small = sizeRangeRefusalOf(refusalOf(() => act(panel(), followsWidth(-50))), say)!
+  assert.ok(small.includes('X 축을') && small.includes('50 mm') && small.includes('panel 부품') && small.includes('다시 재기'), small)
+  const large = sizeRangeRefusalOf(refusalOf(() => act(panel(), followsWidth(1000, { times: -1 }))), say)!
+  assert.ok(large.includes('X 축을') && large.includes('1,000 mm') && large.includes('그릴 수 없는데'), large)
+  const outside = sizeRangeRefusalOf(refusalOf(() => act(box(), declaring({ min: 500, max: 4000 }))), say)!
+  assert.ok(outside.includes('X') && outside.includes('400 mm') && outside.includes('500') && outside.includes('4,000'), outside)
+  const zero = sizeRangeRefusalOf(refusalOf(() => act(box(), declaring({ min: 0, max: 4000 }))), say)!
+  assert.ok(zero.includes('X') && zero.includes('0 보다'), zero)
+  const gone = sizeRangeRefusalOf(refusalOf(() => act(panel(), followsWidth(-399.9999995, { narrowRange: true }))), say)!
+  assert.ok(gone.includes('X') && gone.includes('400 mm') && gone.includes('이미 0'), gone)
+  for (const said of [small, large, outside, zero, gone]) assert.doesNotMatch(said, /below|above|declare|authored|INSTANCE_SIZE_RANGE/)
+  assert.equal(sizeRangeRefusalOf(refusalOf(() => act(conveyor(), { kind: 'set-repeat', part: 'frame', pitch: 10 })), say), null, '다른 거절은 건드리지 않는다')
 })
 
-test('범위가 받을 수 없는 연결은 같은 연결을 범위를 좁혀 다시 권한다 — 다시 재기로는 풀리지 않는다 (사이징, 2026-09-25)', async () => {
-  const { narrowingRetryOf } = await import('../client/modeller/refusals.ts')
-  const { addFigureBox, applyFigureAuthoring, createFigureAsset } = await import('@hatiolab/figure-model')
-  let asset = addFigureBox(createFigureAsset('Panel'), { id: 'panel', size: { x: 400, y: 400, z: 400 }, position: { x: 0, y: 0, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: { x: { min: 1, max: 4000 }, y: { min: 1, max: 4000 }, z: { min: 1, max: 4000 } }, at: { x: 400, y: 400, z: 400 } })
-  const link = { kind: 'link-dimension' as const, part: 'panel', axis: 'x' as const, source: { of: 'instance' as const, axis: 'x' as const }, plus: -50 }
-  let error: unknown
-  try {
-    applyFigureAuthoring(asset, link)
-  } catch (e) {
-    error = e
-  }
-  const say = (key: string, p: Record<string, string>) => `${key} ${JSON.stringify(p)}`
-  const offer = narrowingRetryOf(link, error, say)!
+test('범위가 받을 수 없는 연결은 같은 연결을 범위를 좁혀 다시 권한다 — 다시 재기로는 풀리지 않는다 (사이징, 2026-09-25)', () => {
+  const asset = panel()
+  const link = followsWidth(-50)
+  const error = refusalOf(() => act(asset, link))
+  const offer = narrowingRetryOf(link, error, keyed)!
   assert.ok(offer, '권한다')
   assert.match(offer.label, /figure.button.narrow-range-from .*"axis":"X"/)
+  assert.match(offer.message, /link-needs-smaller-range .*"part":"panel"/)
   assert.deepEqual(offer.retry, { ...link, narrowRange: true })
-  assert.doesNotThrow(() => applyFigureAuthoring(asset, offer.retry as never), '권한 것은 받아들여진다')
-  assert.equal(narrowingRetryOf({ kind: 'attach' }, error, say), null, '연결이 아닌 명령에는 권하지 않는다')
+  assert.doesNotThrow(() => act(asset, offer.retry), '권한 것은 받아들여진다')
+  assert.equal(narrowingRetryOf({ kind: 'attach' }, error, keyed), null, '연결이 아닌 명령에는 권하지 않는다')
 })
 
-test('지우기는 매단 것 · 따라 움직이는 것을 풀어 남기고 그 이름을 한 줄로 말한다; 남는 거절은 공간 선언과 줄 (아키텍트 판정 2026-09-27)', async () => {
-  const { partRefusalOf, removalNoticeOf, editRefusalOf } = await import('../client/modeller/refusals.ts')
-  const fm = await import('@hatiolab/figure-model')
-  const say = (key: string, p: Record<string, string>) => `${key} ${JSON.stringify(p)}`
+test('지우기는 매단 것 · 따라 움직이는 것을 풀어 남기고 그 이름을 한 줄로 말한다; 남는 거절은 공간 선언과 줄 (아키텍트 판정 2026-09-27)', () => {
   let a = fm.createFigureAsset('Bench')
   a = fm.addFigureBox(a, { id: 'leg', size: { x: 60, y: 700, z: 60 }, position: { x: 0, y: 0, z: 0 } })
   a = fm.addFigureBox(a, { id: 'top', size: { x: 1200, y: 40, z: 600 }, position: { x: 0, y: 0, z: 0 } })
   a = fm.addFigureBox(a, { id: 'lamp', size: { x: 80, y: 80, z: 80 }, position: { x: 0, y: 0, z: 0 } })
   a = fm.addFigureBox(a, { id: 'shade', size: { x: 40, y: 40, z: 40 }, position: { x: 0, y: 0, z: 0 } })
-  a = fm.applyFigureAuthoring(a, { kind: 'attach', part: 'leg', face: 'bottom', to: { plane: 'mounting-plane' } })
-  a = fm.applyFigureAuthoring(a, { kind: 'attach', part: 'top', face: 'bottom', to: { part: 'leg', face: 'top' } })
-  a = fm.applyFigureAuthoring(a, { kind: 'attach', part: 'lamp', face: 'bottom', to: { part: 'top', face: 'top' }, align: { x: { mm: -300 } } })
-  a = fm.applyFigureAuthoring(a, { kind: 'attach', part: 'shade', face: 'bottom', to: { part: 'top', face: 'top' }, align: { x: { mm: 300 } } })
-  const turn = (asset: typeof a, part: string, extra: object) => fm.applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...asset.joints!.find(j => j.body1.part === part)!, type: 'revolute', axis: 'Y', ...extra } as never })
+  a = act(a, { kind: 'attach', part: 'leg', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = act(a, { kind: 'attach', part: 'top', face: 'bottom', to: { part: 'leg', face: 'top' } })
+  a = act(a, { kind: 'attach', part: 'lamp', face: 'bottom', to: { part: 'top', face: 'top' }, align: { x: { mm: -300 } } })
+  a = act(a, { kind: 'attach', part: 'shade', face: 'bottom', to: { part: 'top', face: 'top' }, align: { x: { mm: 300 } } })
+  const turn = (asset: typeof a, part: string, extra: object) => act(asset, { kind: 'set-joint', joint: { ...asset.joints!.find(j => j.body1.part === part)!, type: 'revolute', axis: 'Y', ...extra } })
   a = turn(a, 'lamp', { state: { id: 'lamp-turn' } })
   a = turn(a, 'shade', { mimic: { joint: 'lamp', multiplier: 1 } })
 
   const top = fm.removePart(a, { kind: 'remove-part', target: 'top' })
-  const told = removalNoticeOf(top.notice, say)!
+  const told = removalNoticeOf(top.notice, keyed)!
   assert.match(told, /removal-released-motion .*"part":"lamp".*"control":"lamp-turn"/, '움직이던 것은 조작값 이름까지')
   assert.match(told, /removal-released .*"parts":"shade"/)
-  const lamp = removalNoticeOf(fm.removePart(a, { kind: 'remove-part', target: 'lamp' }).notice, say)!
+  const lamp = removalNoticeOf(fm.removePart(a, { kind: 'remove-part', target: 'lamp' }).notice, keyed)!
   assert.match(lamp, /removal-own-control .*"part":"shade".*"control":"shade".*"min":"-180".*"max":"180"/, '따르던 것은 제 조작값을 받는다')
-  assert.equal(removalNoticeOf(fm.removePart(a, { kind: 'remove-part', target: 'shade' }).notice, say), null, '아무것도 풀지 않았으면 말하지 않는다')
-
-  const declared = fm.applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'floor' })
-  const why = (asset: typeof a, part: string) => {
-    try {
-      fm.editFigurePart(asset, { kind: 'remove-part', target: part })
-      return 'removed'
-    } catch (e) {
-      return partRefusalOf(e, part, say)
-    }
-  }
-  assert.match(why(declared, 'shade')!, /part-in-declared-space .*"part":"shade"/, '잎인데 공간 선언에 들어 있다')
+  assert.equal(removalNoticeOf(fm.removePart(a, { kind: 'remove-part', target: 'shade' }).notice, keyed), null, '아무것도 풀지 않았으면 말하지 않는다')
 
-  let row = fm.createFigureAsset('Conveyor')
-  row = fm.addFigureBox(row, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 0, z: 0 } })
-  row = fm.addFigureBox(row, { id: 'roller', size: { x: 60, y: 60, z: 560 }, position: { x: 0, y: 0, z: 0 } })
-  row = fm.applyFigureAuthoring(row, { kind: 'attach', part: 'frame', face: 'bottom', to: { plane: 'mounting-plane' } })
-  row = fm.applyFigureAuthoring(row, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'frame', face: 'top' } })
-  row = fm.applyFigureAuthoring(row, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 200 })
-  assert.match(why(row, 'frame')!, /part-row-along .*"part":"frame".*"rows":"roller"/, '줄이 따라 놓인 부품')
-
-  /* A refusal no sentence knows is still said as a refusal, with its code -- never the kernel's English. */
-  const unknown = editRefusalOf(Object.assign(new Error('EDIT_TARGET: x: something in English'), { code: 'EDIT_TARGET' }), say)
-  assert.match(unknown, /^figure\.text\.edit-refused .*"code":"EDIT_TARGET"/)
-  assert.doesNotMatch(unknown, /something in English/)
+  const declared = act(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'floor' })
+  const why = (asset: FigureAsset, part: string) => partRefusalOf(refusalOf(() => fm.editFigurePart(asset, { kind: 'remove-part', target: part })), part, keyed)
+  assert.match(why(declared, 'shade')!, /part-in-declared-space .*"part":"shade"/, '잎인데 공간 선언에 들어 있다')
+  assert.match(why(conveyor(), 'frame')!, /part-row-along .*"part":"frame".*"rows":"roller"/, '줄이 따라 놓인 부품')
+  let hung = fm.addFigureBox(conveyor(), { id: 'cap', size: { x: 20, y: 20, z: 20 }, position: { x: 0, y: 0, z: 0 } })
+  hung = act(hung, { kind: 'attach', part: 'cap', face: 'bottom', to: { part: 'roller', face: 'top' } })
+  assert.match(why(hung, 'roller')!, /part-row-carries .*"part":"roller".*"others":"cap"/, '줄에 매달린 것')
 })
 
-test('공간 선언에 든 부품 — 한 번 눌러 지우고, 공간은 남은 부품에 다시 맞추며 그렇다고 한 줄 말한다(묻지 않는다, 2026-09-27)', async () => {
-  const { inDeclaredRoom } = await import('../client/modeller/refusals.ts')
-  const fm = await import('@hatiolab/figure-model')
+test('공간 선언에 든 부품 — 한 번 눌러 지우고, 공간은 남은 부품에 다시 맞추며 그렇다고 한 줄 말한다(묻지 않는다, 2026-09-27)', () => {
   let a = fm.addFigureBox(fm.createFigureAsset('Gate'), { id: 'housing', size: { x: 300, y: 1000, z: 300 }, position: { x: 0, y: 0, z: 0 } })
   a = fm.addFigureBox(a, { id: 'stray', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
-  a = fm.applyFigureAuthoring(a, { kind: 'attach', part: 'housing', face: 'bottom', to: { plane: 'mounting-plane' } })
-  a = fm.applyFigureAuthoring(a, { kind: 'attach', part: 'stray', face: 'bottom', to: { plane: 'mounting-plane' } })
-  a = fm.applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'floor' })
-  let refused: unknown
-  try {
-    fm.editFigurePart(a, { kind: 'remove-part', target: 'stray' })
-  } catch (e) {
-    refused = e
-  }
-  assert.equal(inDeclaredRoom(refused), true)
-  assert.equal(inDeclaredRoom(Object.assign(new Error('PART_REFERENCED: top: top holds leg; take it off first'), { code: 'PART_REFERENCED' })), false, '매단 것은 이 길이 아니다')
+  a = act(a, { kind: 'attach', part: 'housing', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = act(a, { kind: 'attach', part: 'stray', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = act(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'floor' })
+  assert.equal(inDeclaredRoom(refusalOf(() => fm.editFigurePart(a, { kind: 'remove-part', target: 'stray' }))), true)
+  assert.equal(inDeclaredRoom(refusalOf(() => fm.editFigurePart(conveyor(), { kind: 'remove-part', target: 'frame' }))), false, '줄은 이 길이 아니다')
   const after = fm.editFigurePart(a, { kind: 'remove-part', target: 'stray', refitRoom: true })
   assert.equal(after.document.model.nodes.some(n => n.id === 'stray'), false)
   assert.ok(after.occupancy?.bounds, '공간은 남은 부품으로 다시 선언된다')
@@ -165,45 +141,175 @@ test('공간 선언에 든 부품 — 한 번 눌러 지우고, 공간은 남은
   assert.ok(ko['figure.text.removal-space-refitted'])
 })
 
-test('배치를 바꿀 수 없는 까닭 — 평면에 붙은 부품과 새 평면이 받는 면을 말한다(벽 배치, 09-25)', async () => {
-  const { placementRefusalOf } = await import('../client/modeller/refusals.ts')
-  const fm = await import('@hatiolab/figure-model')
-  let a = fm.addFigureBox(fm.createFigureAsset('Post'), { id: 'post', size: { x: 100, y: 1000, z: 100 }, position: { x: 0, y: 0, z: 0 } })
-  a = fm.applyFigureAuthoring(a, { kind: 'attach', part: 'post', face: 'bottom', to: { plane: 'mounting-plane' } })
-  let refused: unknown
-  try {
-    fm.applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'wall' as never })
-  } catch (e) {
-    refused = e
-  }
+test('배치를 바꿀 수 없는 까닭 — 평면에 붙은 부품과 새 평면이 받는 면을 말한다(벽 배치, 09-25)', () => {
+  const a = act(fm.addFigureBox(fm.createFigureAsset('Post'), { id: 'post', size: { x: 100, y: 1000, z: 100 }, position: { x: 0, y: 0, z: 0 } }), {
+    kind: 'attach',
+    part: 'post',
+    face: 'bottom',
+    to: { plane: 'mounting-plane' }
+  })
+  const refused = refusalOf(() => act(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'wall' }))
   const said = placementRefusalOf(refused, say)!
   assert.ok(said.includes('post (bottom)') && said.includes('벽 기반') && said.includes('back'), said)
-  assert.equal(placementRefusalOf(new Error('x'), say), null)
+  assert.equal(editRefusalOf(refused, say), said, '편집 거절의 말도 같다')
+  assert.equal(placementRefusalOf(refusalOf(() => act(box(), declaring({ min: 0, max: 4000 }))), say), null)
   /* The placement list sends its command through the page, not the editor: the page says it in words too, and the list goes back. */
   const page = readFileSync(fileURLToPath(new URL('../client/pages/figure-modeller-page.ts', import.meta.url)), 'utf8')
-  assert.ok(page.includes('placementRefusalOf(error, (key, params) => i18next.t(key, params))'), '페이지 경로도 사람의 말로')
+  assert.ok(page.includes('editRefusalOf(error, (key, params) => i18next.t(key, params))'), '페이지 경로도 사람의 말로')
   const props = readFileSync(fileURLToPath(new URL('../client/modeller/figure-properties.ts', import.meta.url)), 'utf8')
   assert.ok(props.includes('select.value = current'), '거절되면 목록이 원래 배치로 돌아온다')
 })
 
-test('범위 밖 값은 받을 수 있는 범위를 숫자로 말한다 — 커널의 영어가 아니다 (Figure 레인 :3300, 2026-09-26)', async () => {
-  const { inputRangeRefusalOf } = await import('../client/modeller/refusals.ts')
-  const range = (message: string) => Object.assign(new Error(message), { code: 'INPUT_RANGE' })
-  const size = inputRangeRefusalOf(range('INPUT_RANGE: size.x: 6021100 outside [300,1200]'), say)!
-  assert.ok(size.includes('X') && size.includes('300') && size.includes('1,200') && size.includes('6,021,100'), size)
-  assert.ok(!/outside|INPUT_RANGE/.test(size))
-  const other = inputRangeRefusalOf(range('INPUT_RANGE: lift.stroke: -5 outside [0,1]'), say)!
+test('범위 밖 값은 받을 수 있는 범위를 숫자로 말한다 — 커널의 영어가 아니다 (Figure 레인 :3300, 2026-09-26)', () => {
+  const sized = box()
+  const size = inputRangeRefusalOf(refusalOf(() => fm.compileFigureAsset({ ...sized, designInputs: { ...sized.designInputs, 'size.x': 6021100 } }).evaluate()), say)
+  const lift = act(box(), { kind: 'add-design-input', id: 'lift', unit: 'mm', min: 0, max: 1, value: 0 })
+  const other = inputRangeRefusalOf(refusalOf(() => fm.compileFigureAsset({ ...lift, designInputs: { ...lift.designInputs, lift: -5 } }).evaluate()), say)!
   assert.ok(other.includes('0') && other.includes('1') && other.includes('-5'), other)
-  assert.equal(inputRangeRefusalOf(range('INPUT_RANGE: steps: at the length it is authored (100 mm) a pitch under 1 mm makes more than 50 copies'), say), null)
-  assert.equal(inputRangeRefusalOf(Object.assign(new Error('x'), { code: 'EDIT_TARGET' }), say), null)
+  assert.doesNotMatch(other, /outside|INPUT_RANGE/)
+  /* The figure's size is said by its axis -- when the figure declares one; a box made here declares none. */
+  if (size) assert.ok(size.includes('X') && size.includes('6,021,100'), size)
+  const sizing = act(box(), declaring({ min: 300, max: 1200 }))
+  const axis = inputRangeRefusalOf(refusalOf(() => fm.compileFigureAsset({ ...sizing, designInputs: { ...sizing.designInputs, 'size.x': 6021100 } }).evaluate()), say)!
+  assert.ok(axis.includes('X') && axis.includes('300') && axis.includes('1,200') && axis.includes('6,021,100'), axis)
+  const added = editRefusalOf(refusalOf(() => act(box(), { kind: 'add-design-input', id: 'lift', unit: 'mm', min: 0, max: 10, value: 20 })), say)
+  assert.ok(added.includes('20') && added.includes('10') && !added.includes('INPUT_RANGE'), `입력을 더할 때의 범위 밖 값도 말한다 (전에는 코드만): ${added}`)
+  assert.equal(inputRangeRefusalOf(refusalOf(() => act(box(), declaring({ min: 0, max: 4000 }))), say), null)
+})
+
+test('줄 간격이 너무 좁으면 저작한 길이 · 가장 작은 간격 · 개수 한도를 말한다', () => {
+  /* A row made before rows lived in their fastenings: its pitch is the graph's (a figure saved that way). */
+  const legacy = structuredClone(conveyor())
+  for (const j of legacy.joints!) delete (j as { repeat?: unknown }).repeat
+  const refused = refusalOf(() => act(legacy, { kind: 'set-repeat', part: 'roller', pitch: 1 }))
+  const said = repeatPitchRefusalOf(refused, say)!
+  assert.ok(said.includes('20 mm') && said.includes('2,000 mm') && said.includes('100'), said)
+  assert.equal(editRefusalOf(refused, say), said, '편집 거절의 말도 같다')
+  assert.equal(inputRangeRefusalOf(refused, say), null, '값 범위의 말이 아니다')
+})
+
+test('줄이 한도를 넘으면 몇 개가 되는지와 한도를 말한다 — 코드만 보이지 않는다 (ADR-0127, RESOURCE_LIMIT · 줄 개수)', () => {
+  /* A row made in the modeller, its pitch too fine: 195 copies where a row takes 100. */
+  const fine = editRefusalOf(refusalOf(() => act(conveyor(), { kind: 'set-repeat', part: 'roller', pitch: 10 })), say)
+  assert.ok(fine.includes('195') && fine.includes('100') && !fine.includes('RESOURCE_LIMIT'), fine)
+  /* Copies asked for past what a row has. */
+  let a = fm.createFigureAsset('Conveyor')
+  a = fm.addFigureBox(a, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 0, z: 0 } })
+  a = fm.addFigureBox(a, { id: 'roller', size: { x: 10, y: 60, z: 560 }, position: { x: 0, y: 0, z: 0 } })
+  a = act(a, { kind: 'attach', part: 'frame', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = act(a, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  const many = editRefusalOf(refusalOf(() => act(a, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 12, count: 150 })), say)
+  assert.ok(many.includes('150') && many.includes('1~100') && !many.includes('GEOMETRY_DOMAIN'), many)
+  /* A saved figure whose row would expand past what a figure draws: ten thousand copies, each a roller and its cap. */
+  let capped = fm.addFigureBox(conveyor(), { id: 'cap', size: { x: 20, y: 20, z: 20 }, position: { x: 0, y: 0, z: 0 } })
+  capped = structuredClone(act(capped, { kind: 'attach', part: 'cap', face: 'bottom', to: { part: 'roller', face: 'top' } }))
+  const m = capped.document.model as unknown as { constants: Array<{ id: string; value: number }> }
+  m.constants.find(c => c.id === 'limit.count.100')!.value = 10000
+  m.constants.find(c => c.id === 'd.mm.200')!.value = 0.2
+  const bodies = editRefusalOf(refusalOf(() => fm.compileFigureAsset(capped)), say)
+  assert.ok(bodies.includes('19,402') && bodies.includes('10,000'), bodies)
+})
+
+test('기즈모로 옮길 수 없는 부품 — 관절이 자리를 정하는지, 붙은 면이 정하는지', () => {
+  assert.match(placedRefusalOf(refusalOf(() => act(conveyor(), { kind: 'nudge-part', part: 'roller', by: { x: 10 } })), '롤러', keyed)!, /gizmo-joint-places .*"part":"롤러"/)
+  assert.match(placedRefusalOf(refusalOf(() => act(conveyor(), { kind: 'scale-position', part: 'roller', axis: 'x' })), '롤러', keyed)!, /gizmo-fastening-places .*"part":"롤러"/)
+  assert.equal(placedRefusalOf(refusalOf(() => act(conveyor(), { kind: 'set-repeat', part: 'frame', pitch: 10 })), '프레임', keyed), null, '다른 EDIT_TARGET 은 이 말이 아니다')
+})
+
+test('부품 이름 — 이름 규칙은 커널 한 벌이고, 화면은 거절의 값으로 말한다 (ADR-0127)', () => {
+  const rename = (asset: FigureAsset, target: string, name: string) => refusalOf(() => fm.editFigurePart(asset, { kind: 'rename-part', target, name } as never))
+  assert.match(partNameRefusalOf(rename(conveyor(), 'frame', '1x'), keyed)!, /part-name-invalid .*"name":"1x"/)
+  assert.match(partNameRefusalOf(rename(conveyor(), 'frame', 'roller'), keyed)!, /part-name-taken .*"name":"roller"/)
+  /* An imported figure may name a part under another (`box.lid`): the third refusal is said as itself, not as one of the other two. */
+  const nested = JSON.parse(JSON.stringify(fm.addFigureBox(box(), { id: 'lid', size: { x: 400, y: 10, z: 200 }, position: { x: 0, y: 0, z: 0 } })).replaceAll('"lid', '"box.lid'))
+  const said = partNameRefusalOf(rename(nested, 'box', 'crate'), say)!
+  assert.ok(said.includes('box.lid'), said)
+  const editor = readFileSync(fileURLToPath(new URL('../client/modeller/editor.ts', import.meta.url)), 'utf8')
+  assert.doesNotMatch(editor, /a-zA-Z0-9_-/, '이름 규칙을 화면에 다시 쓰지 않는다')
+})
+
+test('단면 · 속 공간 — 모서리, 벽, 막힌 끝, 붙은 면을 거절의 값으로 말한다', () => {
+  assert.match(editRefusalOf(refusalOf(() => act(box(), { kind: 'set-section-corner', part: 'box', corner: 500 })), keyed), /^figure\.text\.section-corner-too-large/)
+  assert.match(editRefusalOf(refusalOf(() => act(box(), { kind: 'set-cavity', part: 'box', cavity: { wall: 150, start: { closed: 10 }, end: 'open' } })), keyed), /^figure\.text\.section-wall-too-thick/)
+  assert.match(editRefusalOf(refusalOf(() => act(box(), { kind: 'set-cavity', part: 'box', cavity: { wall: 10, start: { closed: 200 }, end: { closed: 200 } } })), keyed), /^figure\.text\.section-ends-too-thick/)
+  let tray = act(box(), { kind: 'set-cavity', part: 'box', cavity: { wall: 10, start: { closed: 15 }, end: 'open' } })
+  tray = fm.addFigureBox(tray, { id: 'divider', size: { x: 10, y: 100, z: 150 }, position: { x: 0, y: 0, z: 0 } })
+  tray = act(tray, { kind: 'attach', part: 'divider', face: 'bottom', to: { part: 'box', face: 'inside-bottom' } })
+  const faces = editRefusalOf(refusalOf(() => act(tray, { kind: 'set-cavity', part: 'box', cavity: { wall: 10, start: 'open', end: 'open' } })), say)
+  assert.ok(faces.includes(ko['figure.label.face-inside-bottom']), faces)
+  /* A section finding the screen has no words for is said with its code. */
+  const wedge = fm.addFigurePrimitive(fm.createFigureAsset('Drawn'), {
+    id: 'wedge',
+    kind: 'polygon',
+    dimensions: { height: 100 },
+    points: [
+      { x: -50, z: -40 },
+      { x: 50, z: -40 },
+      { x: 0, z: 40 }
+    ],
+    position: { x: 0, y: 50, z: 0 }
+  })
+  const crossed = [
+    { id: 'p1', x: -50, z: -40 },
+    { id: 'p2', x: 50, z: 40 },
+    { id: 'p3', x: 50, z: -40 },
+    { id: 'p4', x: -50, z: 40 }
+  ]
+  assert.match(editRefusalOf(refusalOf(() => act(wedge, { kind: 'set-section', part: 'wedge', points: crossed })), keyed), /^figure\.text\.edit-refused .*"code":"SECTION_INVALID"/)
+})
+
+test('도형의 한도 — 노드 수, 저장 크기, 중첩 깊이를 숫자로 말한다 (「노드 한도」로 잘못 말하던 결함)', () => {
+  const doc = structuredClone(box().document) as { model: { nodes: unknown[] } }
+  for (let i = 0; i <= fm.FIGURE_DOCUMENT_NODE_LIMIT; i++) doc.model.nodes.push({ id: `k${i}`, op: 'const@1', args: [], outputs: {} })
+  const nodes = editRefusalOf(refusalOf(() => fm.compileFigureDocument(doc as never)), say)
+  assert.ok(nodes.includes(String(fm.FIGURE_DOCUMENT_NODE_LIMIT)), nodes)
+  const large = editRefusalOf(refusalOf(() => fm.compileFigureAsset({ ...box(), name: 'x'.repeat(fm.FIGURE_JSON_MAX_BYTES) })), say)
+  assert.ok(large.includes('저장 한도 1,024 KiB') && /1,02[5-9] KiB 로/.test(large) && !large.includes('노드'), large)
+  const unmeasured = editRefusalOf(refusalOf(() => fm.parseFigureJson(`"${'a'.repeat(fm.FIGURE_JSON_MAX_BYTES)}"`)), say)
+  assert.ok(unmeasured.includes('1,024 KiB') && !unmeasured.includes('노드'), unmeasured)
+  const deep = editRefusalOf(refusalOf(() => fm.parseFigureJson('['.repeat(70) + ']'.repeat(70))), say)
+  assert.ok(deep.includes('64') && !deep.includes('노드'), deep)
+})
+
+test('레시피가 막히면 몇 번째 단계에서 왜 막혔는지 사람의 말로 — 단계 안의 거절도 값을 잃지 않는다 (2026-09-27)', () => {
+  const refused = refusalOf(() => fm.applyFigureProposal(box(), [{ kind: 'attach', part: 'nowhere', face: 'bottom', to: { plane: 'mounting-plane' } }, declaring({ min: 500, max: 4000 })] as never))
+  assert.match(recipeRefusalOf(refused, keyed)!, /^figure\.text\.recipe-step-refused .*"step":"1"/, '첫째 단계, 코드와 함께')
+  const sized = refusalOf(() => fm.applyFigureProposal(box(), [declaring({ min: 500, max: 4000 })] as never))
+  const told = recipeRefusalOf(sized, say)!
+  assert.ok(told.includes('1 번째') && told.includes('400 mm') && told.includes('4,000'), told)
+  assert.equal(recipeRefusalOf(refusalOf(() => act(box(), declaring({ min: 0, max: 4000 }))), keyed), null, '단계가 아닌 거절은 다른 말이 맡는다')
 })
 
-test('레시피가 막히면 몇 번째 단계에서 왜 막혔는지 사람의 말로 — 커널의 영어가 아니라 (2026-09-27)', async () => {
-  const { recipeRefusalOf } = await import('../client/modeller/refusals.ts')
-  const say = (key: string, p: Record<string, string>) => `${key} ${JSON.stringify(p)}`
-  const refusal = Object.assign(new Error('EDIT_TARGET: steps[2]: attach: door is wider than the opening'), { code: 'EDIT_TARGET', path: 'steps[2]' })
-  const told = recipeRefusalOf(refusal, say)!
-  assert.match(told, /^figure\.text\.recipe-step-refused .*"step":"3".*"code":"EDIT_TARGET"/, '셋째 단계, 코드와 함께')
-  assert.doesNotMatch(told, /wider than/)
-  assert.equal(recipeRefusalOf(Object.assign(new Error('x'), { code: 'SCHEMA', path: 'steps' }), say), null, '단계가 아닌 거절은 다른 말이 맡는다')
+test('말이 없는 거절은 코드로 — 커널의 영어가 아니다', () => {
+  const refused = refusalOf(() => act(conveyor(), { kind: 'set-repeat', part: 'frame', pitch: 10 }))
+  const said = editRefusalOf(refused, keyed)
+  assert.match(said, /^figure\.text\.edit-refused .*"code":"EDIT_TARGET"/)
+  assert.doesNotMatch(said, /repeated part/)
+})
+
+/*
+ * ADR-0127 decision 4: the screen says a refusal from its code and details, never from the kernel's sentence. A
+ * regular expression handed an error's message anywhere in the client brings back what went quiet on 2026-10-11.
+ */
+test('화면은 커널의 거절 문장에 정규식을 대지 않는다 (ADR-0127)', () => {
+  const root = fileURLToPath(new URL('../client', import.meta.url))
+  const files: string[] = []
+  const walk = (dir: string) => {
+    for (const name of readdirSync(dir)) {
+      const path = join(dir, name)
+      if (statSync(path).isDirectory()) walk(path)
+      else if (name.endsWith('.ts')) files.push(path)
+    }
+  }
+  walk(root)
+  const reading = /\.(?:test|exec|match|matchAll|replace|search)\(\s*(?:message|msg|(?:error|err|e)\.message|String\((?:error|err|e)\))\b|\b(?:message|(?:error|err|e)\.message)\.(?:match|matchAll|replace|search)\(/
+  const found = files.flatMap(file =>
+    readFileSync(file, 'utf8')
+      .split('\n')
+      .map((line, i) => ({ file, line: i + 1, text: line }))
+      .filter(l => reading.test(l.text))
+  )
+  assert.deepEqual(found.map(f => `${f.file.slice(root.length)}:${f.line}: ${f.text.trim()}`), [])
+  const refusals = readFileSync(join(root, 'modeller/refusals.ts'), 'utf8')
+  assert.doesNotMatch(refusals, /\.message\b/, 'refusals.ts 는 문장을 읽지 않는다')
 })

package/test/release-entry.test.ts

@@ -10,15 +10,7 @@ import { fileURLToPath } from 'node:url'
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 
 test('beside the save: the release state, and a way to the release section that exists', () => {
-  const editor = read('../client/modeller/editor.ts')
-  assert.ok(editor.includes('<span slot="status" release-state>${this.releaseWords(view)}</span>'))
-  assert.ok(editor.includes("<button slot=\"commit\" publish ?disabled=${!view.id}"), 'not before the first save')
-  const go = editor.slice(editor.indexOf('  private goRelease'), editor.indexOf('  /** The fastening form'))
-  assert.ok(go.includes("this.tab = 'history'") && go.includes('showRelease'), 'to the history tab\'s release section')
-  const panel = read('../client/modeller/figure-history-panel.ts')
-  assert.ok(panel.includes('<section release tabindex="-1">') && panel.includes('async showRelease()'))
-  const page = read('../client/pages/figure-modeller-page.ts')
-  assert.ok(page.includes('.releaseState=${this.row}'), 'as the server gave it')
+  /* The state beside the save and the way to the release section are checked on the page: test/browser/product-page.check.mjs. */
   const ko = JSON.parse(read('../translations/ko.json'))
   assert.equal(ko['figure.text.release-state-draft-over'].replace('{version}', '3'), '초안 · 보드는 v3 사용')
   for (const lang of ['en', 'ja', 'ko', 'ms', 'zh', 'es']) {

package/test/release-panel.test.ts

@@ -11,8 +11,6 @@
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
 
 import {
   addFigureBox,
@@ -52,23 +50,4 @@ test('선언한 공간을 넘은 부품도 같은 한 번으로 풀리고, 배
   assert.equal(fitted.placement, 'center', '이미 선언된 배치 기준을 바꾸지 않는다')
 })
 
-const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
-
-test('모델러가 발행 패널을 걸고, 패널이 내는 셋을 받는다', () => {
-  const page = read('../client/pages/figure-modeller-page.ts')
-
-  assert.ok(/<figure-history-panel/.test(page), '패널을 건다')
-  for (const event of ['fit-base-to-parts', 'figure-released', 'figure-reverted']) {
-    assert.ok(page.includes(`@${event}=`), `패널이 내는 ${event} 를 받는 자리가 없다 — 눌러도 아무 일이 없다`)
-  }
-  assert.ok(/occupancyFromParts\(shown\.asset\)/.test(page), '「부품에 맞추기」가 공간 선언으로 이어진다')
-  /* 없으면 셸이 페이지를 내용 폭(편집기 660 + 패널 320)으로 세워 패널이 오른쪽 밖으로 나간다 — 945 px 에서 봤다. */
-  assert.ok(/:host \{[^}]*overflow: hidden/.test(page), '페이지가 주어진 폭 안에 든다')
-})
-
-test('패널은 받는 화면이 있는 조치만 그린다 — 「바닥에 앉히기」는 없다', () => {
-  const panel = read('../client/modeller/figure-history-panel.ts')
-
-  assert.ok(!/settle-parts-on-floor|apply-sizing-fix|restore-released-footprint/.test(panel), '받는 화면이 없는 조치를 내지 않는다')
-  assert.ok(/code === 'part-outside-occupancy' \|\| code === 'occupancy-undeclared'/.test(panel), '두 판정에 맞추기를 낸다')
-})
+/* The page hangs the panel and takes what it sends -- fit, released, reverted -- checked in test/browser/product-page.check.mjs. */