@things-factory/figure-ui 10.1.79 → 10.1.82

package/test/first-minute.test.ts

@@ -0,0 +1,96 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { addFigureBox, applyFigureAuthoring, applyFigureProposal, createFigureAsset, planFigureResize, proposeFigureOccupancy } from '@hatiolab/figure-model'
+import { partSummaryOf } from '../client/modeller/links.js'
+
+/*
+ * ADR-0097 B, the first minute (designer 2026-09-27, U04 · U05 · U09 · U11): a new figure asks what to start with; a
+ * selected part says what it is, how its size answers and what holds it; the side tabs say their names; and a narrow
+ * screen gives the canvas room by folding the parts list, said once.
+ */
+
+const read = (path: string) => readFileSync(new URL(path, import.meta.url), 'utf-8')
+const say = (key: string, params: Record<string, string> = {}) => `${key}${Object.keys(params).length ? JSON.stringify(params) : ''}`
+
+test('a selected part in three lines: its kind, how its size answers, what holds it', () => {
+  let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
+  assert.deepEqual(partSummaryOf(a, 'box', say), { kind: 'figure.label.primitive-cube', size: 'figure.text.summary-size-fixed', relation: 'figure.text.summary-free' })
+  const only = applyFigureProposal(a, planFigureResize(a, { part: 'box', axes: ['x'] }).steps)
+  const s = partSummaryOf(only, 'box', say)
+  assert.equal(s.size, 'figure.text.summary-follows{"axes":"figure.label.resize-x"}')
+  assert.match(s.relation, /^figure\.text\.held-on-plane/)
+  assert.match(s.relation, /"gap":"0"/)
+})
+
+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>'))
+  for (const lang of ['ko', 'en', 'ja', 'zh', 'ms']) {
+    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(parsed, 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')
+})
+
+/* 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')
+  assert.ok(links.includes("i18next.t('figure.text.fasten-editing', {"))
+  assert.ok(links.includes("i18next.t(current ? 'figure.button.fasten-update' : 'figure.button.fasten')"))
+  const ko = JSON.parse(read('../translations/ko.json'))
+  assert.equal(ko['figure.text.fasten-new'], '새로 붙이기')
+  assert.equal(ko['figure.button.fasten-update'], '이 붙임 수정')
+})

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

@@ -0,0 +1,42 @@
+/*
+ * Designer 2026-09-27, Q-D3: the first save asks for the name first, with a valid identifier already offered -- for a
+ * Korean name too: a valid prefix and a random part, no transliteration guessed.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+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'
+
+const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
+
+test('an identifier is offered for any name: plain letters as they are, anything else a prefix and a random part', () => {
+  assert.equal(suggestTypeOf('Lift table', []), 'LIFT_TABLE')
+  assert.equal(suggestTypeOf('roller-conveyor 2', []), 'ROLLER_CONVEYOR_2')
+  for (const name of ['리프트 테이블', '새 Figure', '', '___', '2층 선반']) {
+    const made = suggestTypeOf(name, [])
+    assert.match(made, /^FIG_[0-9A-Z]{6}$/, name)
+    assert.ok(releasableType(made) && TYPE_PATTERN.test(made) && made.length >= TYPE_LENGTH.min && !isPlaceholderType(made))
+  }
+  /* Never one already used: a taken name falls back, a taken random part is drawn again. */
+  assert.match(suggestTypeOf('Lift table', ['LIFT_TABLE']), /^FIG_/)
+  let n = 0
+  const draws = [0, 0, 0, 0, 0, 0, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]
+  assert.equal(suggestTypeOf('선반', ['FIG_000000'], () => draws[n++ % draws.length]!), 'FIG_IIIIII')
+})
+
+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')
+  for (const lang of ['en', 'ja', 'ko', 'ms', 'zh']) {
+    const t = JSON.parse(read(`../translations/${lang}.json`))
+    assert.ok(t['figure.label.figure-identifier'] && t['figure.text.identifier-suggested'], lang)
+  }
+})

package/test/gizmo.test.ts

@@ -140,33 +140,37 @@ test('원기둥 · 구도 크기 기즈모가 먹는다 — 단면은 원으로'
 })
 
 /*
- * 높이를 숫자로 적어도 아랫면이 그 자리에 있다 — 손잡이로 키울 때와 같게. 2200 을 적은 기둥이 바닥 아래로 933 mm
- * 묻혔다(09-26). 돌려 세운 부품은 그 높이가 위아래가 아니라 건드리지 않는다.
+ * 높이를 숫자로 적거나 손잡이로 키워도, 도형의 배치가 지키는 면이 그 자리에 있다 — figure-model 의 한 규칙
+ * (`figureSizeEditChanges`, ADR-0097). 전에는 화면이 제 산수로 배치와 상관없이 아랫면을 지켰다. 2200 을 적은 기둥이
+ * 바닥 아래로 933 mm 묻혔던 일(09-26)은 바닥 도형에서 그대로 막힌다. 돌려 세운 부품은 그 높이가 위아래가 아니라 건드리지 않는다.
  */
-test('높이 칸 — 아랫면을 지킨다, 손잡이처럼', async () => {
-  const { keepBottomChanges } = await import('../client/modeller/gizmo.ts')
+test('크기 칸과 손잡이 — 배치가 지키는 면을 지킨다, 커널의 한 규칙으로', async () => {
+  const { figureSizeEditChanges, applyFigureAuthoring, proposeFigureOccupancy } = await import('@hatiolab/figure-model')
   let asset = createFigureAsset('Post')
   asset = addFigureBox(asset, { id: 'post', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
   asset = addFigurePrimitive(asset, { id: 'drum', kind: 'cylinder', dimensions: { radius: 50, length: 100 }, position: { x: 0, y: 300, z: 0 } })
   asset = addFigurePrimitive(asset, { id: 'roller', kind: 'cylinder', dimensions: { radius: 30, length: 500 }, position: { x: 0, y: 30, z: 0 }, rotation: { x: 90, y: 0, z: 0 } })
-  const bottom = (a: typeof asset, part: string) => {
+  const centreY = (a: typeof asset, part: string) => {
     const g = compileFigureAsset(a).evaluate().geometry.find(o => o.id === part)! as unknown as { pose: { t: number[] } }
     return g.pose.t[1]!
   }
-  const grow = (part: string, input: string, value: number) => {
-    const reach = gizmoReachOf(asset, part)
-    const changes = [{ kind: 'set-design', input, unit: 'mm', value } as never, ...keepBottomChanges(part, reach, input, value, asset.designInputs)]
-    return apply(asset, changes)
-  }
+  const set = (input: string, value: number) => ({ kind: 'set-design', input, unit: 'mm', value }) as never
+  const grow = (a: typeof asset, part: string, input: string, value: number) => apply(a, figureSizeEditChanges(a, part, [set(input, value)]))
   const postH = gizmoReachOf(asset, 'post').sizes![1]
-  const tall = grow('post', postH, 2200)
-  assert.equal(bottom(tall, 'post') - 2200 / 2, 0, '기둥 아랫면이 바닥에')
+  assert.equal(centreY(grow(asset, 'post', postH, 2200), 'post') - 2200 / 2, 0, '바닥 도형(선언 전 기본): 기둥 아랫면이 바닥에')
   const drumH = gizmoReachOf(asset, 'drum').round!.along[0]!
-  assert.equal(bottom(grow('drum', drumH, 300), 'drum') - 300 / 2, 300 - 100 / 2, '원기둥도 아랫면이 제자리')
+  assert.equal(centreY(grow(asset, 'drum', drumH, 300), 'drum') - 300 / 2, 300 - 100 / 2, '원기둥도 아랫면이 제자리')
   const rollerLength = gizmoReachOf(asset, 'roller').round!.along[0]!
-  assert.deepEqual(keepBottomChanges('roller', gizmoReachOf(asset, 'roller'), rollerLength, 800, asset.designInputs), [], '누운 롤러의 길이는 위아래가 아니다')
-  assert.deepEqual(keepBottomChanges('post', gizmoReachOf(asset, 'post'), gizmoReachOf(asset, 'post').sizes![0], 800, asset.designInputs), [], '폭은 가운데 그대로')
-  assert.ok(read('../client/modeller/editor.ts').includes('keepBottomChanges('), '숫자 칸이 부른다')
+  assert.deepEqual(figureSizeEditChanges(asset, 'roller', [set(rollerLength, 800)]), [set(rollerLength, 800)], '누운 롤러의 길이는 위아래가 아니다')
+  assert.deepEqual(figureSizeEditChanges(asset, 'post', [set(gizmoReachOf(asset, 'post').sizes![0], 800)]), [set(gizmoReachOf(asset, 'post').sizes![0], 800)], '폭은 가운데 그대로')
+  /* 천장 도형이면 윗면을 지킨다 — 전에는 여기서도 아랫면을 지켜 천장을 뚫고 올라갔다. */
+  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(parseFigureAsset(this.session!.source()), part, [change])'), '숫자 칸이 부른다')
+  assert.ok(editor.includes('figureSizeEditChanges(asset, ownerOf(id), written)'), '손잡이도 부른다')
+  assert.ok(!read('../client/modeller/gizmo.ts').includes('keepBottomChanges'), '화면의 제 산수는 없다')
 })
 
 /* 손잡이는 키를 몰라도 찾는다 — 도구 막대에 옮기기 · 돌리기 · 크기, 제 숫자로 놓인 부품에만 (09-26). */

package/test/joint-fan.test.ts

@@ -84,7 +84,8 @@ test('the editor draws it for the selected part, with the pose in hand; the canv
   assert.ok(editor.includes('.fan=${this.fanOf(asset as FigureAsset | undefined)}'))
   assert.ok(editor.includes('return jointFanOf(asset, this.selected, { ...this.currentInputs(), ...this.live.values })'), 'the fan reads the pose the session holds')
   const canvas = read('../client/modeller/canvas.ts')
-  assert.ok(canvas.includes('{ ...fan, capturable: false, locked: true }'))
+  /* 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 }))'))
 })
 
 /* ── Joints on a chain (user 2026-09-24: 「로봇암 axis와 관절의 각도 표현을 다시 검증해보라」) ───────── */

package/test/layout.test.ts

@@ -37,9 +37,16 @@ test('부품을 고르면 — 도형 전체의 탭(판정 · 이력)은 그 부
     assert.ok(renderBody.includes(from), from)
 })
 
-test('부품을 보고 있으면 도형 전체로 돌아가는 칩이 탭마다 있다', () => {
+/* B.1 (designer 2026-09-27): the path -- model name › part -- on every tab; the model name is the one way back, the same move as the list's root. */
+test('모델명 › 부품 경로가 탭마다 있고, 모델명은 목록 루트와 같은 한 동작으로 모델 설정을 연다', () => {
   assert.ok((renderBody.match(/\$\{this\.renderSubject\(\)\}/g) ?? []).length >= 3)
-  assert.match(editor.slice(editor.indexOf('  private renderSubject()')), /@click=\$\{\(\) => \(this\.selected = ''\)\}/)
+  const subject = editor.slice(editor.indexOf('  private renderSubject()'), editor.indexOf('  private showModelSettings()'))
+  assert.ok(subject.includes('@click=${() => this.showModelSettings()}'))
+  assert.ok(!subject.includes('whole-figure'), 'no separate "whole figure" link')
+  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('탭마다 제자리 — 속성엔 부품의 모양 · 재질, 자리와 능력엔 사다리와 자리, 움직임엔 움직임 · 조작값', () => {

package/test/links.test.ts

@@ -318,9 +318,9 @@ test('붙여도 제자리 — 폼은 지금 서 있는 자리를 가운데서
     const [before, after] = [where(asset), where(fastened)]
     assert.deepEqual([after[0], after[2]], [before[0], before[2]], `${JSON.stringify(target)}: 앞뒤·좌우는 그대로`)
   }
-  assert.deepEqual(placeKeptOf(asset, 'leaf', { part: 'frame', face: 'top' }), { align: { x: 'mm', z: 'mm' }, alignMm: { x: -50, z: 100 } })
+  assert.deepEqual(placeKeptOf(asset, 'leaf', { part: 'frame', face: 'top' }), { align: { x: 'mm', z: 'mm' }, alignMm: { x: -50, z: 100 }, alignInput: {} })
   const centred = addFigureBox(createFigureAsset('C'), { id: 'a', size: { x: 10, y: 10, z: 10 }, position: { x: 0, y: 5, z: 0 } })
-  assert.deepEqual(placeKeptOf(centred, 'a', 'plane'), { align: {}, alignMm: {} }, '가운데 있던 것은 가운데로')
+  assert.deepEqual(placeKeptOf(centred, 'a', 'plane'), { align: {}, alignMm: {}, alignInput: {} }, '가운데 있던 것은 가운데로')
 
   /* The form fills it in whenever the aim changes, and does not offer a part that hangs from this one. */
   const { hangsFrom } = await import('../client/modeller/links.ts')
@@ -332,7 +332,9 @@ test('붙여도 제자리 — 폼은 지금 서 있는 자리를 가운데서
   assert.deepEqual([hangsFrom(row, 'roller', 'plate'), hangsFrom(row, 'cap', 'plate'), hangsFrom(row, 'plate', 'roller')], [true, true, false])
   const form = read('../client/modeller/figure-links.ts')
   assert.equal(form.match(/this\.aimAt\(asset, \{ \.\.\.f, (toPlane|target|targetFace):/g)?.length, 3, '바닥 · 상대 부품 · 상대 면을 바꿀 때마다')
-  assert.ok(form.includes('!hangsFrom(asset, one, this.partId)'))
+  /* Kept in the list, not choosable, with the reason (ADR-0097 §5.5). */
+  assert.ok(form.includes('const loops = (one: string) => hangsFrom(asset, one, this.partId)'))
+  assert.ok(form.includes("html`<option value=${one} disabled>${i18next.t('figure.text.target-would-loop'"))
 })
 
 test('따라 움직이는 관절 — 같은 방식으로 움직이고 제 조작값이 있는 관절만 고르고, 기록에는 배율과 더하기만 (집게 두 손가락, 09-25)', async () => {
@@ -609,7 +611,8 @@ test('팔레트의 문틀은 문 크기로 서고, 세 축 모두 크기를 따
 /* 크기를 따라감 한 번 — 치수 칸의 단추 하나, 크기를 대신 정했으면 한 줄로 말한다 (ADR 판정 Q1, 09-26). */
 test('치수 칸 — 「도형 크기를 따라감」 단추는 follow-size 한 번, 다 따르면 사라진다; 크기를 대신 정하면 한 줄', () => {
   const form = read('../client/modeller/figure-links.ts')
-  const dims = form.slice(form.indexOf('  private renderDimensions('), form.indexOf('  private renderDimensions(') + 1200)
+  /* The whole method: the resize-with-placement block above the advanced settings made it longer than a fixed slice. */
+  const dims = form.slice(form.indexOf('  private renderDimensions('), form.indexOf('  /** The same source, the same share'))
   assert.ok(dims.includes("this.command({ kind: 'follow-size', part: this.partId })"))
   assert.ok(dims.includes("followOf(asset, this.partId, axis).of === 'instance'"), '다 따르면 단추가 없다')
   const editor = read('../client/modeller/editor.ts')

package/test/proposal-record.test.ts

@@ -0,0 +1,126 @@
+/*
+ * What became of an AI proposal (ADR-0097 §5.6 item 5; AI lane, 2026-09-27). A save names the proposals whose steps its
+ * text holds -- undone, a proposal is not in it; a new figure made from a proposal is created under the proposal's key.
+ * The server side (recorded in the save's transaction, one figure per key) is tested on sqlite in figure-service
+ * (figure-proposal-db).
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { addFigureBox, createFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
+
+import { createFigureProductSession } from '../client/modeller/product-session.js'
+import { runFigureProposal, takeFigureOffer, type FigureApplyDetail } from '../client/modeller/ai-proposal.js'
+
+const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
+const say = (key: string) => key
+const text = () => serializeFigureAsset(addFigureBox(createFigureAsset('A'), { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } }))
+const lid = [{ kind: 'add-part', part: { id: 'lid', kind: 'box', dimensions: { width: 100, height: 10, depth: 100 } } }] as any[]
+const leg = [{ kind: 'add-part', part: { id: 'leg', kind: 'box', dimensions: { width: 10, height: 50, depth: 10 } } }] as any[]
+const K1 = '11111111-1111-4111-8111-111111111111'
+const K2 = '22222222-2222-4222-8222-222222222222'
+
+function server() {
+  const saves: Array<{ id?: string; creationId?: string; proposalKeys?: string[] }> = []
+  let row = text()
+  const store = {
+    load: async (id: string) => ({ id, source: row }),
+    save: async (q: { id?: string; source: string; creationId?: string; proposalKeys?: string[] }) => {
+      saves.push({ id: q.id, creationId: q.creationId, proposalKeys: q.proposalKeys })
+      row = q.source
+      return { id: q.id ?? q.creationId ?? 'created', source: q.source }
+    }
+  }
+  return { store, saves }
+}
+
+test('a save names the proposals its text holds: undone, not; redone, again; undone and written past, never', async () => {
+  const { store, saves } = server()
+  const s = createFigureProductSession(store)
+  await s.open('a')
+  let v = s.read()
+  s.applyProposal(lid, v.revision!, v.context!, K1)
+  v = s.read()
+  s.applyProposal(leg, v.revision!, v.context!, K2)
+  assert.deepEqual(s.proposalsInEffect(), [K1, K2])
+  s.undo()
+  assert.deepEqual(s.proposalsInEffect(), [K1], 'the leg proposal undone: not in the model')
+  s.redo()
+  assert.deepEqual(s.proposalsInEffect(), [K1, K2])
+  s.undo()
+  s.command({ kind: 'rename', name: 'B' } as never)
+  assert.deepEqual(s.proposalsInEffect(), [K1], 'undone and written past: gone for good')
+  await s.save()
+  assert.deepEqual(saves.at(-1)!.proposalKeys, [K1])
+  /* A person's own edits carry no key; a refused proposal adds none. */
+  v = s.read()
+  assert.throws(() => s.applyProposal(leg, v.revision! - 1, v.context!, K2))
+  assert.deepEqual(s.proposalsInEffect(), [K1])
+})
+
+test('a new figure made from a proposal is created under its key; one being made keeps its own', async () => {
+  const { store, saves } = server()
+  const s = createFigureProductSession(store)
+  s.startNew()
+  const detail: FigureApplyDetail = { key: K1, steps: lid, create: true }
+  assert.equal(takeFigureOffer(s, detail, { onSavedFigure: false, say }), true)
+  await s.save({ type: 'LIDDED' })
+  assert.equal(saves.at(-1)!.creationId, K1, 'created under the proposal key: taken twice, it meets the first figure')
+  assert.deepEqual(saves.at(-1)!.proposalKeys, [K1])
+
+  /* A new figure the person has touched is theirs: the proposal is not put on it (NEW_FIGURE_UNSAVED), its id stays. */
+  s.startNew({ discard: true })
+  s.command({ kind: 'rename', name: 'Mine' } as never)
+  assert.throws(() => s.createUnder(K2))
+  /* Nor on a saved one. */
+  const t = createFigureProductSession(server().store)
+  await t.open('a')
+  assert.throws(() => t.createUnder(K2))
+})
+
+test('the key travels from the card to the modeller, on a revision and on a new figure', async () => {
+  const offered: FigureApplyDetail[] = []
+  const opened: Array<string | undefined> = []
+  await runFigureProposal(
+    { key: K1, steps: lid, create: false, context: 'c', revision: 1 },
+    { offer: d => (offered.push(d), { ...d, applied: true }), openNew: async () => ({ applied: false }) },
+    say
+  )
+  assert.equal(offered[0]!.key, K1)
+  await runFigureProposal(
+    { key: K2, steps: lid, create: true },
+    { offer: d => d, openNew: async (_steps, key) => (opened.push(key), { applied: true }) },
+    say
+  )
+  assert.deepEqual(opened, [K2])
+  const page = read('../client/pages/figure-modeller-page.ts')
+  const take = page.slice(page.indexOf('  private takeNewFigureProposal'), page.indexOf('  private askFirstSave'))
+  assert.ok(take.includes('if (waiting.key) this.session.createUnder(waiting.key)'))
+  assert.ok(take.includes('this.session.applyProposal(waiting.steps, view.revision!, view.context!, waiting.key)'))
+  assert.ok(read('../client/figure-assistant.ts').includes('const opened = pendNewFigure(steps, key)'))
+})
+
+test('the dock hears the selected part and what the preview tries, with the version -- and selecting starts nothing', () => {
+  const page = read('../client/pages/figure-modeller-page.ts')
+  const provide = page.slice(page.indexOf('  private provideAssistant = '), page.indexOf('  private withdrawAssistant('))
+  assert.ok(provide.includes('...this.assistantFocus()'), 'read at the moment of sending')
+  assert.ok(provide.includes('selection: { part: focus.part, context, revision }'))
+  assert.ok(provide.includes('trying: { ...focus.trying, context, revision }'))
+  /* Not in the key, the label or the anchor: selecting is not a new subject. */
+  assert.ok(provide.includes('key: `figure:${id}`'))
+  const editor = read('../client/modeller/editor.ts')
+  const choose = editor.slice(editor.indexOf('  private choose('), editor.indexOf('  private choose(') + 400)
+  assert.ok(!choose.includes('notifyAssistantSurface') && !editor.includes('notifyAssistantSurface'), 'selecting does not tell the dock')
+})
+
+test('the dock checks the result from the server: saved is accepted and named, nothing recorded is not known', async () => {
+  const { proposalOutcomeFrom } = await import('../client/modeller/ai-proposal.js')
+  const words = JSON.parse(read('../translations/ko.json'))
+  const sayKo = (key: string, params: Record<string, string> = {}) => words[key].replace(/\{(\w+)\}/g, (_: string, k: string) => params[k] ?? '')
+  assert.deepEqual(proposalOutcomeFrom([{ figureId: 'x', type: 'LIDDED', name: '뚜껑 상자' }], sayKo), { verdict: 'accepted', note: '저장된 도형에 들어 있습니다: 뚜껑 상자' })
+  assert.equal(proposalOutcomeFrom([], sayKo), undefined, 'not saved is not known, never refused')
+  const page = read('../client/pages/figure-modeller-page.ts')
+  assert.ok(page.includes('proposalOutcomeFrom(await fetchProposalOutcome(proposalKey)'), 'the surface asks the server')
+  for (const lang of ['en', 'ja', 'ko', 'ms', 'zh']) assert.ok(JSON.parse(read(`../translations/${lang}.json`))['figure.text.proposal-saved-into'], lang)
+})

package/test/release-entry.test.ts

@@ -0,0 +1,28 @@
+/*
+ * ADR-0097 §5.6, Q-D2: beside the save, what the saved figure is -- a draft never released, a draft while boards use an
+ * earlier release, a release -- and a way to the release that exists, not a second one.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+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')
+  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']) {
+    const t = JSON.parse(read(`../translations/${lang}.json`))
+    for (const key of ['figure.text.release-state-released', 'figure.text.release-state-draft-over', 'figure.text.release-state-draft-new', 'figure.button.release']) assert.ok(t[key], `${lang} ${key}`)
+  }
+})

package/test/release-panel.test.ts

@@ -35,7 +35,8 @@ test('새로 만든 도형의 「공간 선언 없음」을 「부품에 맞추
   const fitted = applyFigureAuthoring(asset, occupancyFromParts(serializeFigureAsset(asset)))
 
   assert.deepEqual(codes(fitted), [])
-  assert.equal(fitted.occupancy?.placement, 'floor', '처음 선언하는 도형은 바닥에 선다')
+  assert.equal(fitted.placement ?? 'floor', 'floor', '처음 선언하는 도형은 바닥에 선다')
+  assert.equal('placement' in (fitted.occupancy ?? {}), false, '배치는 공간이 아니라 도형 자신의 설정 (ADR-0097)')
 })
 
 test('선언한 공간을 넘은 부품도 같은 한 번으로 풀리고, 배치 기준은 지킨다', () => {
@@ -48,7 +49,7 @@ test('선언한 공간을 넘은 부품도 같은 한 번으로 풀리고, 배
   const fitted = applyFigureAuthoring(asset, occupancyFromParts(serializeFigureAsset(asset)))
 
   assert.deepEqual(codes(fitted), [])
-  assert.equal(fitted.occupancy?.placement, 'center', '이미 선언된 배치 기준을 바꾸지 않는다')
+  assert.equal(fitted.placement, 'center', '이미 선언된 배치 기준을 바꾸지 않는다')
 })
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')