@things-factory/figure-ui 10.1.81 → 10.1.82

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

@@ -0,0 +1,225 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { addFigureBox, createFigureAsset, applyFigureAuthoring, applyFigureProposal, compileFigureAsset, figureFollowOf, figureRoomOnlyInputsOf, proposeFigureOccupancy, parseFigureAsset, planFigureResize, serializeFigureAsset } from '@hatiolab/figure-model'
+import type { FigurePlacement } from '@hatiolab/figure-model'
+import { createFigureProductSession } from '../client/modeller/product-session.js'
+import { resizeRefusalOf } from '../client/modeller/refusals.js'
+import { resizeAxesOf } from '../client/modeller/links.js'
+import { groupFields } from '../client/modeller/fields.js'
+
+/*
+ * ADR-0097: the modeller's "follow the size and keep where the figure is placed" is figure-model's plan, applied through
+ * the product session as one step: undone and redone whole, saved and opened again the same. The kernel's own tests
+ * check each placement at eight sizes; this checks the screen's path to it. The store is in memory: a kernel
+ * serialize-and-open, not the service's save and reopen, which is checked in the browser.
+ */
+
+const START: Record<FigurePlacement, { x: number; y: number; z: number }> = {
+  floor: { x: 20, y: 50, z: 30 },
+  ceiling: { x: 20, y: -50, z: 30 },
+  wall: { x: 20, y: 50, z: 50 },
+  center: { x: 20, y: 50, z: 30 }
+}
+
+for (const mode of ['floor', 'ceiling', 'wall', 'center'] as const) {
+  test(`${mode}: one step through the session -- undo, redo, save and open again`, async () => {
+    let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: START[mode] })
+    a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: mode })
+    const before = serializeFigureAsset(a)
+    let record = { id: 'ux', source: before }
+    const session = createFigureProductSession({ load: async () => record, save: async q => (record = { id: 'ux', source: q.source }) })
+    await session.open('ux')
+    const plan = planFigureResize(parseFigureAsset(session.source()), { part: 'box', axes: resizeAxesOf(parseFigureAsset(session.source()), 'box').axes })
+    assert.equal(plan.refusal, undefined)
+    session.applyRecipe(plan.steps)
+    const after = session.source()
+    assert.notEqual(after, before)
+    session.undo()
+    assert.equal(session.source(), before, 'one undo takes all of it back')
+    session.redo()
+    assert.equal(session.source(), after)
+    await session.save()
+    await session.open('ux')
+    assert.equal(session.source(), after)
+    /* At twice the height the kept face is where it was. */
+    const asset = parseFigureAsset(session.source())
+    asset.designInputs['size.y'] = asset.designInputs['size.y']! * 2
+    const g = compileFigureAsset(asset).evaluate().geometry.find(g => g.id === 'box')! as unknown as { pose: { t: number[] }; shape: { dimensions: { height: number } } }
+    const y = g.pose.t[1]!, h = g.shape.dimensions.height
+    if (mode === 'floor') assert.equal(y - h / 2, 0)
+    if (mode === 'ceiling') assert.equal(y + h / 2, 0)
+    if (mode === 'center') assert.equal(y, 50)
+    /* Asked again, the part is held: the screen says so rather than fastening it twice. */
+    if (mode !== 'center') assert.equal(planFigureResize(asset, { part: 'box' }).refusal?.code, 'HELD')
+  })
+}
+
+test('a refusal is said in the author\'s words, never the kernel\'s English', () => {
+  const said: Array<[string, Record<string, string>]> = []
+  const say = (key: string, params: Record<string, string>) => (said.push([key, params]), key)
+  /* No room declared: the figure stands on the floor by default. */
+  const a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 }, rotation: { x: 0, y: 30, z: 0 } })
+  assert.equal(resizeRefusalOf(planFigureResize(a, { part: 'box' }), 'box', say), 'figure.text.resize-refused-turned')
+  assert.deepEqual(said.at(-1)![1].place, 'figure.label.resize-place-floor')
+  assert.equal(resizeRefusalOf({ mode: 'floor', refusal: { code: 'COMMAND_REFUSED' } }, 'box', say), 'figure.text.edit-refused')
+  assert.equal(resizeRefusalOf({ mode: 'floor' }, 'box', say), '')
+})
+
+/*
+ * Designer 2026-09-27: the directions are passed as chosen; a first suggestion is not a choice, and a part set back to
+ * fixed in every direction is not "nothing chosen yet".
+ */
+test('fresh, width only, and all set back to fixed are three different answers', async () => {
+  let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 20, y: 50, z: 30 } })
+  a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
+  /* Fresh: all three are suggested -- and the button says "all three", never passing it off as the author's choice. */
+  assert.deepEqual(resizeAxesOf(a, 'box'), { axes: ['x', 'y', 'z'], basis: 'suggested' })
+  /* Width only ticked: width alone is planned, and height and depth stay fixed. */
+  const only = resizeAxesOf(a, 'box', ['x'])
+  assert.deepEqual(only, { axes: ['x'], basis: 'chosen' })
+  const resized = applyFigureProposal(a, planFigureResize(a, { part: 'box', axes: only.axes }).steps)
+  for (const axis of ['y', 'z'] as const) assert.equal(figureFollowOf(resized, 'box', axis).of, 'own', `${axis} stays fixed`)
+  const g = compileFigureAsset({ ...resized, designInputs: { ...resized.designInputs, 'size.x': 200, 'size.y': 400, 'size.z': 400 } }).evaluate().geometry.find(g => g.id === 'box') as unknown as { shape: { dimensions: Record<string, number> }; pose: { t: number[] } }
+  assert.deepEqual(g.shape.dimensions, { width: 200, height: 100, depth: 100 })
+  assert.equal(g.pose.t[1]! - 50, 0, 'and it stands on the floor')
+  /* All set back to fixed: nothing is taken for "all". */
+  let fixed = applyFigureAuthoring(a, { kind: 'follow-size', part: 'box', axes: ['x'] })
+  fixed = applyFigureAuthoring(fixed, { kind: 'unlink-dimension', part: 'box', axis: 'x', mm: 100 })
+  assert.deepEqual(resizeAxesOf(fixed, 'box', []), { axes: [], basis: 'none' })
+  /* A direction already following stays in, ticked or not. */
+  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: the button passes the axes, the button names its scope, and "none" disables it. */
+  const links = readFileSync(new URL('../client/modeller/figure-links.ts', import.meta.url), 'utf-8')
+  assert.ok(links.includes("detail: { request: { part: this.partId, axes, ...(gap ? { gap } : {}) } }"))
+  assert.ok(links.includes("i18next.t('figure.button.resize-scoped-' + mode, { scope })"))
+  assert.ok(links.includes("?disabled=${choice.basis === 'none'"))
+  assert.ok(links.includes('this.pendingAxes = { ...this.pendingAxes, [this.partId]: axes.filter(one => one !== axis) }'), 'set back to fixed is remembered as a choice')
+  const ko = JSON.parse(readFileSync(new URL('../translations/ko.json', import.meta.url), 'utf-8'))
+  assert.equal(ko['figure.text.resize-scope-all-3'], '세 방향 모두')
+})
+
+test('a part off the floor is offered both, with the distance: keep the gap, or be brought onto the floor', () => {
+  let a = addFigureBox(createFigureAsset('UX'), { id: 'shelf', size: { x: 400, y: 40, z: 300 }, position: { x: 0, y: 520, z: 0 } })
+  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')}") && links.includes("@click=${() => ask('plane')}"), 'two buttons, each a choice')
+})
+
+test('a field only the room reads is taken out of the part\'s position row and shown apart', () => {
+  let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 20, y: 50, z: 30 } })
+  a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
+  const resized = applyFigureProposal(a, planFigureResize(a, { part: 'box' }).steps)
+  const roomOnly = figureRoomOnlyInputsOf(resized, 'box')
+  assert.ok(roomOnly.includes('box.position.y'))
+  const fields = Object.entries(resized.designInputs).filter(([id]) => id.startsWith('box.')).map(([id, value]) => ({ id, unit: 'mm', role: 'design', value }))
+  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')
+})
+
+/*
+ * Designer 2026-09-27, 1: what the drag shows is what is written. The part component carries figure-model's anchor, and
+ * the scene's gizmo keeps that face while dragging (things-scene `scaleAnchor`); the commit keeps the same face.
+ */
+test('the part component carries the face a size drag keeps, for each placement', async () => {
+  const { componentOf } = await import('../client/modeller/stage-model.js')
+  const { figureScaleAnchorOf } = await import('@hatiolab/figure-model')
+  const expected = { floor: { x: 0, y: 1, z: 0 }, ceiling: { x: 0, y: -1, z: 0 }, wall: { x: 0, y: 0, z: 1 }, center: { x: 0, y: 0, z: 0 } } as const
+  for (const mode of ['floor', 'ceiling', 'wall', 'center'] as const) {
+    let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: START[mode] })
+    a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: mode })
+    const anchor = figureScaleAnchorOf(a, 'box')!
+    assert.deepEqual(anchor, expected[mode], mode)
+    const body = compileFigureAsset(a).evaluate().geometry.find(g => g.id === 'box') as never
+    const state = componentOf(body, {}, { width: 1000, height: 1000 }, anchor)!
+    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 as FigureAsset | undefined)}'))
+})
+
+/* Designer 2026-09-27 (acceptance round 2): what the screen shows for a part a rule places, and what it withholds. */
+test('a fastened part keeps its position and turn rows, with the numbers the rule gives', async () => {
+  const { placementOf } = await import('../client/modeller/stage-model.js')
+  let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 20, y: 50, z: 30 } })
+  a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
+  const resized = applyFigureProposal(a, planFigureResize(a, { part: 'box' }).steps)
+  const fields = Object.entries(resized.designInputs).filter(([id]) => id.startsWith('box.') && !figureRoomOnlyInputsOf(resized, 'box').includes(id)).map(([id, value]) => ({ id, unit: 'mm', role: 'design', value }))
+  const { vectors } = groupFields(fields, 'box')
+  const rows = Object.fromEntries(vectors.map(v => [v.name, v]))
+  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('after "follow size, attached" the part says what holds it, not a refusal', () => {
+  const links = readFileSync(new URL('../client/modeller/figure-links.ts', import.meta.url), 'utf-8')
+  assert.ok(links.includes('? this.renderHeld(asset)'))
+  assert.ok(!links.includes("<p hint resize-held>${i18next.t('figure.text.resize-refused-held'"))
+  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)')
+})
+
+test('a part fastened twisted has no face figure-model can keep for a drag, so the size gizmo is withheld', async () => {
+  const { figureScaleAnchorOf } = await import('@hatiolab/figure-model')
+  let a = addFigureBox(createFigureAsset('UX'), { id: 'hub', size: { x: 200, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
+  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')
+})
+
+/*
+ * Designer 2026-09-27 (reproduced by pressing it): "open attachment settings" opened the capability tab's holding places.
+ * It opens this part's fastening form -- loaded from the fastening the part has now -- in place.
+ */
+test('"open attachment settings" opens this part\'s fastening, as it is now, and not another tab', async () => {
+  const { fasteningOf } = await import('../client/modeller/links.js')
+  let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 20, y: 150, z: 30 } })
+  a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
+  const kept = applyFigureProposal(a, planFigureResize(a, { part: 'box', gap: 'keep' }).steps)
+  const form = fasteningOf(kept, 'box')!
+  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(asset, 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}'))
+})
+
+/*
+ * The fastening form reads a place that follows a position field as that, and fastening again from it keeps the field:
+ * no relation is fixed into a number by opening the form and pressing "fasten" (a lost relation blocks release).
+ */
+test('the fastening form keeps a place that follows a position field, and fastening again keeps the field', async () => {
+  const { fasteningOf, alignOf } = await import('../client/modeller/links.js')
+  let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 200, y: 50, z: 150 } })
+  a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
+  const kept = applyFigureProposal(a, planFigureResize(a, { part: 'box' }).steps)
+  const form = fasteningOf(kept, 'box')!
+  assert.deepEqual([form.align.x, form.alignInput.x, form.align.z, form.alignInput.z], ['input', 'box.position.x', 'input', 'box.position.z'])
+  const align = alignOf(kept, 'box', 'plane', form.align, form.alignMm, false, form.alignInput)
+  const again = applyFigureAuthoring(kept, { kind: 'attach', part: 'box', face: 'bottom', to: { plane: 'mounting-plane' }, ...(align ? { align } : {}), replace: true } as never)
+  assert.ok('box.position.x' in again.designInputs && 'box.position.z' in again.designInputs, 'the fields stay')
+  assert.deepEqual(JSON.stringify(again.joints), JSON.stringify(kept.joints), 'the same fastening')
+})

package/test/revert-choice.test.ts

@@ -0,0 +1,39 @@
+/*
+ * Designer 2026-09-27, Q-D1: going back to a released version with edits not saved -- save first, let them go, or stay.
+ * A save that failed, or whose outcome is not known, holds the revert.
+ */
+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('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')
+})
+
+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']) {
+    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

@@ -0,0 +1,102 @@
+/*
+ * Designer 2026-09-27 (ADR-0097 §5.6): the draft a revert writes over is kept on the server, in the same transaction.
+ * The screen sends what the server is confirmed to hold, so a revert never writes over something it did not see; a
+ * retry after a lost answer goes with the same request id, so the same revert is never run twice; the kept drafts are
+ * listed apart from the releases, and the newest can be taken back.
+ *
+ * The server's side -- one transaction, the same request once, an undo only while nothing changed -- is tested on sqlite
+ * and on postgres in figure-service (figure-revert-db, figure-revert-race.pg).
+ */
+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 { afterRevertAnswer, revertOutcomeUnknown, revertRequestFor } from '../client/modeller/revert-request.js'
+
+const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
+
+test('asked again for the same revert after no answer: the same request id; anything else, a new one', () => {
+  let n = 0
+  const fresh = () => `id-${++n}`
+  const first = revertRequestFor(undefined, 'revert:1:A', fresh)
+  assert.equal(first.requestId, 'id-1')
+  /* No answer came: kept, and the same press goes with the same id. */
+  const kept = afterRevertAnswer(first, 'REVERT_UNREACHABLE')
+  assert.equal(revertRequestFor(kept, 'revert:1:A', fresh).requestId, 'id-1')
+  /* Met itself in flight on the server: still not known -- kept too. */
+  assert.equal(afterRevertAnswer(first, 'FIGURE_REVERT_IN_FLIGHT'), first)
+  /* Another version, or the same version over another source (saved since): a new request. */
+  assert.equal(revertRequestFor(kept, 'revert:2:A', fresh).requestId, 'id-2')
+  assert.equal(revertRequestFor(kept, 'revert:1:B', fresh).requestId, 'id-3')
+  /* Done, or refused by name: let go -- the next press is a new request. */
+  assert.equal(afterRevertAnswer(first, undefined), undefined)
+  assert.equal(afterRevertAnswer(first, 'FIGURE_SOURCE_CONFLICT'), undefined)
+  assert.equal(afterRevertAnswer(first, 'FIGURE_KEPT_RESTORED'), undefined)
+  assert.equal(revertOutcomeUnknown('FIGURE_SOURCE_CONFLICT'), false)
+})
+
+test('the source a revert expects is what the server is confirmed to hold -- not the edits on screen', async () => {
+  let row = serializeFigureAsset(addFigureBox(createFigureAsset('A'), { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } }))
+  let lose = false
+  const session = createFigureProductSession({
+    load: async (id: string) => ({ id, source: row }),
+    readBack: async (id: string) => ({ id, source: row }),
+    save: async (q: { id?: string; source: string; expectedSource?: string }) => {
+      if (lose) throw Object.assign(Error('서버에 연결하지 못했습니다.'), { code: 'SAVE_UNREACHABLE' })
+      row = q.source
+      return { id: q.id ?? 'a', source: row }
+    }
+  })
+  session.startNew()
+  assert.equal(session.confirmedSource(), undefined, 'nothing saved: nothing to revert over')
+  await session.open('a')
+  const loaded = row
+  assert.equal(session.confirmedSource(), loaded)
+  session.command({ kind: 'rename', name: 'B' } as never)
+  assert.equal(session.confirmedSource(), loaded, 'edits not saved are not what the server holds')
+  await session.save()
+  assert.equal(session.confirmedSource(), row)
+  assert.notEqual(row, loaded)
+  /* A save that never reached the server does not move it. */
+  const saved = row
+  session.command({ kind: 'rename', name: 'C' } as never)
+  lose = true
+  await session.save().catch(() => {})
+  assert.equal(session.confirmedSource(), saved)
+})
+
+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()}'))
+  for (const lang of ['en', 'ja', 'ko', 'ms', 'zh']) {
+    const t = JSON.parse(read(`../translations/${lang}.json`))
+    for (const key of [
+      'figure.label.kept-drafts',
+      'figure.text.kept-before-revert',
+      'figure.text.kept-before-undo',
+      'figure.text.kept-restored',
+      'figure.button.undo-revert',
+      'figure.button.redo-revert',
+      'figure.text.undo-revert-with-unsaved',
+      'figure.button.save-and-continue',
+      'figure.button.discard-and-continue',
+      'figure.text.revert-needs-server-source',
+      'figure.text.revert-unconfirmed'
+    ])
+      assert.ok(t[key], `${lang} ${key}`)
+    assert.equal(t['figure.text.revert-waits-for-keeping'], undefined, `${lang}: the waiting notice is gone`)
+  }
+})

package/test/save-landed.test.ts

@@ -0,0 +1,198 @@
+/*
+ * Designer 2026-09-27 (D): a network failure alone does not say nothing was saved. A save whose answer was lost, or whose
+ * second try is refused because the first landed, is read back from the server: the very text sent is a save that
+ * happened. Anything else, the failure stands and the edits stay.
+ */
+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'
+
+const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
+const unreachable = () => Object.assign(Error('서버에 연결하지 못했습니다.'), { code: 'SAVE_UNREACHABLE' })
+
+/** A server that keeps one row; its save can be made to fail before or after it writes. */
+function server() {
+  let row = serializeFigureAsset(addFigureBox(createFigureAsset('A'), { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } }))
+  let picture: string | undefined
+  const state = { failAfterWrite: false, failBeforeWrite: false, loadFails: false, refuseOnGrounds: false, writes: 0, hold: undefined as undefined | Promise<void> }
+  const store = {
+    load: async (id: string) => ({ id, source: row }),
+    readBack: async (id: string) => {
+      if (state.loadFails) throw unreachable()
+      return { id, source: row, thumbnail: picture }
+    },
+    save: async (q: { id?: string; source: string; expectedSource?: string; thumbnail?: string }) => {
+      if (state.hold) await state.hold
+      if (state.failBeforeWrite) throw unreachable()
+      /* Refused on grounds -- permission: the row may even hold the same text; it is not a save. */
+      if (state.refuseOnGrounds) throw Object.assign(Error('권한이 없습니다.'), { code: 'FORBIDDEN' })
+      if (q.expectedSource !== row) throw Object.assign(Error('다른 편집에서 모델이 변경되었습니다. 최신 모델을 다시 열어 주세요.'), { code: 'FIGURE_SOURCE_CONFLICT' })
+      row = q.source
+      if (q.thumbnail !== undefined) picture = q.thumbnail
+      state.writes++
+      if (state.failAfterWrite) throw unreachable()
+      return { id: q.id ?? 'a', source: row }
+    }
+  }
+  return { store, state, row: () => row, setRow: (text: string) => (row = text), setPicture: (p: string | undefined) => (picture = p) }
+}
+
+test('the answer lost after it was written: read back, it was saved -- said as saved, and saving again is not refused', async () => {
+  const s = server()
+  const session = createFigureProductSession(s.store)
+  await session.open('a')
+  session.command({ kind: 'rename', name: 'B' } as never)
+  s.state.failAfterWrite = true
+  await session.save()
+  assert.equal(session.read().dirty, false, 'the server has it: saved')
+  assert.equal(s.state.writes, 1)
+  /* And the next save starts from what the server has. */
+  s.state.failAfterWrite = false
+  session.command({ kind: 'rename', name: 'C' } as never)
+  await session.save()
+  assert.equal(session.read().dirty, false)
+})
+
+test('a second try refused because the first landed: read back, it was saved', async () => {
+  const s = server()
+  const session = createFigureProductSession(s.store)
+  await session.open('a')
+  session.command({ kind: 'rename', name: 'B' } as never)
+  /* The first try wrote and its answer was lost, the page not told (it threw before the session read back). */
+  const sent = JSON.parse(session.source())
+  s.setRow(serializeFigureAsset(sent))
+  await session.save()
+  assert.equal(session.read().dirty, false, 'the conflict was its own earlier save')
+})
+
+test('a real conflict, or no server at all: the failure stands and the edits stay', async () => {
+  const s = server()
+  const session = createFigureProductSession(s.store)
+  await session.open('a')
+  session.command({ kind: 'rename', name: 'B' } as never)
+  /* Someone else's edit on the server. */
+  s.setRow(serializeFigureAsset({ ...JSON.parse(s.row()), name: 'Other' }))
+  await assert.rejects(session.save(), /다른 편집에서/)
+  assert.equal(session.read().dirty, true)
+  /* Not reached, and not readable back: not known, and the edits stay. */
+  s.setRow(JSON.stringify(JSON.parse(s.row())))
+  const t = server()
+  const lost = createFigureProductSession(t.store)
+  await lost.open('a')
+  lost.command({ kind: 'rename', name: 'B' } as never)
+  t.state.failBeforeWrite = true
+  t.state.loadFails = true
+  await assert.rejects(lost.save(), (e: { code?: string }) => e.code === 'SAVE_UNREACHABLE')
+  assert.equal(lost.read().dirty, true)
+  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')
+  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']) 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. */
+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']) assert.ok(JSON.parse(read(`../translations/${lang}.json`))['figure.text.released-now-draft'], lang)
+})
+
+/* Designer 2026-09-27: read back, every field the save writes must match; a refusal on grounds is never a save. */
+test('a refusal on grounds is not a save, even if the row holds the same text; a picture not written is not saved', async () => {
+  const s1 = server()
+  const session = createFigureProductSession(s1.store)
+  await session.open('a')
+  session.command({ kind: 'rename', name: 'B' } as never)
+  s1.setRow(serializeFigureAsset(JSON.parse(session.source())))
+  s1.state.refuseOnGrounds = true
+  await assert.rejects(session.save(), /권한이 없습니다/)
+  assert.equal(session.read().dirty, true, 'refused on grounds: not saved, whatever the row holds')
+  /* The answer lost, the source written but not the picture sent: not every field landed -- not a save. */
+  const s2 = server()
+  const other = createFigureProductSession(s2.store)
+  await other.open('a')
+  other.command({ kind: 'rename', name: 'B' } as never)
+  s2.setRow(serializeFigureAsset(JSON.parse(other.source())))
+  s2.setPicture('old-picture')
+  s2.state.failBeforeWrite = true
+  await assert.rejects(other.save({ thumbnail: 'new-picture' }), (e: { code?: string }) => e.code === 'SAVE_UNREACHABLE')
+  assert.equal(other.read().dirty, true)
+})
+
+test('no edit gets in while it saves; the next save starts from what the server has', async () => {
+  const s = server()
+  const session = createFigureProductSession(s.store)
+  await session.open('a')
+  session.command({ kind: 'rename', name: 'B' } as never)
+  let release!: () => void
+  s.state.hold = new Promise<void>(r => (release = r))
+  const saving = session.save()
+  await new Promise(r => setTimeout(r, 0))
+  /* While it saves, an edit is refused: nothing made after the request can be marked saved or wiped. */
+  assert.throws(() => session.command({ kind: 'rename', name: 'C' } as never), /저장이 끝난 뒤 편집해 주세요/)
+  release()
+  await saving
+  assert.equal(JSON.parse(s.row()).name, 'B')
+  assert.equal(session.read().dirty, false)
+  session.command({ kind: 'rename', name: 'D' } as never)
+  await session.save()
+  assert.equal(JSON.parse(s.row()).name, 'D')
+})
+
+/* The answer lost and not readable back; edited further; saved again: the row holds our earlier save, not another's. */
+test('a save never answered, then more edits: the sent content confirmed on the server, the next save is conditional on it', async () => {
+  const s = server()
+  const session = createFigureProductSession(s.store)
+  await session.open('a')
+  session.command({ kind: 'rename', name: 'B' } as never)
+  s.state.failAfterWrite = true
+  s.state.loadFails = true
+  await assert.rejects(session.save(), (e: { code?: string }) => e.code === 'SAVE_UNREACHABLE')
+  assert.equal(session.read().dirty, true, 'not known: still unsaved')
+  s.state.failAfterWrite = false
+  s.state.loadFails = false
+  session.command({ kind: 'rename', name: 'C' } as never)
+  await session.save()
+  assert.equal(JSON.parse(s.row()).name, 'C', 'saved, conditional on the server text confirmed to be what was sent')
+  assert.equal(session.read().dirty, false)
+  /* Another's edit on the row is still a conflict. */
+  s.setRow(serializeFigureAsset({ ...JSON.parse(s.row()), name: 'Theirs' }))
+  session.command({ kind: 'rename', name: 'E' } as never)
+  await assert.rejects(session.save(), /다른 편집에서/)
+})
+
+/* ADR-0097 §5.6: sent again only on what was compared -- a row whose picture is not the one sent is not ours to write over. */
+test('the sent content confirmed on the server means every field of it, the picture too', async () => {
+  const s = server()
+  const session = createFigureProductSession(s.store)
+  await session.open('a')
+  session.command({ kind: 'rename', name: 'B' } as never)
+  s.state.failAfterWrite = true
+  s.state.loadFails = true
+  await assert.rejects(session.save({ thumbnail: 'mine' }), (e: { code?: string }) => e.code === 'SAVE_UNREACHABLE')
+  s.state.failAfterWrite = false
+  s.state.loadFails = false
+  /* Someone else changed the picture since: the source matches what was sent, the picture does not. */
+  s.setPicture('theirs')
+  session.command({ kind: 'rename', name: 'C' } as never)
+  await assert.rejects(session.save({ thumbnail: 'mine-2' }), /다른 편집에서/)
+  assert.equal(session.read().dirty, true)
+})