@things-factory/figure-ui 10.1.146 → 10.1.149

package/test/figure-assistant-surface.test.ts

@@ -1,58 +1,52 @@
 /*
  * The modeller's AI - the framework dock talks about the figure on screen (design/ai/shared-dock.md §3).
  *
- * What this holds: ① a saved figure provides a surface anchored on its row ② the draft is read at the moment of
- * sending, not when the surface was provided ③ an unsaved figure provides nothing - no conversation without a row
- * ④ the page takes the surface back when it goes inactive or leaves. The page pulls in the shell and things-scene,
- * so this reads its source.
+ * What the page does with the dock -- ① a saved figure provides a surface anchored on its row ② the draft is read at the
+ * moment of sending ③ an unsaved figure provides nothing ④ the surface is taken back when the page goes inactive or
+ * leaves ⑤ a proposal is taken through the page, and a new figure's opens a new figure -- is checked on the page itself
+ * in test/browser/product-page.check.mjs. Here: the offer the page takes it by, and the words every outcome is said in.
  */
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import { test } from 'node:test'
+import { addFigureBox, createFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
 
-const source = readFileSync(fileURLToPath(new URL('../client/pages/figure-modeller-page.ts', import.meta.url)), 'utf8')
+import { createFigureProductSession } from '../client/modeller/product-session.js'
+import { takeFigureOffer, type FigureApplyDetail } from '../client/modeller/ai-proposal.js'
 
-test('a saved figure provides a surface anchored on its row', () => {
-  assert.match(source, /provideAssistantSurface\(this, \{/)
-  assert.match(source, /subject: 'figure'/)
-  assert.match(source, /anchor: \(\) => \(\{ anchorType: 'figure', anchorId: id \}\)/)
-})
-
-test('the draft is read when the message is sent, as host context the figure tools read', () => {
-  assert.match(source, /hostContext: \(\) => \(\{[\s\S]*?figureId: id,[\s\S]*?draftSource: JSON\.parse\(this\.session\.source\(\)\),[\s\S]*?context: this\.session\.read\(\)\.context,\s*revision: this\.session\.read\(\)\.revision,/)
-})
-
-test('an unsaved figure provides nothing', () => {
-  assert.match(source, /if \(!view\.id\) \{\s*this\.withdrawAssistant\(\)/)
-})
-
-test('the surface is taken back when the page goes inactive or leaves', () => {
-  const withdraws = source.match(/this\.withdrawAssistant\(\)/g) ?? []
-  assert.ok(withdraws.length >= 3, 'unsaved, inactive and disconnected each withdraw')
-  assert.doesNotMatch(source, /figure-ai-context/, 'the old window-event channel is gone')
-})
+const say = (key: string) => key
+const K1 = '11111111-1111-4111-8111-111111111111'
+const lid = [{ kind: 'add-part', part: { id: 'lid', kind: 'box', dimensions: { width: 100, height: 10, depth: 100 } } }] as never[]
 
-test('the dock applies a proposal through the page, on the version the model saw', () => {
-  assert.match(source, /window\.addEventListener\('figure-apply', this\.applyAI\)/)
-  /* The page takes it by `takeFigureOffer` (ai-proposal.ts), tested there on the session itself. */
-  assert.match(source, /takeFigureOffer\(this\.session, detail, \{/)
-  const offer = readFileSync(fileURLToPath(new URL('../client/modeller/ai-proposal.ts', import.meta.url)), 'utf8')
-  assert.match(offer, /session\.applyProposal\(detail\.steps, detail\.revision!, detail\.context!, detail\.key\)/)
-  assert.match(source, /this\.takeNewFigureProposal\(\)/, 'a new figure opened for a proposal takes its steps')
+test('the dock applies a proposal through the page, on the version the model saw', async () => {
+  const source = serializeFigureAsset(addFigureBox(createFigureAsset('A'), { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } }))
+  const session = createFigureProductSession({ load: async (id: string) => ({ id, source }), save: async (q: { id?: string; source: string }) => ({ id: q.id ?? 'a', source: q.source }) })
+  await session.open('a')
+  const seen = session.read()
+  /* The person edits meanwhile: the version the model saw is gone, and the proposal is refused, not put on top. */
+  session.command({ kind: 'rename', name: 'B' } as never)
+  const stale: FigureApplyDetail = { key: K1, steps: lid, create: false, context: seen.context, revision: seen.revision }
+  assert.equal(takeFigureOffer(session, stale, { onSavedFigure: true, say }), false)
+  assert.deepEqual({ applied: stale.applied, code: stale.code }, { applied: false, code: 'REVISION_CONFLICT' })
+  assert.deepEqual(session.proposalsInEffect(), [])
+  /* On the version now: applied as one step, under the proposal's key. */
+  const now = session.read()
+  const fresh: FigureApplyDetail = { key: K1, steps: lid, create: false, context: now.context, revision: now.revision }
+  assert.equal(takeFigureOffer(session, fresh, { onSavedFigure: true, say }), true)
+  assert.equal(fresh.applied, true)
+  assert.equal(session.read().revision, now.revision! + 1)
+  assert.deepEqual(session.proposalsInEffect(), [K1])
+  /* A new figure's proposal is not for a page on a saved figure: left untaken, so the handler opens a new one. */
+  const create: FigureApplyDetail = { key: K1, steps: lid, create: true }
+  assert.equal(takeFigureOffer(session, create, { onSavedFigure: true, say }), false)
+  assert.equal(create.applied, undefined)
 })
 
 test('a figure proposal is answered by its handler, in words, never left without one', () => {
-  const handler = readFileSync(fileURLToPath(new URL('../client/figure-assistant.ts', import.meta.url)), 'utf8')
-  assert.match(handler, /registerProposalHandler\(FIGURE_CANDIDATE_TOOL,/)
-  assert.match(handler, /export const FIGURE_CANDIDATE_TOOL = 'proposeFigureCandidate'/)
-  assert.match(handler, /runFigureProposal\(/)
-  assert.match(handler, /context\.notify\(/)
   for (const lang of ['en', 'ko', 'ja', 'zh', 'ms', 'es']) {
     const words = JSON.parse(readFileSync(fileURLToPath(new URL(`../translations/${lang}.json`, import.meta.url)), 'utf8'))
     for (const key of ['applied', 'stale', 'refused', 'needs-modeller', 'not-opened', 'new-figure-unsaved'])
       assert.ok(words[`figure.text.proposal-${key}`], `${lang} has no words for proposal-${key}`)
   }
-  const index = readFileSync(fileURLToPath(new URL('../client/index.ts', import.meta.url)), 'utf8')
-  assert.match(index, /figure-assistant\.js/)
 })

package/test/first-minute.test.ts

@@ -31,78 +31,26 @@ test('a selected part at the head: its kind, and what its size follows only when
   assert.ok(!/규칙을 따름|규칙으로 결정됨|규칙이 정하는|도형을 따라감|크기 고정|붙임 없음/.test(JSON.stringify(ko)), 'the words nobody knew are gone')
 })
 
-test('a new figure asks what to start with -- a shape, a recipe, an AI draft where offered -- and adds nothing by itself', () => {
-  const editor = read('../client/modeller/editor.ts')
-  const start = editor.slice(editor.indexOf('  private renderStart() {'), editor.indexOf('  /**\n   * Which part the panel speaks of'))
-  assert.ok(start.includes("['box', 'cylinder', 'plate']") && start.includes('@click=${() => this.add(kind)}'), 'a shape, on the author\'s click')
-  assert.ok(start.includes('this.catalogOpen = true'), 'a recipe')
-  assert.ok(start.includes('${this.aiDraft') && start.includes("new CustomEvent('ask-ai-draft'"), 'an AI draft, only where the page offers it')
-  assert.ok(editor.includes('${view.geometry.length === 0 && !unavailable ? this.renderStart() : nothing}'), 'only while the figure is empty')
-  assert.ok(editor.includes('<summary>${i18next.t(\'figure.label.figure-info-later\')}</summary>'), 'the figure\'s own settings wait, folded')
-  const page = read('../client/pages/figure-modeller-page.ts')
-  assert.ok(page.includes("aiDraft @ask-ai-draft=${() => askAssistant({ draft: i18next.t('figure.text.ai-draft-request') })}"), 'the app puts a draft request in the dock, not sent')
-  const parts = read('../client/modeller/figure-parts.ts')
-  assert.ok(parts.includes('if (!b || (!this.parts.length && !b.level)) return nothing'), 'the detail level comes after the first part (U09)')
-})
-
 test('the side tabs say their names, in every language', () => {
-  const editor = read('../client/modeller/editor.ts')
-  assert.ok(editor.includes("const name = i18next.t('figure.label.tab-short-' + tab)"))
-  assert.ok(editor.includes('aria-label=${name}'), 'its accessible name is the name it shows')
-  assert.ok(editor.includes('<span tab-label aria-hidden="true">${name}</span>'))
+  /* The name under each icon, and its accessible name, are the browser check's (test/browser/screen.check.mjs). */
   for (const lang of ['ko', 'en', 'ja', 'zh', 'ms', 'es']) {
     const table = JSON.parse(read(`../translations/${lang}.json`))
     for (const tab of ['properties', 'capability', 'motion', 'verdict', 'view', 'history']) assert.ok(table[`figure.label.tab-short-${tab}`], `${lang} ${tab}`)
   }
 })
 
-test('narrow, the parts list folds for the canvas, said once, and stays open once the author opens it', () => {
-  const editor = read('../client/modeller/editor.ts')
-  const fit = editor.slice(editor.indexOf('  private fitPanesTo(width: number) {'), editor.indexOf('  /**\n   * Refusals and notices'))
-  assert.ok(fit.includes('if (this.foldedForWidth && !panes.foldStart) this.keptOpenByAuthor = true'), 'opened by the author, left open')
-  assert.ok(fit.includes("notify({ level: 'info', message: i18next.t('figure.text.parts-panel-folded-narrow') })"), 'said')
-  assert.ok(fit.includes('if (this.foldedForWidth && panes.foldStart) panes.foldStart = false'), 'wide again, opened again')
-  assert.ok(editor.includes('private static readonly FOLD_START_UNDER = 1100'))
-})
-
-test('a palette part\'s own sizes are its shape\'s fields, not a rule\'s: no "set by a rule" size row for them', () => {
-  const editor = read('../client/modeller/editor.ts')
-  assert.ok(editor.includes("sizeRuled: (['x', 'y', 'z'] as const).every(axis => followOf(shown.asset, ownerOf(this.selected), axis).of !== 'own')"))
-  assert.ok(editor.includes('if (!held?.sizeRuled ||'))
-})
-
 /* Designer 2026-09-27: the placement is chosen before any part, as the figure's own setting -- no room, no part made up. */
 test('the start card and the figure panel choose the placement as the figure\'s own setting', async () => {
   const { createFigureAsset, applyFigureAuthoring } = await import('@hatiolab/figure-model')
   const hung = applyFigureAuthoring(createFigureAsset('New'), { kind: 'set-placement', placement: 'ceiling' })
   assert.equal(hung.placement, 'ceiling')
   assert.equal(hung.occupancy, undefined)
-  const editor = read('../client/modeller/editor.ts')
-  assert.ok(editor.includes("this.linkCommand({ kind: 'set-placement', placement: one })"), 'on the start card')
-  const properties = read('../client/modeller/figure-properties.ts')
-  assert.ok(properties.includes("this.command({ kind: 'set-placement', placement: select.value as Placement })"), 'in the figure panel')
-  assert.ok(!properties.includes('?disabled=${!facts.parts.length}\n          .value=${live(current)}'), 'not waiting for a part')
+  /* Chosen on the start card and in the figure panel, before any part: the browser check's (test/browser/screen.check.mjs). */
 })
 
 /* B.1 and the designer's items (2026-09-27): each target's panel is found as it was left; the fastening form says which it is. */
-test('the panel remembers its scroll and folds per model and part, and forgets them for another model', () => {
-  const editor = read('../client/modeller/editor.ts')
-  assert.ok(editor.includes("if (panel) this.panelMemory.set(was || '@model', { top: panel.scrollTop, open: this.foldsOf(panel).map(d => d.open) })"))
-  assert.ok(editor.includes('panel.scrollTop = kept?.top ?? 0'))
-  assert.ok(editor.includes('this.panelMemory.clear()'), 'another model starts clean')
-  assert.ok(editor.includes("position: sticky;"), 'the path stays in view whatever the scroll')
-})
-
 test('the fastening form says whether it edits the current relation or fastens anew', () => {
-  const links = read('../client/modeller/figure-links.ts')
-  /* Anew is said; the one it has is said once, by the sentence over the drawing (user 2026-10-01: no third line). */
-  assert.ok(links.includes("${current ? nothing : html`<p fasten-mode>${editing}</p>`}"))
-  assert.ok(links.includes('<p fasten-sentence>'))
-  /* A fastening the part has is changed as soon as something is chosen (2026-10-02): 붙이기 only for a new one. */
-  assert.ok(links.includes("${held\n        ? nothing\n        : html`<button act ?disabled=${this.locked || !action} @click=${() => action && this.command(action)}>"))
-  assert.ok(links.includes('if (value) settle()'), 'another target taken at once')
-  assert.ok(links.includes("action && !held && this.working === 'fasten' ? this.renderPreviewWords() : nothing"), 'no words for a command no button sends')
-  assert.ok(links.includes('const settle = () => this.onFastenRelease(!!held)'))
+  /* Anew is said, the one it has changed at once, 붙이기 only for a new one: the browser check's (test/browser/screen.check.mjs). Here, the words. */
   const ko = JSON.parse(read('../translations/ko.json'))
   assert.equal(ko['figure.text.fasten-new'], '새로 붙이기')
   assert.equal(ko['figure.button.fasten-update'], undefined)

package/test/first-save-suggest.test.ts

@@ -8,7 +8,7 @@ import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import { isPlaceholderType, TYPE_LENGTH, TYPE_PATTERN } from '@hatiolab/figure-model'
 
-import { suggestTypeOf, releasableType } from '../client/modeller/first-save.js'
+import { offeredTypeOf, suggestTypeOf, releasableType } from '../client/modeller/first-save.js'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 
@@ -27,14 +27,17 @@ test('an identifier is offered for any name: plain letters as they are, anything
   assert.equal(suggestTypeOf('선반', ['fig-000000'], () => draws[n++ % draws.length]!), 'fig-iiiiii')
 })
 
+/* The question itself -- the name first and focused, a retry on the identifier answered -- is checked in product-page.check.mjs. */
 test('the first save asks the name first; the identifier offered stays through retries, and renaming does not change it', () => {
-  const popup = read('../client/modeller/figure-first-save.ts')
-  assert.ok(popup.indexOf('<label for="name">') < popup.indexOf('<label for="type">'), 'the name first')
-  assert.ok(/id="name"\s+autofocus/.test(popup), 'the name has the focus')
-  assert.ok(!popup.includes('this.type = this.suggested = suggestTypeOf(this.name, this.taken)\n          }}'), 'typing a name does not redraw it')
-  assert.ok(popup.includes('if (!this.type || offeredAndTaken) this.type = this.suggested = suggestTypeOf(this.name, this.taken)'), 'offered again only when empty, or offered and taken')
-  const page = read('../client/pages/figure-modeller-page.ts')
-  assert.ok(page.includes('if (answer) this.row = { ...this.row, type: answer.type }'), 'a retry opens on the identifier answered before')
+  /* None yet: one is offered, from the name. */
+  assert.deepEqual(offeredTypeOf('', 'Lift table', []), { type: 'lift-table', suggested: 'lift-table' })
+  /* Offered before and still free, or typed by the author: kept as it is. */
+  assert.deepEqual(offeredTypeOf('fig-abc123', 'Lift table', []), { type: 'fig-abc123', suggested: 'fig-abc123' })
+  assert.deepEqual(offeredTypeOf('my-lift', 'Other name', []), { type: 'my-lift' })
+  /* Offered and found taken: offered again. Typed and taken: kept as typed -- its refusal is said when saving. */
+  assert.deepEqual(offeredTypeOf('fig-abc123', 'Lift table', ['fig-abc123']), { type: 'lift-table', suggested: 'lift-table' })
+  assert.deepEqual(offeredTypeOf('my-lift', 'Lift table', ['my-lift']), { type: 'my-lift' })
+  assert.deepEqual(offeredTypeOf('fig-abc123', '선반', ['fig-abc123'], () => 0), { type: 'fig-000000', suggested: 'fig-000000' })
   for (const lang of ['en', 'ja', 'ko', 'ms', 'zh', 'es']) {
     const t = JSON.parse(read(`../translations/${lang}.json`))
     assert.ok(t['figure.label.figure-identifier'] && t['figure.text.identifier-suggested'], lang)

package/test/first-save.test.ts

@@ -66,29 +66,7 @@ test('타입을 주지 않으면 싣지 않는다 — 서버가 임시 이름을
   assert.equal('type' in requests[0]!, false)
 })
 
-test('저장 전에 적은 타입은 처음 저장의 물음에 실려 온다 — 칸이 막혀 있어 적어도 사라졌다 (09-25)', async () => {
-  const { readFileSync } = await import('node:fs')
-  const page = readFileSync(new URL('../client/pages/figure-modeller-page.ts', import.meta.url), 'utf8')
-  const field = page.slice(page.indexOf('<label slot="type" type-field>'), page.indexOf('</label>', page.indexOf('<label slot="type" type-field>')))
-  assert.doesNotMatch(field, /disabled=\$\{!view\.id\}/, '저장 전에도 칸에 적을 수 있다')
-  const rename = page.slice(page.indexOf('private renameType'), page.indexOf('private fitToParts'))
-  assert.match(rename, /if \(!id\) \{\s*this\.row = \{ \.\.\.this\.row, type: wanted \|\| undefined \}/, '저장 전에는 행 대신 화면이 타입을 쥔다')
-  assert.match(page, /<figure-first-save \.type=\$\{this\.row\.type \?\? ''\}/, '물음은 그 타입으로 열린다')
-})
-
-test('처음 저장한 도형은 주소가 제 것이 된다 — 모델러를 다시 열면 새 도형이 열린다 (2026-09-25)', async () => {
-  const { readFileSync } = await import('node:fs')
-  const page = readFileSync(new URL('../client/pages/figure-modeller-page.ts', import.meta.url), 'utf8')
-  const changed = page.slice(page.indexOf('private changed = () => {'), page.indexOf('private async readRow'))
-  assert.match(changed, /if \(view\.id && !this\.routeId && !view\.saving\) \{\s*this\.routeId = view\.id\s*navigate\(modellerPathOf\(\{ id: view\.id \}\), true\)/, '저장으로 id 를 얻으면 그 주소로 바꾼다(기록은 덮어쓴다)')
-  /* The early return that kept the old figure reads the route id; it now matches only the figure the address names. */
-  assert.match(page, /if \(this\.session\.read\(\)\.context && id === this\.routeId && !changes\.active\) return/)
-})
-
-test('다른 도형을 열면 행을 먼저 비운다 — 앞 도형의 타입이 칸에 남지 않는다 (C2, 2026-09-25)', async () => {
-  const { readFileSync } = await import('node:fs')
-  const page = readFileSync(new URL('../client/pages/figure-modeller-page.ts', import.meta.url), 'utf8')
-  const updated = page.slice(page.indexOf('async pageUpdated'), page.indexOf('private askFirstSave'))
-  const opening = updated.slice(updated.indexOf('if (id) {'), updated.indexOf('this.session.open(id'))
-  assert.match(opening, /this\.row = \{ version: 0 \}/, '열기 전에 행을 비운다')
-})
+/*
+  On the page -- a type written before the first save carried into its question, the address made the figure's own,
+  the row emptied before another figure opens -- see test/browser/product-page.check.mjs.
+*/

package/test/gizmo.test.ts

@@ -81,15 +81,10 @@ test('크기는 배율만큼 치수를 바꾸고 1mm 아래로 가지 않는다'
 test('끈 것은 세션의 한 걸음이다 — 한 번의 되돌리기로 돌아간다', () => {
   const workspace = createFigureEditorWorkspace() as unknown as Record<string, Function>
   assert.ok(typeof workspace.apply === 'function')
-  const editor = read('../client/modeller/editor.ts')
-  const moved = editor.slice(editor.indexOf('  private transformed('), editor.indexOf('  /** 맞추기'))
-  assert.ok(moved.includes('this.run(() => this.session!.apply(changes))'), 'one apply, one step')
-  assert.ok(moved.includes("kind: 'nudge-part',"), 'a nudge is one command, one step')
 })
 
 test('캔버스 — 기즈모 · W E R · 스냅은 씬의 편집 모드가 한다', () => {
   const canvas = read('../client/modeller/canvas.ts')
-  assert.match(canvas, /mode: 1\n/)
   assert.doesNotMatch(canvas, /TransformControls|OrbitControls/)
 })
 
@@ -110,14 +105,6 @@ test('떼어 낸 부품은 다시 옮길 수 있다 — 움직임이 있는 부
   assert.equal(gizmoReachOf(slid as never, 'lid').translate, false, 'not its own numbers: a drag on a joint edits the joint (joint-drag)')
 })
 
-test('끄는 동안은 모아 두고 놓을 때 한 번 적는다 — 크기 기즈모가 편집기와 싸우지 않는다', () => {
-  const canvas = read('../client/modeller/canvas.ts')
-  const watch = canvas.slice(canvas.indexOf('  private watchScene()'), canvas.indexOf('  /** Components the gizmo changed'))
-  assert.ok(watch.includes('this.pending.set(name, origin!)') && watch.includes('if (!this.pointerDown) this.commitSoon(80)'), '사용자 2026-09-24: 「기즈모 컨트롤 중에 scale은 제대로 작동하지 않는군」')
-  assert.ok(!watch.includes("new CustomEvent('part-transformed'"), '움직일 때마다 알리지 않는다')
-  assert.ok(canvas.includes('private onPointerUp = () => {') && canvas.includes('this.commitSoon(0)'))
-})
-
 
 test('원기둥 · 구도 크기 기즈모가 먹는다 — 단면은 원으로', async () => {
   const { addFigurePrimitive, createFigureAsset } = await import('@hatiolab/figure-model')
@@ -167,22 +154,10 @@ test('크기 칸과 손잡이 — 배치가 지키는 면을 지킨다, 커널
   let hung = addFigureBox(createFigureAsset('Lamp'), { id: 'lamp', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: -50, z: 0 } })
   hung = applyFigureAuthoring(hung, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(hung), placement: 'ceiling' })
   assert.equal(centreY(grow(hung, 'lamp', gizmoReachOf(hung, 'lamp').sizes![1], 300), 'lamp') + 300 / 2, 0, '천장 도형: 윗면이 천장에')
-  const editor = read('../client/modeller/editor.ts')
-  assert.ok(editor.includes('figureSizeEditChanges(this.shown()!.asset, part, [change])'), '숫자 칸이 부른다')
-  assert.ok(editor.includes('figureSizeEditChanges(asset, ownerOf(id), written)'), '손잡이도 부른다')
-  assert.ok(!read('../client/modeller/gizmo.ts').includes('keepBottomChanges'), '화면의 제 산수는 없다')
 })
 
 /* 손잡이는 키를 몰라도 찾는다 — 도구 막대에 옮기기 · 돌리기 · 크기, 제 숫자로 놓인 부품에만 (09-26). */
 test('도구 막대의 옮기기 · 돌리기 · 크기 — 키와 같은 길, 되쓸 수 있는 것만', () => {
-  const editor = read('../client/modeller/editor.ts')
-  const bar = editor.slice(editor.indexOf('return html`<ox-canvas-bar'), editor.indexOf('</ox-canvas-bar>'))
-  assert.ok(bar.includes("this.renderGizmoTools(!unavailable && this.middle === 'edit')"), '편집 중에만')
-  const tools = editor.slice(editor.indexOf('  private renderGizmoTools('), editor.indexOf("  /** The modeller's keys"))
-  for (const [mode, key, can] of [['translate', 'W', 'translate'], ['rotate', 'E', 'rotate'], ['scale', 'R', 'scale']])
-    assert.ok(tools.includes(`mode: '${mode}'`) && tools.includes(`key: '${key}'`) && tools.includes(`can: !!reach?.${can}`), mode)
-  assert.ok(tools.includes('@click=${() => this.useGizmo(tool.mode)}'))
-  assert.match(editor, /action === 'scale'\) canvas && this\.useGizmo\(action\)/, '키도 같은 길로 — 눌린 단추가 맞다')
   const ko = JSON.parse(read('../translations/ko.json'))
   assert.deepEqual(['translate', 'rotate', 'scale'].map(m => ko['figure.button.gizmo-' + m]), ['옮기기', '돌리기', '크기 바꾸기'])
 })

package/test/joint-fan.test.ts

@@ -16,8 +16,6 @@ import { revisionOf } from './revision-of.ts'
 import { liveOverSession } from '../client/modeller/live.ts'
 import { moving } from './joints.ts'
 
-const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
-
 function arm(): FigureAsset {
   let asset = createFigureAsset('Probe')
   asset = addFigureBox(asset, { id: 'base', size: { x: 200, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
@@ -84,14 +82,6 @@ test('no fan for a part that does not turn, nor for a slide -- a fan in a guesse
   assert.equal(jointFanOf(revisionOf(slider), 'block'), null)
 })
 
-test('the editor draws it for the selected part; the canvas never lets it be picked', () => {
-  const editor = read('../client/modeller/editor.ts')
-  assert.ok(editor.includes('.fan=${this.fanOf(shown, live)}'))
-  const canvas = read('../client/modeller/canvas.ts')
-  /* The fan, and what a command would do, are shown and never picked (ADR-0097 §5.5). */
-  assert.ok(canvas.includes('.map(c => ({ ...c, capturable: false, locked: true }))'))
-})
-
 /*
  * The fan stands where the joint is drawn: the pose set with the controls (the version's inputs), and while a control is
  * dragged, the pose in hand -- the same as a version where that pose was set (user 2026-09-24: the arm jumped on release).

package/test/keys.test.ts

@@ -3,8 +3,6 @@
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
 
 import { keyActionOf } from '../client/modeller/keys.ts'
 
@@ -30,11 +28,6 @@ test('칸에 치는 키는 칸의 것 — 이름 칸의 Backspace 는 글자를
   assert.equal(keyActionOf({ key: 'Delete', target: { tagName: 'CANVAS' } }, 'arm'), 'remove')
 })
 
-test('편집기가 창의 키를 듣고, 떼어지면 놓는다', () => {
-  const editor = readFileSync(fileURLToPath(new URL('../client/modeller/editor.ts', import.meta.url)), 'utf8')
-  assert.ok(editor.includes("window.addEventListener('keydown', this.onKey, true)") && editor.includes("window.removeEventListener('keydown', this.onKey, true)"))
-})
-
 test('W · E · R 은 gizmo 의 모드 — 부품 목록에서 골라 포커스가 캔버스 밖에 있어도', () => {
   assert.equal(keyActionOf({ key: 'w' }, 'arm'), 'translate')
   assert.equal(keyActionOf({ key: 'E' }, 'arm'), 'rotate')

package/test/layout.test.ts

@@ -2,7 +2,7 @@
  * **모델러의 구성 — 세 칸과 오른쪽 탭** (사용자 2026-09-24).
  *
  * 부품 목록 · 캔버스 · 오른쪽 칸(아이콘 탭 여섯). 전에는 부품 속성이 캔버스 아래 좁은 칸에 끼어 있었다.
- * 이 시험은 소스에서 그 구성을 확인한다.
+ * 그 구성은 브라우저 검사(`test/browser/screen.check.mjs`)가 확인하고, 여기서는 화면의 말을 본다.
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
@@ -13,57 +13,8 @@ const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.m
 const editor = read('../client/modeller/editor.ts')
 const renderBody = editor.slice(editor.indexOf('  render() {'), editor.indexOf('  private renderField('))
 
-test('세 칸 — 부품 목록 · 캔버스 · 오른쪽 칸, 캔버스 아래에는 아무것도 없다', () => {
-  /* The three panes are ox-three-pane's (ADR-0060 decision 8): parts in start, the canvas in the middle, the side in end. */
-  const main = renderBody.slice(renderBody.indexOf('<ox-three-pane'), renderBody.indexOf('</ox-three-pane>'))
-  const order = ['<figure-parts', '<figure-canvas', '<aside slot="end">'].map(tag => main.indexOf(tag))
-  assert.match(main, /<figure-parts\s+slot="start"/, '부품 목록은 왼쪽 칸')
-  assert.ok(order.every(i => i >= 0) && order[0]! < order[1]! && order[1]! < order[2]!, '부품 · 캔버스 · 오른쪽 칸 순서')
-  assert.equal((main.match(/<aside/g) ?? []).length, 1, '오른쪽 칸은 하나 — 페이지가 따로 칸을 두지 않는다')
-  assert.doesNotMatch(read('../client/pages/figure-modeller-page.ts'), /<aside/)
-})
-
-test('오른쪽 칸의 탭 여섯: 속성 · 능력 · 움직임 · 판정 · 환경 · 이력, 판정의 개수는 탭에 남는다', () => {
-  const tabs = [...renderBody.matchAll(/this\.renderTab\('([a-z]+)'/g)].map(m => m[1])
-  assert.deepEqual(tabs, ['properties', 'capability', 'motion', 'verdict', 'view', 'history'])
-  for (const tab of tabs) assert.ok(renderBody.includes(`?off=\${tab !== '${tab}'}`), `${tab} 는 감추되 떼지 않는다`)
-})
-
-test('부품을 고르면 — 도형 전체의 탭(판정 · 이력)은 그 부품의 속성으로 넘어가고, 부품 탭은 새 부품을 보여 준다', () => {
-  const choose = editor.slice(editor.indexOf('  private choose('), editor.indexOf('  private asset()'))
-  assert.match(choose, /this\.selected = id/)
-  assert.match(choose, /if \(id && \(this\.tab === 'verdict' \|\| this\.tab === 'view' \|\| this\.tab === 'history'\)\) this\.tab = 'properties'/)
-  for (const from of ['@select-part=${(e: CustomEvent) => this.choose(e.detail.id)}', '@part-selected=${(e: CustomEvent<string>) => this.choose(e.detail)}'])
-    assert.ok(renderBody.includes(from), from)
-})
-
-/* B.1 (designer 2026-09-27), amended by the user 2026-10-01: no path -- the list and the canvas show the choice; the list's root goes back. */
-test('패널 머리에는 경로가 없고 부품의 세 줄만 — 모델 설정은 목록 루트의 한 동작으로 연다', () => {
-  assert.ok((renderBody.match(/\$\{this\.renderSubject\(\)\}/g) ?? []).length >= 3)
-  const subject = editor.slice(editor.indexOf('  private renderSubject()'), editor.indexOf('  private showModelSettings()'))
-  assert.ok(!subject.includes('<nav path'), 'no path')
-  assert.ok(subject.includes('if (!summary) return nothing'), 'nothing chosen: no head')
-  const show = editor.slice(editor.indexOf('  private showModelSettings()'), editor.indexOf('  render() {'))
-  assert.ok(show.includes("this.selected = ''") && show.includes("this.tab = 'properties'"), 'the model settings, on the properties tab')
-  assert.ok(!/session!?\.(command|apply|edit|undo)/.test(show), 'moving changes no data and no history')
-  assert.ok(editor.includes('@show-model-settings=${() => this.showModelSettings()}'), 'the list root, the same move')
-})
-
-test('탭마다 제자리 — 속성엔 부품의 모양 · 재질, 자리와 능력엔 사다리와 자리, 움직임엔 움직임 · 조작값', () => {
-  const panel = (tab: string) => {
-    const start = renderBody.indexOf(`?off=\${tab !== '${tab}'}`)
-    return renderBody.slice(start, renderBody.indexOf('<div panel', start + 1))
-  }
-  assert.ok(panel('properties').includes("this.renderLinks(unavailable, 'shape')") && panel('properties').includes('<figure-material-panel'))
-  assert.ok(panel('capability').includes("this.renderLinks(unavailable, 'places')") && panel('capability').includes('<figure-capability-panel'))
-  assert.ok(panel('motion').includes("this.renderLinks(unavailable, 'motion')") && panel('motion').includes('this.renderControls('))
-})
-
 test('띠 — 칸 접기 · 되돌리기 · 전체 보기 · 저장 상태 · 저장, 말은 번역에서', () => {
-  /* The bar is ox-canvas-bar: folds at its edges (it folds the frame it is given), undo · redo · fit in the suite's places. */
-  const bar = renderBody.slice(renderBody.indexOf('<ox-canvas-bar'), renderBody.indexOf('</ox-canvas-bar>'))
-  for (const piece of ['.pane=${this.panes}', 'history', 'fit', 'undo-shortcut="Ctrl+Z"', 'redo-shortcut="Ctrl+Y"', 'session!.undo()', 'session!.redo()', '.fit()', 'role="status"', '@click=${this.save}'])
-    assert.ok(bar.includes(piece), piece)
+  /* The bar itself -- its folds, undo · redo · fit, the status and save -- is the browser check's (test/browser/screen.check.mjs). */
   assert.doesNotMatch(renderBody, /[가-힣]/, '편집기의 화면 말에 한국어가 박혀 있지 않다')
   const keys = [...editor.matchAll(/'(figure\.[a-z.-]*[a-z])'/g)].map(m => m[1])
   for (const lang of ['ko', 'en', 'ja', 'zh', 'ms', 'es']) {
@@ -72,24 +23,9 @@ test('띠 — 칸 접기 · 되돌리기 · 전체 보기 · 저장 상태 ·
   }
 })
 
-test('탭 아이콘은 오른쪽 칸 맨 위 — 타입 칸은 속성 탭 안의 첫 칸', () => {
-  const aside = renderBody.slice(renderBody.indexOf('<aside slot="end">'), renderBody.indexOf('</aside>'))
-  assert.match(aside, /^<aside slot="end">\s*<div tabs>/, '탭이 첫째')
-  const properties = aside.slice(aside.indexOf("?off=${tab !== 'properties'}"), aside.indexOf("?off=${tab !== 'capability'}"))
-  assert.ok(properties.includes('<slot name="figure"></slot>'))
-  const figure = read('../client/modeller/figure-properties.ts')
-  assert.match(figure, /<h3>\$\{i18next\.t\('figure\.label\.group-figure'\)\}<\/h3>\s*<slot name="type"><\/slot>/, '타입은 「도형」 절의 첫 칸')
-  const page = read('../client/pages/figure-modeller-page.ts')
-  assert.ok(page.includes('<label slot="type" type-field>'))
-})
-
 /* User 2026-10-01: 「맞추기 아이콘 … 무엇을 하는 것인지 모르겠다」 -- words, and what moves the part apart from what makes one. */
 test('맞추기는 글자 단추로 — 옮기는 넷(가운데 X·Z, 면에 대기, 눈금)과 새 부품을 만드는 대칭 복사를 다른 줄에 둔다', () => {
-  const tools = editor.slice(editor.indexOf('  private renderTools('), editor.indexOf("  /**\n   * A part's name."))
-  assert.ok(!tools.includes('<md-icon>'), 'no icon-only buttons')
-  assert.ok(tools.includes("i18next.t('figure.label.tools')") && tools.includes("i18next.t('figure.label.mirror-copy')"), 'two rows, each named')
-  const plane = editor.slice(editor.indexOf('  private renderPlaneAlign('), editor.indexOf('  private alignToPlane()'))
-  assert.ok(!plane.includes('<md-icon>') && plane.includes('figure.button.align-to-${placement}'))
+  /* The two rows and their buttons in words are the browser check's (test/browser/screen.check.mjs); here, the words. */
   const ko = JSON.parse(readFileSync(fileURLToPath(new URL('../translations/ko.json', import.meta.url)), 'utf8')) as Record<string, string>
   assert.deepEqual(
     ['center-x', 'center-z', 'align-to-floor', 'snap', 'mirror-x'].map(k => ko[`figure.button.${k}`]),
@@ -99,12 +35,7 @@ test('맞추기는 글자 단추로 — 옮기는 넷(가운데 X·Z, 면에 대
 })
 
 test('불러오는 동안 빈 무대에 「도형을 추가해…」가 깜빡이지 않고, 좁은 화면 알림은 이 브라우저에서 한 번', () => {
-  const canvas = read('../client/modeller/canvas.ts')
-  /* A new figure's start card says how to begin; an empty stage otherwise is one loading, or with every part hidden. */
-  assert.ok(canvas.includes('return html`<div stage></div>`'))
-  assert.ok(!canvas.includes('add-a-shape-to-start') && !editor.includes('startShown'))
+  /* A new figure's start card says how to begin; an empty stage otherwise is one loading, or with every part hidden. The bare stage and the notice said once are the browser check's (test/browser/screen.check.mjs). */
   for (const lang of ['ko', 'en', 'ja', 'zh', 'ms', 'es'])
     assert.equal((JSON.parse(read(`../translations/${lang}.json`)) as Record<string, string>)['figure.text.add-a-shape-to-start'], undefined, lang)
-  assert.ok(editor.includes("if (!foldSaid()) notify({ level: 'info', message: i18next.t('figure.text.parts-panel-folded-narrow') })"))
-  assert.ok(/function foldSaid\(\): boolean \{\s*try \{\s*if \(localStorage\.getItem\('figure-fold-said'\)\) return true\s*localStorage\.setItem\('figure-fold-said', '1'\)\s*\} catch/.test(editor), 'storage refused: said, as before')
 })