@things-factory/figure-ui 10.1.147 → 10.1.149

package/test/resize-with-placement.test.ts

@@ -93,12 +93,6 @@ test('fresh, width only, and all set back to fixed are three different answers',
   const following = applyFigureAuthoring(a, { kind: 'follow-size', part: 'box', axes: ['y'] })
   assert.deepEqual(resizeAxesOf(following, 'box'), { axes: ['y'], basis: 'chosen' })
   assert.deepEqual(resizeAxesOf(following, 'box', ['x']), { axes: ['x', 'y'], basis: 'chosen' })
-  /* The screen: size response is no longer a disguised placement command. */
-  const links = readFileSync(new URL('../client/modeller/figure-links.ts', import.meta.url), 'utf-8')
-  const dimensions = links.slice(links.indexOf('  private renderDimensions('), links.indexOf('  /** The same source'))
-  assert.ok(dimensions.includes("this.command({ kind: 'follow-size', part: this.partId })"))
-  assert.ok(!dimensions.includes('resize-with-placement'), 'size response does not attach the part')
-  assert.ok(!links.includes('figure.label.stands-on-plane'), 'the attachment form does not present a model-placement toggle')
   const ko = JSON.parse(readFileSync(new URL('../translations/ko.json', import.meta.url), 'utf-8'))
   assert.equal(ko['figure.button.follow-size'], '모델 크기에 맞추기')
 })
@@ -108,8 +102,6 @@ test('a part off the floor is not moved by choosing its size response', () => {
   a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
   const asked = planFigureResize(a, { part: 'shelf', axes: resizeAxesOf(a, 'shelf').axes })
   assert.deepEqual([asked.refusal?.code, asked.refusal?.mm], ['GAP_CHOICE', 500])
-  const links = readFileSync(new URL('../client/modeller/figure-links.ts', import.meta.url), 'utf-8')
-  assert.ok(!links.includes("@click=${() => ask('keep')}"), 'the UI does not offer a size command that also moves the part')
 })
 
 test('a field only the room reads is taken out of the part\'s position row and shown apart', () => {
@@ -122,9 +114,6 @@ test('a field only the room reads is taken out of the part\'s position row and s
   const { vectors } = groupFields(fields.filter(f => !roomOnly.includes(f.id)), 'box')
   const position = vectors.find(v => v.kind === 'vector' && v.name === 'position')!
   assert.ok(position.kind === 'vector' && position.cells.x && !position.cells.y && position.cells.z, 'X and Z still move it; Y is held by the floor')
-  const editor = readFileSync(new URL('../client/modeller/editor.ts', import.meta.url), 'utf-8')
-  assert.ok(editor.includes('${roomFields.length ? this.renderRoomOnly(roomFields, unavailable) : nothing}'))
-  assert.ok(editor.includes('if (agreed) this.linkCommand(refit.step)'), 'the room is declared again only when the author confirms')
 })
 
 /*
@@ -145,8 +134,6 @@ test('the part component carries the face a size drag keeps, for each placement'
     assert.deepEqual(state.scaleAnchor, expected[mode])
     assert.equal(componentOf(body, {}, { width: 1000, height: 1000 })!.scaleAnchor, undefined, 'none given, none set')
   }
-  const editor = readFileSync(new URL('../client/modeller/editor.ts', import.meta.url), 'utf-8')
-  assert.ok(editor.includes('.anchors=${this.anchorsOf(asset)}'))
 })
 
 /* Designer 2026-09-27 (acceptance round 2): what the screen shows for a part a rule places, and what it withholds. */
@@ -161,16 +148,9 @@ test('a fastened part keeps its position and turn rows, with the numbers the rul
   assert.ok(rows.rotation && rows.position, 'the turn row stands though every turn axis is the joint\'s')
   const body = compileFigureAsset(resized).evaluate().geometry.find(g => g.id === 'box') as never
   assert.deepEqual(placementOf(body), { position: [20, 50, 30], rotation: [0, 0, 0] }, 'the numbers a held cell shows')
-  const editor = readFileSync(new URL('../client/modeller/editor.ts', import.meta.url), 'utf-8')
-  assert.ok(editor.includes('<input type="text" readonly .value=${given(axis)}'), 'a held cell shows its number, read-only')
-  assert.ok(!editor.includes('value="—" disabled'), 'not a blank')
 })
 
 test('size response and attachment are separate screen paths', () => {
-  const links = readFileSync(new URL('../client/modeller/figure-links.ts', import.meta.url), 'utf-8')
-  assert.ok(links.includes('figure.button.fasten-start'))
-  assert.ok(links.includes('figure.label.target-part-placeholder'))
-  assert.ok(!links.includes('? this.renderHeld(asset)'))
   const ko = JSON.parse(readFileSync(new URL('../translations/ko.json', import.meta.url), 'utf-8'))
   assert.equal(ko['figure.text.held-on-plane'].replace('{face}', '아랫면').replace('{place}', '바닥').replace('{gap}', '0'), '아랫면을 바닥에 유지 중 (간격 0 mm)')
 })
@@ -181,10 +161,6 @@ test('a part fastened twisted has no face figure-model can keep for a drag, so t
   a = addFigureBox(a, { id: 'blade', size: { x: 300, y: 20, z: 60 }, position: { x: 0, y: 110, z: 0 } })
   a = applyFigureAuthoring(a, { kind: 'attach', part: 'blade', face: 'bottom', to: { part: 'hub', face: 'top' }, twist: 30 })
   assert.equal(figureScaleAnchorOf(a, 'blade'), undefined)
-  const editor = readFileSync(new URL('../client/modeller/editor.ts', import.meta.url), 'utf-8')
-  assert.ok(editor.includes('if (reach.scale && this.sizeDragUnsure(asset, id)) return { ...reach, scale: false }'), 'the tool is off')
-  assert.ok(editor.includes("if (asset && this.sizeDragUnsure(asset, this.selected)) {"), 'the R key says why')
-  assert.ok(editor.includes("result.scale.some(k => Math.abs(k - 1) > 1e-4) && this.sizeDragUnsure(asset, id)"), 'a drag that still arrives is not written')
 })
 
 /*
@@ -200,14 +176,6 @@ test('"open attachment settings" opens this part\'s fastening, as it is now, and
   assert.equal(form.toPlane, true, 'on the plane')
   assert.equal(form.face, 'bottom')
   assert.equal(form.gap, 100, 'the gap it keeps')
-  const links = readFileSync(new URL('../client/modeller/figure-links.ts', import.meta.url), 'utf-8')
-  const editor = readFileSync(new URL('../client/modeller/editor.ts', import.meta.url), 'utf-8')
-  assert.ok(links.includes('@click=${() => this.openFastening(asset)}'))
-  const open = links.slice(links.indexOf('  private async openFastening('), links.indexOf('  /**\n   * What holds the part, said as its state'))
-  assert.ok(open.includes('const own = fasteningOf(this.revision!, this.partId)'), 'the form is loaded from the fastening it has now')
-  assert.ok(open.includes("querySelector<HTMLElement>('section[fastening]')"), 'the fastening section is what comes into view')
-  assert.ok(!editor.includes("@open-fastening=${() => (this.tab = 'capability')}"), 'it does not switch to the capability tab')
-  assert.ok(links.includes('<section fastening ?spotlit=${this.spotlit}'))
 })
 
 /*

package/test/revert-choice.test.ts

@@ -9,29 +9,8 @@ import { fileURLToPath } from 'node:url'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 
-test('with edits not saved, the three are asked; without, the plain confirmation', () => {
-  const panel = read('../client/modeller/figure-history-panel.ts')
-  const revert = panel.slice(panel.indexOf('  private async revert('))
-  assert.ok(revert.indexOf('if (this.dirty) {') < revert.indexOf('revertFigureVersion('), 'asked before anything is reverted')
-  assert.ok(revert.includes("if (!(await this.settleUnsaved('revert', version))) return"), 'cancelled or not saved: nothing')
-  const settle = panel.slice(panel.indexOf('  private async settleUnsaved('), panel.indexOf('  private async revert('))
-  assert.ok(settle.includes('html`<figure-revert-choice .version=${version} .purpose=${purpose}></figure-revert-choice>`'))
-  assert.ok(settle.includes('if (!choice) return false'), 'cancelled: nothing')
-  const choice = read('../client/modeller/figure-revert-choice.ts')
-  assert.ok(choice.includes("closePopup(this, 'discard' satisfies RevertChoice)") && choice.includes("closePopup(this, 'save' satisfies RevertChoice)"))
-  assert.ok(choice.includes('slot="start" destructive'), 'letting edits go is marked as what it is')
-})
-
+/* The three asked, and a save first that holds the revert, are checked on the page: test/browser/product-page.check.mjs. */
 test('saved first, and known to be -- or nothing is reverted', () => {
-  const panel = read('../client/modeller/figure-history-panel.ts')
-  const settle = panel.slice(panel.indexOf('  private async settleUnsaved('), panel.indexOf('  private async revert('))
-  assert.ok(settle.includes("if (!saved?.ok) {\n        this.failure = i18next.t('figure.text.revert-held-unsaved'"), 'a save not done holds the revert')
-  assert.ok(settle.includes('return false\n      }\n    }\n    return true'))
-  const page = read('../client/pages/figure-modeller-page.ts')
-  assert.ok(page.includes('.saveFirst=${this.saveBeforeRevert}'))
-  const save = page.slice(page.indexOf('  private saveBeforeRevert'), page.indexOf('  private reverted'))
-  assert.ok(save.includes("return this.session.read().dirty ? { ok: false } : { ok: true }"), 'ok only when the session says saved')
-  assert.ok(save.includes("code === 'SAVE_UNREACHABLE' ? i18next.t('figure.text.save-unreachable')"), 'not known is said as not known')
   for (const lang of ['en', 'ja', 'ko', 'ms', 'zh', 'es']) {
     const t = JSON.parse(read(`../translations/${lang}.json`))
     for (const key of ['figure.text.revert-with-unsaved', 'figure.button.revert-saving', 'figure.button.revert-discarding', 'figure.text.revert-held-unsaved']) assert.ok(t[key], `${lang} ${key}`)

package/test/revert-keeping.test.ts

@@ -69,18 +69,7 @@ test('the source a revert expects is what the server is confirmed to hold -- not
 })
 
 test('the screen: reverting is on, sends the confirmed source and a request id, and lists the kept drafts apart', () => {
-  const panel = read('../client/modeller/figure-history-panel.ts')
-  assert.ok(!panel.includes('REVERT_KEEPS_REPLACED_DRAFT'), 'the gate is gone')
-  const revert = panel.slice(panel.indexOf('  private async revert('), panel.indexOf('  private async undo('))
-  /* Read after the unsaved edits are settled -- a save first moves it. */
-  assert.ok(revert.indexOf('settleUnsaved(') < revert.indexOf('const expected = this.serverSource?.()'))
-  assert.ok(revert.includes('if (expected === undefined) {'), 'not known: not reverted')
-  assert.ok(revert.includes('revertFigureVersion(this.figureId!, version, requestId, expected)'))
-  const undo = panel.slice(panel.indexOf('  private async undo('), panel.indexOf('  private async send('))
-  assert.ok(undo.includes("this.dirty && !(await this.settleUnsaved('undo'))"), 'an undo asks about unsaved edits too')
-  assert.ok(panel.includes('<section kept>'), 'kept drafts in their own section, not among the releases')
-  assert.ok(panel.includes('${newest && !kept.restoredAt'), 'only the newest, not yet brought back, is offered')
-  assert.ok(read('../client/pages/figure-modeller-page.ts').includes('.serverSource=${() => this.session.confirmedSource()}'))
+  /* The panel on the page -- the confirmed source sent, the same request asked again, the kept drafts -- is checked in product-page.check.mjs. */
   for (const lang of ['en', 'ja', 'ko', 'ms', 'zh', 'es']) {
     const t = JSON.parse(read(`../translations/${lang}.json`))
     for (const key of [

package/test/save-landed.test.ts

@@ -11,6 +11,7 @@ import { addFigureBox, createFigureAsset, serializeFigureAsset } from '@hatiolab
 
 import { createFigureProductSession } from '../client/modeller/product-session.js'
 import { thumbnailHashOf } from '../client/modeller/thumbnail-hash.js'
+import { reached } from '../client/graphql/reached.js'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 /** A picture as the modeller sends one: a data URL. */
@@ -95,27 +96,28 @@ test('a real conflict, or no server at all: the failure stands and the edits sta
   assert.equal(t.state.writes, 0)
 })
 
-test('not reached is said as not known, not as not saved', () => {
-  const store = read('../client/graphql/store.ts')
-  assert.ok(read('../client/graphql/reached.ts').includes("if (lost) throw Object.assign(Error('서버에 연결하지 못했습니다.'), { code: unreachable, cause: error })"))
-  assert.ok(read('../client/graphql/reached.ts').includes("unreachable = 'SAVE_UNREACHABLE'"), 'a save not reached is SAVE_UNREACHABLE')
-  assert.ok(store.includes('await reached(client.mutate('), 'the save goes through it')
-  assert.ok(store.includes('async readBack(id)'), 'every field a save writes, read back')
+/* The page's side -- a save lost and read back, a save not known said as such -- is checked in the browser (test/browser/product-page.check.mjs). */
+test('not reached is said as not known, not as not saved', async () => {
+  type Told = Error & { code?: string; cause?: unknown }
+  assert.equal(await reached(Promise.resolve('answered')), 'answered')
+  /* Lost on the way or on the way back: not known -- SAVE_UNREACHABLE unless the caller names its own. */
+  const lost = Object.assign(Error('Failed to fetch'), { networkError: { statusCode: 0 } })
+  await assert.rejects(reached(Promise.reject(lost)), (e: Told) => e.code === 'SAVE_UNREACHABLE' && e.cause === lost && e.message === '서버에 연결하지 못했습니다.')
+  const offline = new TypeError('Failed to fetch')
+  await assert.rejects(reached(Promise.reject(offline), 'REVERT_UNREACHABLE'), (e: Told) => e.code === 'REVERT_UNREACHABLE' && e.cause === offline)
+  /* A refusal keeps the server's code, so a conflict is told from a refusal on grounds. */
+  const conflict = Object.assign(Error('Response not successful'), { graphQLErrors: [{ message: '다른 편집에서 모델이 변경되었습니다.', extensions: { code: 'FIGURE_SOURCE_CONFLICT' } }] })
+  await assert.rejects(reached(Promise.reject(conflict)), (e: Told) => e.code === 'FIGURE_SOURCE_CONFLICT' && e.message === '다른 편집에서 모델이 변경되었습니다.')
+  const other = Error('something else')
+  await assert.rejects(reached(Promise.reject(other)), (e: Told) => e === other)
   const write = read('../../figure-service/server/service/figure/figure-write.ts')
   assert.ok(write.includes("return new GraphQLError(message, { extensions: { code: 'FIGURE_SOURCE_CONFLICT' } })"), 'the server says a conflict is one')
-  const editor = read('../client/modeller/editor.ts')
-  assert.ok(editor.includes("=== 'SAVE_UNREACHABLE' ? i18next.t('figure.text.save-unreachable')"))
   for (const lang of ['en', 'ja', 'ko', 'ms', 'zh', 'es']) assert.ok(JSON.parse(read(`../translations/${lang}.json`))['figure.text.save-unreachable'], lang)
   assert.match(JSON.parse(read('../translations/ko.json'))['figure.text.save-unreachable'], /저장됐는지 확인하지 못했습니다/)
 })
 
-/* A released figure made a draft by a change is said when it happens -- saved source, or category and tags. */
+/* A released figure made a draft by a change is said when it happens -- saved source, or category and tags (product-page.check.mjs). */
 test('a released figure changed back to a draft is told, whichever change did it', () => {
-  const page = read('../client/pages/figure-modeller-page.ts')
-  assert.ok(page.includes("if (before === 'released' && after === 'draft') notify({ level: 'info', message: i18next.t('figure.text.released-now-draft') })"))
-  assert.ok(page.includes('if (this.session.read().id === id) this.toldDemoted(this.row.state, figure.state)'), 'after a save, read back')
-  assert.ok(page.includes('this.toldDemoted(this.row.state, result.figure.state)'), 'after category or tags')
-  assert.ok(page.includes("...(result.figure.state ? { state: result.figure.state as 'draft' | 'released' } : {})"), 'and the badge follows')
   for (const lang of ['en', 'ja', 'ko', 'ms', 'zh', 'es']) assert.ok(JSON.parse(read(`../translations/${lang}.json`))['figure.text.released-now-draft'], lang)
 })
 

package/test/scene-canvas.test.ts

@@ -33,12 +33,8 @@ const box = (t: number[], r = turned(0)): FigureRenderPart => ({
   material: { token: 'palette.primary' }
 })
 
-test('things-scene 의 판을 편집 모드로 세우고, 보기 설정은 판의 상태 이름 그대로 넣는다', () => {
-  assert.ok(canvas.includes("import { create, Model, niceGridStep } from '@hatiolab/things-scene'"))
-  assert.match(canvas, /type: 'model-layer'/)
-  assert.match(canvas, /mode: 1\n/, '편집 모드 — 시점 단추 · 기즈모 · 도움말 · 단축키')
-  assert.ok(canvas.includes('...sceneLook(this.view ?? DEFAULT_VIEW)'))
-  assert.ok(canvas.includes('pixelRatio: Math.min(3, (window.devicePixelRatio || 1) * 2)'), '두 배 표본')
+test('things-scene 의 판을 세운다 — 제 장면을 짜지 않는다', () => {
+  /* The board in editing mode, the view settings and the supersampling it is given are the browser check's (test/browser/screen.check.mjs). */
   assert.doesNotMatch(canvas, /new THREE\.|WebGLRenderer|OrbitControls|TransformControls/, '제 장면을 짜지 않는다')
 })
 
@@ -77,10 +73,3 @@ test('돌린 몸체도 왕복한다 — 판에 적은 상태를 그대로 되읽
   assert.equal(changedKeys(at, { ...at }), null, '같은 값은 다시 넣지 않는다 — 씬이 메아리를 내지 않게')
   assert.deepEqual(changedKeys(at, { ...at, left: 1 }), { left: 1 })
 })
-
-test('고르기와 끌기는 이름으로 알리고, 스스로 적은 것의 메아리는 끌기로 읽지 않는다', () => {
-  assert.ok(canvas.includes("root.on('selected'"))
-  assert.ok(canvas.includes("if (this.writing) return"))
-  assert.ok(canvas.includes("new CustomEvent('part-transformed', { detail: { id: part.id, result }"))
-  assert.ok(canvas.includes('setTimeout(() => this.sync())'), '받지 못한 변경은 입력이 둔 자리로 돌아간다')
-})

package/test/section-editor.test.ts

@@ -12,17 +12,12 @@ import { fileURLToPath } from 'node:url'
 import { addFigurePrimitive, applyFigureAuthoring, compileFigureAsset, createFigureAsset } from '@hatiolab/figure-model'
 import type { FigureAsset, FigureEvaluatedShape, FigureSectionPoint } from '@hatiolab/figure-model'
 
-import { apexOver, extentOf, sectionOf as sectionOfWorking, workingIssuesOf as issuesOfWorking, workingOf as workingOfShape, insertAfter, issueWords, issuesOf, markedBy, movePoint, nextPointId, pointLabel, removePoint } from '../client/modeller/section-drawing.ts'
+import { apexOver, drawnOf, extentOf, measureNoteOf, sectionActionOf, sectionOf as sectionOfWorking, sectionPointsWordsOf, workingIssuesOf as issuesOfWorking, workingOf as workingOfShape, insertAfter, issueWords, issuesOf, markedBy, movePoint, nextPointId, pointLabel, removePoint } from '../client/modeller/section-drawing.ts'
 import { livePartsOf } from '../client/modeller/live.ts'
 import { revisionOf } from './revision-of.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
-/* A source file is a big string: a failing assert.match on it spends minutes building the diff and looks hung. */
-const has = (source: string, re: RegExp, message?: string) => assert.ok(re.test(source), message ?? `missing: ${re}`)
-const hasNot = (source: string, re: RegExp, message?: string) => assert.ok(!re.test(source), message ?? `present: ${re}`)
 const editorPanel = read('../client/modeller/figure-section-editor.ts')
-const sectionPanel = read('../client/modeller/figure-section-panel.ts')
-const editor = read('../client/modeller/editor.ts')
 const ko = JSON.parse(read('../translations/ko.json')) as Record<string, string>
 const say = (key: string, params: Record<string, string>) => Object.entries(params).reduce((s, [k, v]) => s.replace(`{${k}}`, v), ko[key] ?? key)
 
@@ -112,31 +107,6 @@ test('치는 동안 입체는 그 점으로 그려지고, 잘못된 동안은
   const body = drawn.find(p => p.id === 'wedge') as unknown as { shape: FigureEvaluatedShape }
   assert.equal((body.shape.extrusion!.section as { points: unknown[] }).points.length, 4)
   assert.equal(pointsOf(t).length, 3, 'the figure itself is not changed')
-  has(editorPanel, /private preview\(w = this\.lastValid\) \{\s*this\.dispatchEvent\(new CustomEvent\('command-live', \{ detail: \{ action: this\.action\(w\) \}/, 'the preview is always of a valid shape')
-  has(editorPanel, /this\.preview\(c && this\.valid\(\{ \.\.\.this\.working, cavity: c \}\) \? \{ \.\.\.this\.working, cavity: c \} : this\.lastValid\)/, 'the one other: the inside being dragged, when valid')
-  has(editorPanel, /figure\.text\.section-editor-last-valid/)
-})
-
-test('적용은 한 명령, 취소·Esc 는 아무것도 보내지 않는다 — 창을 연 뒤 도형이 바뀌면 적용을 막는다', () => {
-  has(editorPanel, /private apply\(\) \{\s*if \(this\.stale \|\| !this\.valid\(this\.working\)\) return/)
-  has(editorPanel, /private cancel\(\) \{\s*this\.dispatchEvent\(new CustomEvent\('command-live', \{ detail: \{ action: null \}/)
-    has(editorPanel, /return this\.revision !== this\.openedAt/)
-  has(editor, /<figure-section-editor[\s\S]*?\.revision=\$\{this\.session\?\.read\(\)\.revision \?\? 0\}[\s\S]*?@command=\$\{\(e: CustomEvent\) => this\.linkCommand\(e\.detail\.action\)\}/)
-  has(editor,
-    /protected willUpdate[\s\S]*?if \(this\.sectionEditing && this\.sectionEditing !== this\.selected\) this\.leaveSectionEditor\(this\.selected\)\s*\}/,
-    'the selection moved off the part by any way closes it and lets go of the preview'
-  )
-  has(editor, /if \(!editor\?\.dirty \|\| !stillThere\) \{\s*this\.closeSectionEditor\(\)/, 'nothing changed, or nothing to go back to: it just closes')
-  has(editor, /private closeSectionEditor\(\) \{\s*this\.sectionEditing = null\s*this\.holdAction\(null\)/)
-  has(sectionPanel, /section-editor-open/)
-})
-
-test('Delete 키는 칸 안에서는 글자를, 밖에서는 고른 점을 지운다 — 창이 먼저 듣고, 받은 키는 뒤의 장면에 넘기지 않는다', () => {
-  has(editorPanel, /\(e\.key === 'Delete' \|\| e\.key === 'Backspace'\) && !inField && this\.selected/)
-  /* The scene listens on its own element and stops the key there: heard later, Esc selected nothing and Delete took the part. */
-  has(editorPanel, /window\.addEventListener\('keydown', this\.keys, true\)/)
-  has(editorPanel, /const take = \(\) => \(e\.preventDefault\(\), e\.stopImmediatePropagation\(\)\)/)
-  has(editorPanel, /if \(e\.key === 'Escape'\) \{\s*take\(\)\s*this\.requestClose\(\)/)
 })
 
 test('그림은 점을 다 담고 여유를 둔다 — 50 mm 단위로', () => {
@@ -154,11 +124,6 @@ test('편집 창의 말은 다섯 말 모두에 있다', () => {
   }
 })
 
-test('창의 네 줄은 줄 번호로 선다 — 넓은 화면에서 탭 줄이 숨어도 적용·취소가 밀려 나가지 않는다', () => {
-  for (const [part, row] of [['header', 1], ['nav\\[tabs\\]', 2], ['div\\[body\\]', 3], ['footer', 4]] as const)
-    has(editorPanel, new RegExp(`${part} \\{\\s*grid-row: ${row};`))
-})
-
 test('치는 동안의 명령이 쓴 입력은 명령의 값으로 그린다 — 지금 값이 옮긴 점·다시 친 반지름을 되돌리지 않는다', async () => {
   const { liveOverSession } = await import('../client/modeller/live.ts')
   const t = triangle()
@@ -174,12 +139,6 @@ test('치는 동안의 명령이 쓴 입력은 명령의 값으로 그린다 —
   assert.deepEqual((b.shape.extrusion!.section as { corner: unknown }).corner, { x: 80, z: 80 })
 })
 
-test('편집 창이 열린 동안 모델러의 키는 비켜선다 — Esc 가 선택을, Delete 가 부품을, Ctrl+Z 가 도형의 기록을 건드리지 않는다', () => {
-  const onKey = editor.slice(editor.indexOf('  private onKey = '), editor.indexOf('  connectedCallback() {', editor.indexOf('  private onKey = ')))
-  has(onKey, /if \(this\.sectionEditing\) return\s*const canvas/)
-  assert.ok(onKey.indexOf('if (this.sectionEditing) return') < onKey.indexOf('keyActionOf('), 'before any key is taken')
-})
-
 test('속성의 형상 치수에는 점·꼭짓점 칸이 없다 (사용자 10-01) — 높이만 남고, 단면 칸이 점 개수를 말한다', async () => {
   const { groupFields } = await import('../client/modeller/fields.ts')
   const f = (id: string) => ({ id, value: 0, unit: 'mm' })
@@ -188,16 +147,14 @@ test('속성의 형상 치수에는 점·꼭짓점 칸이 없다 (사용자 10-0
     'tip.dimension.round', 'tip.dimension.wall', 'tip.dimension.closed.start', 'tip.dimension.wallX', 'tip.corner.x', 'tip.wall.x-']
   const { singles } = groupFields(ids.map(f) as never, 'tip')
   assert.deepEqual(singles.map(g => (g as { field: { id: string } }).field.id), ['tip.dimension.height'])
-  has(sectionPanel, /e\.apex \? 'figure\.text\.section-points-apex' : 'figure\.text\.section-points', \{ points: String\(e\.section\.points\.length\) \}/)
-  assert.equal(say('figure.text.section-points-apex', { points: '3' }), '점 3개 · 꼭짓점 하나')
-})
-
-test('편집 창 옆에 입체를 볼 자리가 없으면 윤곽과 입체 결과를 번갈아 본다 (§7)', async () => {
-  const { NARROW_BELOW } = { NARROW_BELOW: Number(/export const NARROW_BELOW = (\d+)/.exec(editorPanel)![1]) }
-  assert.ok(NARROW_BELOW > 560, 'wider than the editor itself')
-  has(editorPanel, /:host\(\[narrow\]\) nav\[tabs\] \{\s*display: flex;/)
-  has(editorPanel, /:host\(\[narrow\]\[show='solid'\]\) div\[body\] \{\s*display: none;/)
-  has(editorPanel, /this\.room\.observe\(this\.parentElement\)/)
+  /* The 단면 group says how many points instead: a triangle three, a pyramid three and its apex; a box nothing. */
+  assert.deepEqual(sectionPointsWordsOf(drawnOf(shapeOf(triangle()))), { key: 'figure.text.section-points', params: { points: '3' } })
+  const pyramid = applyFigureAuthoring(triangle(), { kind: 'set-section', part: 'wedge', apex: { x: 0, z: 0 } })
+  const words = sectionPointsWordsOf(drawnOf(shapeOf(pyramid)))!
+  assert.equal(say(words.key, words.params), '점 3개 · 꼭짓점 하나')
+  const { addFigureBox } = await import('@hatiolab/figure-model')
+  const box = addFigureBox(createFigureAsset('B'), { id: 'wedge', size: { x: 400, y: 100, z: 300 }, position: { x: 0, y: 50, z: 0 } })
+  assert.equal(sectionPointsWordsOf(drawnOf(shapeOf(box))), null)
 })
 
 test('사각형·원도 같은 창에서 — 폭·지름·길이를 한 명령으로, 바꾸지 않은 치수는 보내지 않는다', async () => {
@@ -210,7 +167,9 @@ test('사각형·원도 같은 창에서 — 폭·지름·길이를 한 명령
   assert.deepEqual(sectionOf(shape, { ...w, across: { x: 500, z: 300 } }), { kind: 'rectangle', size: { x: 500, z: 300 } })
   assert.deepEqual(figureSectionMeasuresOf(box, 'b')!.measures, { y: 'editable', x: 'editable', z: 'editable' })
   /* The editor sends only what changed: a measure left alone may follow another value and must not be written. */
-  has(editorPanel, /const across = Object\.fromEntries\(Object\.entries\(w\.across\)\.filter\(\(\[k, v\]\) => changed\(v, o\.across\[k as Axis\]\)\)\)/)
+  assert.deepEqual(sectionActionOf('b', 'rectangle', w, { ...w, across: { x: 500, z: 300 } }), { kind: 'set-section', part: 'b', across: { x: 500 } })
+  assert.deepEqual(sectionActionOf('b', 'rectangle', w, { ...w, length: 260 }), { kind: 'set-section', part: 'b', length: 260 })
+  assert.deepEqual(sectionActionOf('b', 'rectangle', w, w), { kind: 'set-section', part: 'b' }, 'nothing changed, nothing written')
   const next = applyFigureAuthoring(box, { kind: 'set-section', part: 'b', across: { x: 500 }, length: 260 })
   const b = (compileFigureAsset(next).evaluate().geometry.find(g => (g as { id: string }).id === 'b') as unknown as { shape: FigureEvaluatedShape; pose: { t: number[] } })
   assert.deepEqual(b.shape.extrusion!.section, { kind: 'rectangle', size: { x: 500, z: 300 } })
@@ -252,17 +211,20 @@ test('창 안에서 폭과 속 공간을 함께 — 넓힌 폭에서만 들어
   const next = applyFigureAuthoring(tray, { kind: 'set-section', part: 't', across: { x: 600, z: 400 }, cavity: thick })
   const t = (compileFigureAsset(next).evaluate().geometry.find(g => (g as { id: string }).id === 't') as unknown as { shape: FigureEvaluatedShape }).shape
   assert.deepEqual(t.cavity!.wall, thick.wall)
-  /* The drawing in the editor is the panel's, its commands kept in the editor as working state, sent with the widths. */
-  has(editorPanel, /<figure-cavity-drawing\s+\.body=\$\{\{ id: this\.body!\.id, shape \}\}/)
-  has(editorPanel, /@command=\$\{\(ev: CustomEvent\) => \{\s*ev\.stopPropagation\(\)\s*const c = this\.cavityOf\(ev\.detail\.action\)\s*if \(c\) this\.change\(\{ \.\.\.this\.working, cavity: c \}\)/)
-  has(editorPanel, /\.\.\.\(cavityMoved \? \{ cavity: w\.cavity \? \{ wall: \{ \.\.\.w\.cavity\.wall \}, start: w\.cavity\.start, end: w\.cavity\.end \} : null \} : \{\}\)/, 'only when changed')
-  has(editorPanel, /private get hollowable\(\) \{\s*return !!this\.body\?\.shape\.extrusion && \(this\.kind === 'rectangle' \|\| this\.kind === 'ellipse'\)/, 'no inside for a drawn section')
+  /* The editor's one command carries the inside only when it changed: the widths alone leave it out; taken away, null. */
+  assert.deepEqual(sectionActionOf('t', 'rectangle', w, { ...w, across: { x: 600, z: 400 } }), { kind: 'set-section', part: 't', across: { x: 600, z: 400 } })
+  assert.deepEqual(sectionActionOf('t', 'rectangle', w, wide), { kind: 'set-section', part: 't', across: { x: 600, z: 400 }, cavity: thick })
+  assert.deepEqual(sectionActionOf('t', 'rectangle', w, { ...w, cavity: null }), { kind: 'set-section', part: 't', cavity: null })
 })
 
-test('길이를 바꿀 때 남는 면은 부품의 관계가 정한 것을 읽어 보여 준다 (§4.1) — 다른 값을 따르는 치수는 칸을 막는다', () => {
-  has(editor, /const kept = figureScaleAnchorOf\(asset, this\.selected\)\?\.\[drawn\.axis\]/)
-  has(editorPanel, /m\?\.\[this\.axis\] === 'linked' \? linked : this\.keptWords\(\)/)
-  has(editorPanel, /m\?\.\[this\.axis\] !== 'editable'/)
+test('치수 칸 밑의 말: 다른 값을 따르면 그렇다고, 길이는 관계가 남기는 면을 — 말할 것이 없으면 아무것도', () => {
+  assert.deepEqual(measureNoteOf('linked', 1, 'y'), { key: 'figure.text.section-editor-linked' }, 'following another value is said first')
+  assert.deepEqual(measureNoteOf('editable', 1, 'y'), { key: 'figure.text.section-editor-keeps', face: 'bottom' }, 'a floor part keeps its start: the bottom')
+  assert.deepEqual(measureNoteOf('editable', -1, 'y'), { key: 'figure.text.section-editor-keeps', face: 'top' })
+  assert.deepEqual(measureNoteOf('editable', -1, 'x'), { key: 'figure.text.section-editor-keeps', face: 'right' })
+  assert.deepEqual(measureNoteOf('editable', 0, 'y'), { key: 'figure.text.section-editor-keeps-centre' })
+  assert.equal(measureNoteOf('editable', undefined, 'y'), null, 'the relations cannot say: nothing')
+  assert.equal(measureNoteOf(undefined, undefined, 'x'), null, 'a width across says only that it follows')
   assert.equal(say('figure.text.section-editor-keeps', { face: ko['figure.label.face-bottom']! }), '아랫면 유지')
 })
 
@@ -312,43 +274,28 @@ test('편집 창에서 끝을 한 점으로: 켜면 점들의 가운데 위에
   const on = { ...w, apex: apexOver(w.points, 'y') }
   assert.deepEqual(on.apex, { z: 0, x: 0 })
   assert.deepEqual(issuesOfWorking(shape, on).words, [])
-  /* The editor sends apex only when it changed, null to go back to a push. */
-  has(editorPanel, /\.\.\.\(apexMoved \? \{ apex: w\.apex \? \{ \.\.\.w\.apex \} : null \} : \{\}\)/)
+  /* The editor sends apex only when it changed, null to go back to a push; a drawn section's points always go. */
+  assert.deepEqual(sectionActionOf('wedge', 'polygon', w, on), { kind: 'set-section', part: 'wedge', points: w.points, apex: { z: 0, x: 0 } })
+  assert.deepEqual(sectionActionOf('wedge', 'polygon', w, w), { kind: 'set-section', part: 'wedge', points: w.points })
   const pyramid = applyFigureAuthoring(wedge, { kind: 'set-section', part: 'wedge', apex: on.apex })
   const p = shapeOf(pyramid)
   assert.equal(p.provider, 'loft')
   const again = workingOfShape(p)
   assert.deepEqual(again.apex, { x: 0, z: 0 })
+  assert.deepEqual(sectionActionOf('wedge', 'polygon', again, { ...again, apex: null }).apex, null, 'turned off: back to a push')
+  assert.equal('apex' in sectionActionOf('wedge', 'polygon', again, { ...again, apex: { x: 0, z: 0 } }), false, 'the same apex is not sent')
   assert.deepEqual(sectionOfWorking(p, again), { kind: 'polygon', points: again.points })
   assert.equal(issuesOfWorking(p, { ...again, apex: { x: Number.NaN, z: 0 } }).words[0]!.key, 'figure.text.section-issue-number')
-  /* Its length is its height: the same field, called so. */
-  has(editorPanel, /this\.working\.apex \? 'figure\.label\.section-editor-height' : 'figure\.label\.section-editor-length'/)
   const back = applyFigureAuthoring(pyramid, { kind: 'set-section', part: 'wedge', apex: null })
   assert.equal(shapeOf(back).provider, 'extrude')
 })
 
+
 test('끝면에 붙은 부품이 있으면 한 점으로 모으기를 막고 그 면을 말한다 — 커널의 거절로 판정한다', () => {
-  has(editor, /const apex = apexOver\(drawn\.section\.points, drawn\.axis\)[\s\S]*?session\.previewCommand\(\{ kind: 'set-section', part, apex \}\)/)
-  has(editor, /\.code === 'FEATURE_MAPPING_REQUIRED'\)/)
-  has(editorPanel, /const blocked = !apex && !this\.opened\?\.apex \? this\.pointBlocked : ''/)
-  has(editorPanel, /\?disabled=\$\{!!blocked\}/)
   assert.equal(say('figure.text.section-editor-apex-blocked', { face: ko['figure.label.face-top']! }), '윗면에 붙은 부품이 있어 한 점으로 모을 수 없습니다.')
-  /* A pyramid in the section panel: its editor opens, and it has no corners and no inside. */
-  has(sectionPanel, /const e = body\?\.shape \? drawnOf\(body\.shape\) : undefined/)
 })
 
 test('닫기 전에 묻는다 (사용자 10-01): 바꾼 것이 있으면 적용·버리기·계속 편집 — 바꾼 것이 없으면 그냥 닫는다', () => {
-  const choice = read('../client/modeller/figure-section-close-choice.ts')
-  /* Esc and 취소 both ask; while it asks, the question has the keys. */
-  has(editorPanel, /if \(e\.key === 'Escape'\) \{\s*take\(\)\s*this\.requestClose\(\)/)
-  has(editorPanel, /<button @click=\$\{\(\) => this\.requestClose\(\)\}>\$\{i18next\.t\('figure\.button\.section-editor-cancel'\)\}/)
-  has(editorPanel, /if \(this\.asking\) return\n/)
-  has(editorPanel, /if \(!this\.dirty\) \{\s*this\.cancel\(\)\s*return true/)
-  /* Apply is only offered when it would be taken: not for a refused shape, not after the figure changed. */
-  has(editorPanel, /if \(choice === 'apply' && !held\)/)
-  has(choice, /\$\{this\.held\s*\? nothing/)
-  /* Picking another part while changes wait keeps the part selected until the editor closed. */
-  has(editor, /this\.selected = editing\s*editor\.requestClose\(\)\.then\(closed => \{\s*if \(closed && this\.selected === editing\) this\.selected = next/)
   for (const lang of ['ko', 'en', 'ja', 'zh', 'ms', 'es']) {
     const t = JSON.parse(read(`../translations/${lang}.json`)) as Record<string, string>
     for (const key of ['figure.text.section-editor-close-changed', 'figure.text.section-editor-close-invalid', 'figure.button.section-editor-apply-and-close', 'figure.button.section-editor-discard', 'figure.button.keep-editing'])

package/test/section-panel.test.ts

@@ -16,10 +16,13 @@ import {
   cavityDepthOf,
   cavityRefusalOf,
   cavityRequestOf,
+  cavityRefusalWordsOf,
   cavityResultOf,
+  cornerActionOf,
   cornerLimitOf,
   cornerRefusalOf,
   defaultWallOf,
+  hollowableOf,
   wallLimitOf
 } from '../client/modeller/section-controls.ts'
 import { livePartsOf } from '../client/modeller/live.ts'
@@ -27,13 +30,9 @@ import { editRefusalOf } from '../client/modeller/refusals.ts'
 import { revisionOf } from './revision-of.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
-/* A source file is a big string: a failing assert.match on it spends minutes building the diff and looks hung. */
-const has = (source: string, re: RegExp, message?: string) => assert.ok(re.test(source), message ?? `missing: ${re}`)
-const hasNot = (source: string, re: RegExp, message?: string) => assert.ok(!re.test(source), message ?? `present: ${re}`)
 const panel = read('../client/modeller/figure-section-panel.ts')
 /* The inside is drawn and typed in its own element (user 2026-10-01): its words and limits are read there. */
 const drawing = read('../client/modeller/figure-cavity-drawing.ts')
-const editor = read('../client/modeller/editor.ts')
 const ko = JSON.parse(read('../translations/ko.json')) as Record<string, string>
 
 const probe = () => addFigureBox(createFigureAsset('Probe'), { id: 'body', size: { x: 400, y: 200, z: 300 }, position: { x: 0, y: 100, z: 0 } })
@@ -56,7 +55,10 @@ test('모서리 반지름은 네 모서리를 한 값으로 둥글게 하고, 0
   const sharp = applyFigureAuthoring(round, { kind: 'set-section-corner', part: 'body', corner: null })
   assert.equal(shapeOf(sharp).extrusion!.section.kind, 'rectangle')
   assert.equal('corner' in shapeOf(sharp).extrusion!.section, false)
-  has(panel, /corner: value > 0 \? value : null/, 'the field sends 0 as no rounding')
+  /* The field's one command: a radius rounds, 0 takes the rounding away -- and the kernel takes both. */
+  assert.deepEqual(cornerActionOf('body', 40), { kind: 'set-section-corner', part: 'body', corner: 40 })
+  assert.deepEqual(cornerActionOf('body', 0), { kind: 'set-section-corner', part: 'body', corner: null })
+  assert.equal('corner' in shapeOf(applyFigureAuthoring(round, cornerActionOf('body', 0))).extrusion!.section, false)
 })
 
 test('속을 비우면 기본 벽·막힌 바닥·열린 윗면의 쟁반이 되고, 끝과 벽을 하나씩 바꾼다', () => {
@@ -90,9 +92,6 @@ test('벽이 단면을 다 채우거나 모서리가 변의 절반을 넘으면,
 })
 
 test('편집기는 단면 칸의 명령을 세션의 이력 하나로 돌리고, 치는 동안의 값은 그리기만 한다', () => {
-  has(editor, /<figure-section-panel[\s\S]*?@command=\$\{\(e: CustomEvent\) => this\.linkCommand\(e\.detail\.action\)\}/)
-  has(editor, /@command-live=\$\{\(e: CustomEvent\) => this\.holdAction\(e\.detail\.action\)\}/)
-  has(editor, /private linkCommand\(action: FigureAuthoringAction, from: 'section-editor' \| 'panel' = 'panel'\): boolean \{\s*\/\*[^*]*\*\/\s*this\.holdAction\(null\)/, 'a command sent lets go of the one in hand')
   for (const lang of ['ko', 'en', 'ja', 'zh', 'ms', 'es']) {
     const words = JSON.parse(read(`../translations/${lang}.json`)) as Record<string, string>
     const used = [...new Set([...(panel + drawing).matchAll(/'(figure\.(?:label|text)\.section-[\w-]+|figure\.label\.group-section)'/g)].map(m => m[1]!))]
@@ -139,7 +138,6 @@ test('속 공간은 무엇이 되었는지와 깊이로 보인다 — 한쪽이
   assert.equal(cavityDepthOf(tray), 170, 'the 200 mm push less its 30 mm floor')
   assert.equal(cavityResultOf({ ...tray.cavity!, start: 'open' }), 'pipe')
   assert.equal(cavityResultOf({ ...tray.cavity!, end: { closed: 5 } }), 'sealed')
-  has(panel, /figure\.text\.section-depth/)
 })
 
 test('치는 동안의 값은 사본에 그려지고 원본은 그대로다 — 받을 수 없는 값은 그리지 않는다', () => {
@@ -151,9 +149,16 @@ test('치는 동안의 값은 사본에 그려지고 원본은 그대로다 —
   assert.equal(livePartsOf(asset, { values: {}, action: { kind: 'set-section-corner', part: 'body', corner: 999 } }), null)
 })
 
-test('다각 단면에는 속 공간을 만들 수 없다고 그 자리에서 말한다', () => {
+test('다각 단면에는 속 공간을 만들 수 없다고 그 자리에서 말한다', async () => {
   /* A drawn section has no inside control at all, rather than a line saying it cannot have one (user 2026-10-01). */
-  has(panel, /kind === 'rectangle' \|\| kind === 'ellipse' \? this\.renderCavity\(body\) : nothing/)
+  const { addFigurePrimitive } = await import('@hatiolab/figure-model')
+  const drawn = addFigurePrimitive(createFigureAsset('D'), { id: 'body', 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 pyramid = applyFigureAuthoring(drawn, { kind: 'set-section', part: 'body', apex: { x: 0, z: 0 } })
+  const tube = addFigurePrimitive(createFigureAsset('C'), { id: 'body', kind: 'cylinder', dimensions: { radius: 50, length: 200 }, position: { x: 0, y: 0, z: 0 } })
+  assert.equal(hollowableOf(shapeOf(probe())), true, 'a pushed rectangle')
+  assert.equal(hollowableOf(shapeOf(tube)), true, 'a pushed circle')
+  assert.equal(hollowableOf(shapeOf(drawn)), false, 'a drawn section')
+  assert.equal(hollowableOf(shapeOf(pyramid)), false, 'a pyramid')
 })
 
 test('붙어 있는 것이 기대는 면을 없애는 편집은 거절되고, 그 면을 사람의 말로 부른다', () => {
@@ -164,11 +169,6 @@ test('붙어 있는 것이 기대는 면을 없애는 편집은 거절되고,
   assert.equal(said, say('figure.text.section-face-in-use', { faces: ko['figure.label.face-inside-bottom']! }))
 })
 
-test('치는 동안 그려진 도형이 칸의 글자를 덮어쓰지 않는다 — 친 것은 보낼 때까지 칸이 든다', () => {
-  has(panel, /\.value=\$\{live\(this\.typed\[key\] \?\? shown\)\}/)
-  has(panel, /this\.typed = \{ \.\.\.this\.typed, \[key\]: \(ev\.target as HTMLInputElement\)\.value \}/)
-})
-
 test('면마다 벽 두께를 치는 동안에도 그려진다 — 명령이 없앤 입력(한 벽 두께)의 지금 값은 미리보기를 막지 않는다', async () => {
   const { liveOverSession } = await import('../client/modeller/live.ts')
   const tray = applyFigureAuthoring(probe(), { kind: 'set-cavity', part: 'body', cavity: { wall: 30, start: { closed: 30 }, end: 'open' } })
@@ -194,5 +194,10 @@ test('한 면의 벽 한도는 그 방향의 너비에서 맞은편 벽을 뺀
   /* The kernel agrees: just under takes, the limit refuses. */
   assert.equal(cavityRefusalOf(shape, cavityRequestOf(shape, { wall: { ...walls, 'x-': 359 } })), null)
   assert.equal(cavityRefusalOf(shape, cavityRequestOf(shape, { wall: { ...walls, 'x-': 360 } }))!.code, 'wall-too-thick')
-  has(drawing, /this\.perSide && side \? mm\(sideWallLimitOf\(this\.body!\.shape, w\.wall, side\)\) : ask\.max/)
+  /* The drawing says that side's most with the walls one per side, and the kernel's all-round most otherwise. */
+  const over = { wall: { ...walls, 'x-': 380 }, start: { closed: 30 }, end: 'open' as const }
+  assert.deepEqual(cavityRefusalWordsOf(shape, over, true, 'x-'), { key: 'figure.text.section-wall-over', params: { max: '360' } })
+  assert.deepEqual(cavityRefusalWordsOf(shape, over, false, 'x-'), { key: 'figure.text.section-wall-over', params: { max: String(wallLimitOf(shape)) } })
+  assert.deepEqual(cavityRefusalWordsOf(shape, { ...over, wall: walls, start: { closed: 120 }, end: { closed: 90 } }, false), { key: 'figure.text.section-ends-over', params: { max: '200' } })
+  assert.equal(cavityRefusalWordsOf(shape, { ...over, wall: walls }, true, 'x-'), null)
 })