@things-factory/figure-ui 10.1.241 → 10.1.244

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-ui",
-  "version": "10.1.241",
+  "version": "10.1.244",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -42,11 +42,11 @@
     "@operato/slot-layout-editor": "^10.29.58",
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.29.43",
-    "@things-factory/ai-assistant": "^10.1.241",
-    "@things-factory/figure-service": "^10.1.241",
+    "@things-factory/ai-assistant": "^10.1.244",
+    "@things-factory/figure-service": "^10.1.244",
     "@things-factory/figure-viewer": "^10.1.227",
-    "@things-factory/setting-base": "^10.1.241",
+    "@things-factory/setting-base": "^10.1.244",
     "three": "^0.185.1"
   },
-  "gitHead": "d7fe2e1a1eb7c02cb21b897da26d385df014f908"
+  "gitHead": "f80402ed4e682642b9dfb3ce68d8b00d591d44ee"
 }

package/test/browser/category-page.js

@@ -17,12 +17,14 @@ document.body.append(panel)
 window.harness = {
   panel,
   asked,
-  async show({ categories, category }) {
+  /** `saved`: the category the server holds -- the one shown, unless a choice is held for the save. */
+  async show({ categories, category, saved = category }) {
     await session.open('f1')
     panel.revision = session.revisionNow()
     panel.figureId = 'f1'
     panel.figureCategories = categories
     panel.figureCategory = category
+    panel.figureCategorySaved = saved
     await panel.updateComplete
   }
 }

package/test/browser/category.check.mjs

@@ -51,4 +51,10 @@ describe('the category field', () => {
     await page().evaluate(() => harness.show({ categories: ['EQUIPMENT', 'CARRIER'], category: 'EQUIPMENT' }))
     assert.deepEqual(await field(), { kind: 'select', disabled: true, value: 'EQUIPMENT', options: ['EQUIPMENT', 'CARRIER'] })
   })
+
+  /* Chosen and held for the save (2026-11-01 audit item 5): set once is set on the server, so a wrong pick is picked again. */
+  test('with a vocabulary and one chosen, not saved yet: it may be chosen again', async () => {
+    await page().evaluate(() => harness.show({ categories: ['EQUIPMENT', 'CARRIER'], category: 'EQUIPMENT', saved: null }))
+    assert.deepEqual(await field(), { kind: 'select', disabled: false, value: 'EQUIPMENT', options: ['EQUIPMENT', 'CARRIER'] })
+  })
 })

package/test/browser/product-page.check.mjs

@@ -104,6 +104,70 @@ describe('a save whose answer never came back', () => {
   })
 })
 
+/*
+  Another editor saved the figure first (2026-11-01 audit item 6): the edits stay, what differs is said by part, and the
+  ways on are asked -- a copy, the latest in a new tab, or writing over it.
+*/
+describe('a save another editor got in before', () => {
+  before(async () => {
+    await fresh()
+  })
+  const conflictOn = async (id, theirs) => {
+    await read(id => product.seed({ id, type: id, source: product.boxSource('Mine') }), id)
+    await open(id)
+    await press('figure-editor >>> figure-parts >>> button[shape]', 'a part added')
+    await until(() => product.view().dirty, 'edited')
+    await read(({ id, theirs }) => product.seed({ id, type: id, source: product.boxSource(theirs) }), { id, theirs })
+    await read(() => product.forget())
+    await press('button[save]', 'save')
+    await until(() => !!product.deep('figure-save-conflict')[0], 'the conflict asked')
+  }
+  const differs = () => read(() => [...product.deep('figure-save-conflict >>> ul[differs] li')].map(li => li.textContent.replace(/\s+/g, ' ').trim()))
+
+  test('the latest in a new tab: the edits stay, unsaved, and the next save asks again', async () => {
+    await conflictOn('k1', 'Theirs')
+    const added = await read(() => JSON.parse(product.view().source).document.model.nodes.find(n => n.op === 'place@1' && n.id !== 'box').id)
+    assert.deepEqual(await differs(), [`figure.label.conflict-mine-only ${added}`, 'figure.text.conflict-other-changed'])
+    await read(() => { window.opened = []; window.open = (...a) => (window.opened.push(a[0]), null) })
+    await press('figure-save-conflict >>> md-outlined-button[latest]', 'the latest')
+    await until(() => !product.deep('figure-save-conflict')[0], 'closed')
+    assert.deepEqual(await read(() => window.opened), [await read(() => location.href)])
+    const view = await read(() => product.view())
+    assert.deepEqual({ id: view.id, dirty: view.dirty }, { id: 'k1', dirty: true })
+    assert.equal(JSON.parse((await read(() => product.rows())).find(r => r.id === 'k1').source).name, 'Theirs')
+  })
+
+  test('kept as a copy: a new figure saved by the first save\'s question, the other left as the server holds it', async () => {
+    await read(() => product.deep('figure-save-conflict')[0] && product.deep('figure-save-conflict >>> md-text-button[slot=cancel]')[0].click())
+    /* Tags changed and not saved go with the copy (2026-11-01 re-check). */
+    await change('figure-properties >>> input[placeholder="figure.text.tags-placeholder"]', 'new-tag')
+    await read(() => product.forget())
+    await press('button[save]', 'save')
+    await until(() => !!product.deep('figure-save-conflict')[0], 'the conflict asked again')
+    await press('figure-save-conflict >>> md-filled-button[copy]', 'save as a copy')
+    await until(() => !!product.deep('figure-first-save')[0], 'the first save asked')
+    assert.notEqual(await read(() => product.deep('figure-first-save >>> #type')[0].value), 'k1', 'the identifier of the figure left is not offered')
+    await press('figure-first-save >>> md-filled-button[slot=confirm]', 'the first save')
+    await until(() => product.view().id && product.view().id !== 'k1' && !product.view().dirty, 'saved as a figure of its own')
+    const copy = await read(() => product.view().id)
+    await until(c => product.rows().find(r => r.id === c)?.tags?.length, 'the tags written to the copy', copy)
+    assert.deepEqual(await callsTo('updateFigure'), [{ id: copy, patch: { tags: ['new-tag'] } }])
+    const rows = await read(() => product.rows())
+    assert.equal(JSON.parse(rows.find(r => r.id === 'k1').source).name, 'Theirs')
+    assert.equal(JSON.parse(rows.find(r => r.id === copy).source).document.model.nodes.filter(n => n.op === 'place@1').length, 2, 'the copy has the edits')
+    assert.equal(await read(() => location.pathname.endsWith(`/figure-modeller/${product.view().id}`)), true, 'the address is the copy\'s')
+  })
+
+  test('written over, once more agreed: saved over the latest, and nothing else asked', async () => {
+    await conflictOn('k2', 'Theirs')
+    await press('figure-save-conflict >>> md-text-button[overwrite]', 'overwrite')
+    await press('ox-prompt >>> #confirm', 'confirm the overwrite')
+    await until(() => !product.view().dirty, 'saved')
+    assert.equal(JSON.parse((await read(() => product.rows())).find(r => r.id === 'k2').source).name, 'Mine')
+    assert.equal(await read(() => product.view().id), 'k2')
+  })
+})
+
 describe('a released figure the server makes a draft again', () => {
   before(async () => {
     await fresh()
@@ -136,25 +200,153 @@ describe('a released figure the server makes a draft again', () => {
     assert.equal(await releaseState(), 'figure.text.release-state-draft-over {"version":"2"}')
   })
 
-  test('its category changed: written to the row at once, told, and the state follows', async () => {
+  /*
+    The row's fields are saved by 「저장」 with the figure (2026-11-01 audit item 5): written at once, they stayed after
+    leaving without saving, and the save button never lit for them.
+  */
+  test('its category changed: held, the save lit; 「저장」 writes the row alone, told, and the state follows', async () => {
     await open('c')
     await until(() => product.deep('[release-state]')[0]?.textContent.includes('released'), 'released')
     await read(() => {
       product.forget()
-      product.answer('updateFigure', v => {
-        const answer = product.server('updateFigure', v)
-        answer.figure.state = 'draft'
-        return answer
-      })
+      product.answer('updateFigure', v => product.server('updateFigure', { ...v, patch: { ...v.patch, state: 'draft' } }))
     })
     const before = await read(() => product.view())
     await change('figure-properties >>> input[placeholder="figure.text.category-placeholder"]', 'conveyors')
+    assert.deepEqual(await callsTo('updateFigure'), [], 'nothing written yet')
+    assert.equal((await read(() => product.view())).dirty, true)
+    await press('button[save]', 'save')
     await until(() => product.deep('[release-state]')[0]?.textContent.includes('draft-over'), 'the state follows')
     assert.deepEqual(await callsTo('updateFigure'), [{ id: 'c', patch: { category: 'conveyors' } }])
+    assert.deepEqual(await callsTo('saveFigure'), [], 'the source is not written again')
     assert.deepEqual(await notices(), [{ level: 'info', message: 'figure.text.released-now-draft' }])
     const now = await read(() => product.view())
     assert.equal(now.source, before.source, 'the row, not the figure')
     assert.equal(now.dirty, false)
+    assert.equal(await read(() => product.deep('figure-properties >>> input[placeholder="figure.text.category-placeholder"]')[0].value), 'conveyors')
+  })
+
+  /* 2026-11-01 re-check: typed while the save was on its way, the field showed it, the server had the first, and nothing was unsaved. */
+  test('tags typed while their save is on its way: shown, still to save, and saved by the next 「저장」', async () => {
+    await read(() => product.seed({ id: 't', type: 'tag', source: product.boxSource('T') }))
+    await open('t')
+    await read(() => {
+      window.gate = new Promise(go => (window.letGo = go))
+      product.answer('updateFigure', async v => (await window.gate, product.server('updateFigure', v)))
+    })
+    const tags = 'figure-properties >>> input[placeholder="figure.text.tags-placeholder"]'
+    await change(tags, 'first')
+    await press('button[save]', 'save')
+    await until(() => product.page().session.read().saving, 'saving')
+    await change(tags, 'second')
+    await read(() => { window.letGo(); product.answer('updateFigure') })
+    await until(() => !product.page().session.read().saving, 'saved')
+    assert.equal((await read(() => product.rows())).find(r => r.id === 't').tags.join(), 'first')
+    assert.equal((await read(() => product.view())).dirty, true, 'the second is still to save')
+    assert.equal(await read(s => product.deep(s)[0].value, tags), 'second')
+    await press('button[save]', 'save')
+    await until(() => !product.view().dirty, 'saved again')
+    assert.equal((await read(() => product.rows())).find(r => r.id === 't').tags.join(), 'second')
+  })
+
+  /* 2026-11-01 second re-check: put back to the old tags while the save wrote others, the screen said old, the server the others, nothing unsaved. */
+  test('tags put back to the old ones while their save is on its way: still to save, and the next 「저장」 writes them', async () => {
+    await read(() => product.seed({ id: 'u', type: 'untag', tags: ['old'], source: product.boxSource('U') }))
+    await open('u')
+    await read(() => {
+      window.gate = new Promise(go => (window.letGo = go))
+      product.answer('updateFigure', async v => (await window.gate, product.server('updateFigure', v)))
+    })
+    const tags = 'figure-properties >>> input[placeholder="figure.text.tags-placeholder"]'
+    await until(s => product.deep(s)[0]?.value === 'old', 'the tags read', tags)
+    await change(tags, 'first')
+    await press('button[save]', 'save')
+    await until(() => product.page().session.read().saving, 'saving')
+    await change(tags, 'old')
+    await read(() => { window.letGo(); product.answer('updateFigure') })
+    await until(() => !product.page().session.read().saving, 'saved')
+    assert.equal((await read(() => product.rows())).find(r => r.id === 'u').tags.join(), 'first')
+    assert.equal((await read(() => product.view())).dirty, true, 'the old tags are still to save')
+    assert.equal(await read(s => product.deep(s)[0].value, tags), 'old')
+    /* Compared with what the row holds now: the ones written are no change, the old ones are. */
+    await change(tags, 'first')
+    await until(() => !product.view().dirty, 'the row read again: first is what it holds')
+    await change(tags, 'old')
+    assert.equal((await read(() => product.view())).dirty, true)
+    await press('button[save]', 'save')
+    await until(() => !product.view().dirty, 'saved again')
+    assert.equal((await read(() => product.rows())).find(r => r.id === 'u').tags.join(), 'old')
+  })
+
+  /* 2026-11-01 third re-check: typed between the save's answer and the row read again, a value was let go, then written over. */
+  test('tags typed after the save answered and before the row is read again: compared with what was written, and kept', async () => {
+    await read(() => product.seed({ id: 'v', type: 'vtag', tags: ['old'], source: product.boxSource('V') }))
+    await open('v')
+    const tags = 'figure-properties >>> input[placeholder="figure.text.tags-placeholder"]'
+    await until(s => product.deep(s)[0]?.value === 'old', 'the tags read', tags)
+    await read(() => {
+      window.gate = new Promise(go => (window.letGo = go))
+      window.rowGate = new Promise(go => (window.letRowGo = go))
+      product.answer('updateFigure', async v => (await window.gate, product.server('updateFigure', v)))
+      window.rowAnswered = 0
+      product.answer('figure', async v => (await window.rowGate, window.rowAnswered++, product.server('figure', v)))
+    })
+    await change(tags, 'first')
+    await press('button[save]', 'save')
+    await until(() => product.page().session.read().saving, 'saving')
+    await change(tags, 'second')
+    await read(() => window.letGo())
+    await until(() => !product.page().session.read().saving, 'the save answered')
+    assert.equal((await read(() => product.view())).dirty, true, 'second is still to save')
+    /* The row not read again yet. */
+    await change(tags, 'old')
+    assert.equal((await read(() => product.view())).dirty, true, 'old is a change from first, which the row holds now')
+    await read(() => { window.letRowGo(); product.answer('figure'); product.answer('updateFigure') })
+    await until(() => window.rowAnswered > 0, 'the row read again')
+    await read(() => new Promise(go => requestAnimationFrame(() => setTimeout(go, 50))))
+    assert.equal(await read(s => product.deep(s)[0].value, tags), 'old', 'not written over by the reading')
+    await press('button[save]', 'save')
+    await until(() => !product.view().dirty, 'saved again')
+    assert.equal((await read(() => product.rows())).find(r => r.id === 'v').tags.join(), 'old')
+  })
+
+  test('a reading of the row that comes back after a later one is not the row now', async () => {
+    await read(() => product.seed({ id: 'w', type: 'wtag', tags: ['old'], source: product.boxSource('W') }))
+    await open('w')
+    const tags = 'figure-properties >>> input[placeholder="figure.text.tags-placeholder"]'
+    await until(s => product.deep(s)[0]?.value === 'old', 'the tags read', tags)
+    await read(() => {
+      window.firstReading = new Promise(go => (window.letFirstGo = go))
+      window.readings = 0
+      /* The first reading after a save is taken as the server holds the row then, and answers late. */
+      product.answer('figure', async v => {
+        const answer = product.server('figure', v)
+        if (window.readings++ === 0) await window.firstReading
+        return answer
+      })
+    })
+    await change(tags, 'a')
+    await press('button[save]', 'save')
+    await until(() => !product.view().dirty && window.readings === 1, 'saved, its reading on its way')
+    await change(tags, 'b')
+    await press('button[save]', 'save')
+    await until(() => !product.view().dirty && window.readings === 2, 'saved again, read')
+    await read(() => { window.letFirstGo(); product.answer('figure') })
+    await read(() => new Promise(go => requestAnimationFrame(() => setTimeout(go, 50))))
+    assert.equal(await read(s => product.deep(s)[0].value, tags), 'b')
+    await change(tags, 'b')
+    assert.equal((await read(() => product.view())).dirty, false, 'b is what the row holds')
+  })
+
+  test('tags changed and the figure left without saving: the row keeps what it had, and undo is the figure\'s', async () => {
+    await open('n')
+    await read(() => product.forget())
+    await change('figure-properties >>> input[placeholder="figure.text.tags-placeholder"]', 'belt, roller')
+    assert.equal((await read(() => product.view())).dirty, true)
+    assert.equal(await beforeUnload(), true)
+    await read(() => product.page().session.open('o', { discard: true }))
+    assert.deepEqual(await callsTo('updateFigure'), [])
+    assert.deepEqual((await read(() => product.rows())).find(r => r.id === 'n').tags ?? [], [])
   })
 })
 
@@ -628,6 +820,76 @@ describe('the page around the figure: the shell, the dock, the properties', () =
     assert.deepEqual(await said(), [{ call: 'clear' }])
   })
 
+  /*
+    A page left is kept by the shell with its editor on the window (2026-11-01 audit): a key pressed elsewhere is not
+    its, and its unsaved edits are still lost by closing the tab.
+  */
+  test('left behind: keys pressed elsewhere leave the figure alone, and closing the tab still asks', async () => {
+    await open('d')
+    await pick('leaf')
+    await until(() => assistant.surface.hostContext().selection?.part === 'leaf', 'leaf picked')
+    const before = await read(() => product.view())
+    await read(() => product.leave())
+    await read(() => document.activeElement?.blur())
+    for (const key of ['Backspace', 'Delete']) await page().keyboard.press(key)
+    await page().keyboard.down('Control')
+    for (const key of ['d', 'v', 'z']) await page().keyboard.press(key)
+    await page().keyboard.up('Control')
+    const after = await read(() => product.view())
+    assert.deepEqual({ revision: after.revision, dirty: after.dirty, source: after.source }, { revision: before.revision, dirty: before.dirty, source: before.source })
+    await open('d')
+    await rename('Door 4')
+    await until(() => product.view().dirty, 'edited')
+    await read(() => product.leave())
+    assert.equal(await beforeUnload(), true, 'a page left with unsaved edits holds the tab too')
+    await read(() => product.page().session.undo())
+    await until(() => !product.view().dirty, 'undone')
+    assert.equal(await beforeUnload(), false)
+  })
+
+  test('the preview: Backspace removes nothing, and 「fit」 fits the preview in front', async () => {
+    await open('d')
+    await pick('leaf')
+    await press('figure-editor >>> button[mode]:not([aria-pressed=true])', 'the preview')
+    await until(() => !!product.deep('figure-editor >>> figure-preview')[0]?.checkVisibility(), 'the preview shown')
+    const before = await read(() => product.view())
+    await read(() => document.activeElement?.blur())
+    await page().keyboard.press('Backspace')
+    await page().keyboard.press('Delete')
+    const after = await read(() => product.view())
+    assert.deepEqual({ revision: after.revision, dirty: after.dirty }, { revision: before.revision, dirty: before.dirty })
+    const fitted = await read(() => {
+      const fitted = []
+      const preview = product.deep('figure-editor >>> figure-preview')[0]
+      const canvas = product.deep('figure-editor >>> figure-canvas')[0]
+      preview.fitView = () => fitted.push('preview')
+      canvas.fit = () => fitted.push('edit')
+      product.deep('figure-editor >>> ox-canvas-bar')[0].dispatchEvent(new CustomEvent('canvas-fit', { bubbles: true, composed: true }))
+      delete preview.fitView
+      delete canvas.fit
+      return fitted
+    })
+    assert.deepEqual(fitted, ['preview'])
+    await press('figure-editor >>> button[mode]:not([aria-pressed=true])', 'the edit canvas')
+  })
+
+  test('by the keyboard: a part is picked by its row\'s button; the tab in front and each field say what they are', async () => {
+    await open('d')
+    await page().keyboard.press('Escape')
+    await read(() => [...product.deep('figure-editor >>> figure-parts >>> button[pick]')].find(b => b.textContent.includes('frame')).focus())
+    await page().keyboard.press('Enter')
+    await until(() => assistant.surface.hostContext().selection?.part === 'frame', 'frame picked by Enter')
+    const rows = await read(() => [...product.deep('figure-editor >>> figure-parts >>> button[pick]')].map(b => [b.querySelector('span[label]').title, b.getAttribute('aria-pressed')]))
+    assert.deepEqual(rows.filter(([, pressed]) => pressed === 'true'), [['frame', 'true']])
+    await page().keyboard.press('Escape')
+    await press(TAB('properties'), 'the properties tab')
+    const tabs = await read(() => [...product.deep('figure-editor >>> button[tab]')].filter(b => b.getAttribute('aria-pressed') === 'true').map(b => b.getAttribute('aria-label')))
+    assert.deepEqual(tabs, ['figure.label.tab-short-properties'])
+    await until(() => product.deep('figure-modeller-page >>> figure-properties')[0]?.checkVisibility(), 'the figure properties shown')
+    const labelled = await read(() => [...product.deep('figure-modeller-page >>> figure-properties')[0].shadowRoot.querySelectorAll('div[field] > label')].map(l => [l.textContent.trim(), l.control?.localName ?? null]))
+    assert.deepEqual(labelled, [['figure.label.name', 'input'], ['figure.label.figure-placement', 'select'], ['figure.label.category', 'input'], ['figure.label.tags', 'input']])
+  })
+
   test('gone: the surface is taken back, and the tab is no longer held', async () => {
     await open('d')
     await rename('Door 3')

package/test/browser/product-page.js

@@ -81,7 +81,10 @@ function row(id) {
 const answers = {
   figure: ({ id }) => ({ __typename: 'Figure', properties: null, tags: null, category: null, description: null, score: null, triangles: null, groups: null, thumbnailUpdatedAt: null, updatedAt: null, updater: null, thumbnailHash: null, ...row(id) }),
   figureTypeNames: () => [...rows.values()].map(r => r.type),
-  saveFigure: async ({ id, source, type, creationId, thumbnail, proposalKeys }) => {
+  saveFigure: async ({ id, source, expectedSource, type, creationId, thumbnail, proposalKeys }) => {
+    /* Written only over the source the editor opened, as figure-write.ts writes. */
+    if (id && expectedSource !== undefined && expectedSource !== row(id).source)
+      throw Object.assign(Error('changed elsewhere'), { graphQLErrors: [{ message: 'changed elsewhere', extensions: { code: 'FIGURE_SOURCE_CONFLICT' } }] })
     const saved = id ? row(id) : { id: creationId ?? `made-${++made}`, namespace: null, type: type ?? `figure-${made}`, state: 'draft', version: 0 }
     /* The save's record of the proposals its source holds, as the server keeps it (figure-proposal.ts). */
     for (const key of proposalKeys ?? []) if (!records.some(r => r.proposalKey === key && r.figureId === saved.id)) records.push({ proposalKey: key, figureId: saved.id })

package/test/browser/screen.check.mjs

@@ -1102,6 +1102,9 @@ describe('the modeller page: the editor with the page\'s figure panel, verdict a
     await field.click({ clickCount: 3 })
     await page().keyboard.type('probe-renamed')
     await page().keyboard.press('Tab')
+    /* Held until 「저장」 (2026-11-01 audit item 5): the server judges the row, so the new type is asked once saved. */
+    assert.equal((await calls('updateFigure')).length, 0, 'not written before the save')
+    await press('the save', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[save]'))
     await until('the type renamed on the server', () => product.calls().some(c => c.field === 'updateFigure' && c.variables.patch?.type === 'probe-renamed'))
     await until('asked again', asked => product.calls().filter(c => c.field === 'inspectFigureDraft').length > asked, asked)
   })

package/test/browser/section.check.mjs

@@ -248,6 +248,27 @@ describe('the section editor on a drawn section: typed, previewed, applied or le
     await until(() => probe.drawnShape('wedge').section.points.length === 3, 'the solid drawn with three points')
   })
 
+  /* A page left keeps the modeller, and this editor, on the window (2026-11-01 audit item 1, found again in the re-check). */
+  test('on a page left, Delete and Ctrl+Z are not the editor\'s: no point deleted, none brought back', async () => {
+    await press('g[point="p3"] circle', { within: 'figure-section-editor' })
+    await read(() => (findDeep('figure-editor').active = false))
+    await page().keyboard.press('Delete')
+    await page().keyboard.down('Control')
+    await page().keyboard.press('KeyZ')
+    await page().keyboard.up('Control')
+    await sleep(100)
+    assert.equal((await editorNow()).points, 3)
+    await read(() => (findDeep('figure-editor').active = true))
+    await page().keyboard.down('Control')
+    await page().keyboard.press('KeyZ')
+    await page().keyboard.up('Control')
+    await until(() => probe.sectionEditor().points === 4, 'in front again, Ctrl+Z is the editor\'s')
+    /* Left as the test before left it, with its change: the next asks about it. */
+    await press('g[point="p4"] circle', { within: 'figure-section-editor' })
+    await page().keyboard.press('Delete')
+    await until(() => probe.sectionEditor().points === 3, 'p4 deleted again')
+  })
+
   test('picking another part with changes keeps the part until the editor is closed: asked, let go, then the pick goes on', async () => {
     const start = await state()
     const at = await read(() => probe.row('block'))

package/test/keys.test.ts

@@ -52,3 +52,11 @@ test('복사 · 붙여넣기는 모델러의 것 — 고른 부품의 Ctrl+C 는
   assert.equal(keyActionOf({ key: 'x', ctrlKey: true }, 'arm'), 'hold')
   assert.equal(keyActionOf({ key: 'v', ctrlKey: true, target: { tagName: 'INPUT' } }, ''), null, '칸 안의 붙여넣기는 칸의 것')
 })
+
+test('in the preview no key edits a part: removing, duplicating, pasting and the gizmo stay in the edit canvas', () => {
+  for (const key of ['Delete', 'Backspace', 'w', 'e', 'r']) assert.equal(keyActionOf({ key, previewing: true }, 'arm'), null, key)
+  assert.equal(keyActionOf({ key: 'd', ctrlKey: true, previewing: true }, 'arm'), null)
+  assert.equal(keyActionOf({ key: 'v', ctrlKey: true, previewing: true }, 'arm'), 'hold', 'kept from the scene, and not pasted')
+  assert.equal(keyActionOf({ key: 'z', ctrlKey: true, previewing: true }, ''), 'undo', 'undo stays, as the bar has it')
+  assert.equal(keyActionOf({ key: 'Escape', previewing: true }, 'arm'), 'deselect')
+})

package/test/product-session.test.ts

@@ -21,7 +21,8 @@ function deferred<T>() {
 }
 const store = {
   load: async (id: string) => ({ id, source: source(id) }),
-  save: async (q: { id?: string; source: string }) => ({ id: q.id ?? 'created', source: q.source })
+  save: async (q: { id?: string; source: string }) => ({ id: q.id ?? 'created', source: q.source }),
+  updateCatalog: async () => ({})
 }
 
 test('existing model -> new clears geometry, ID, history and derived state', async () => {
@@ -131,3 +132,138 @@ test('retry after a lost create response reuses the same creation identity', asy
   assert.equal(keys[0], keys[1])
   assert.ok(keys[0])
 })
+
+/*
+  The catalogue fields (type, category, tags) are the row's: held by the session and written by 「저장」 with the
+  figure, so leaving without saving leaves them as the server had them (2026-11-01 audit item 5).
+*/
+test('catalogue fields are held until 「저장」: unsaved, they hold the figure; changed back, they are no change', async () => {
+  const s = createFigureProductSession(store)
+  assert.throws(() => s.editCatalog({ tags: ['a'] }, {}), { code: 'SESSION_NOT_SAVED' })
+  await s.open('A')
+  s.editCatalog({ tags: ['conveyor'] }, { tags: [] })
+  assert.deepEqual(s.read().catalog, { tags: ['conveyor'] })
+  assert.equal(s.read().dirty, true)
+  assert.equal(s.read().canUndo, false, 'not a step of the figure')
+  await assert.rejects(s.open('B'), /저장하지 않은/)
+  s.editCatalog({ tags: [] }, { tags: [] })
+  assert.equal(s.read().dirty, false)
+  s.editCatalog({ category: 'C' }, { category: undefined })
+  await s.open('B', { discard: true })
+  assert.deepEqual(s.read().catalog, {})
+})
+test('only the catalogue changed: 「저장」 writes the row and not the source', async () => {
+  const sent: string[] = []
+  const s = createFigureProductSession({
+    ...store,
+    save: async q => (sent.push('source'), store.save(q)),
+    updateCatalog: async (id, patch) => (sent.push(`row ${id} ${JSON.stringify(patch)}`), {})
+  })
+  await s.open('A')
+  s.editCatalog({ category: 'conveyors', tags: ['belt'] }, {})
+  await s.save()
+  assert.deepEqual(sent, ['row A {"category":"conveyors","tags":["belt"]}'])
+  assert.equal(s.read().dirty, false)
+})
+test('the source and the catalogue: the source first; a row refused keeps the catalogue held, the source saved', async () => {
+  const sent: string[] = []
+  const s = createFigureProductSession({
+    ...store,
+    save: async q => (sent.push('source'), store.save(q)),
+    updateCatalog: async () => {
+      sent.push('row')
+      throw Object.assign(Error('the type is taken'), { code: 'figure-type-taken' })
+    }
+  })
+  await s.open('A')
+  s.apply([{ kind: 'set-design', input: 'body.size.y', unit: 'mm', value: 200 }])
+  s.editCatalog({ type: 'gate' }, { type: 'door' })
+  await assert.rejects(s.save(), /taken/)
+  assert.deepEqual(sent, ['source', 'row'])
+  assert.equal(s.read().saving, false)
+  assert.deepEqual(s.read().catalog, { type: 'gate' })
+  assert.equal(s.read().dirty, true, 'the catalogue is still to save')
+  assert.equal(s.read().canUndo, true)
+  s.editCatalog({ type: 'door' }, { type: 'door' })
+  assert.equal(s.read().dirty, false, 'the source was saved')
+})
+test('a catalogue field changed while its save is on the way: shown, and held for the next save', async () => {
+  const writing = deferred<unknown>()
+  const sent: object[] = []
+  const s = createFigureProductSession({ ...store, updateCatalog: (_id: string, patch: object) => (sent.push(patch), writing.promise) })
+  await s.open('A')
+  s.editCatalog({ tags: ['first'], category: 'C' }, {})
+  const saving = s.save()
+  s.editCatalog({ tags: ['second'] }, {})
+  writing.resolve({})
+  await saving
+  assert.deepEqual(sent, [{ tags: ['first'], category: 'C' }])
+  assert.deepEqual(s.read().catalog, { tags: ['second'] }, 'the category saved; the tags typed since still to save')
+  assert.equal(s.read().dirty, true)
+  /* Changed back to what was sent while it was on its way: nothing left to save. */
+  const again = deferred<unknown>()
+  const t = createFigureProductSession({ ...store, updateCatalog: () => again.promise })
+  await t.open('A')
+  t.editCatalog({ tags: ['first'] }, {})
+  const second = t.save()
+  t.editCatalog({ tags: ['other'] }, {})
+  t.editCatalog({ tags: ['first'] }, {})
+  again.resolve({})
+  await second
+  assert.equal(t.read().dirty, false)
+})
+
+/* 2026-11-01 second re-check: put back to the old value while the save writes another, it was let go -- the row kept the other. */
+test('a field put back to its old value while a save writes another is held: the old value is a change once that save lands', async () => {
+  const writing = deferred<unknown>()
+  const s = createFigureProductSession({ ...store, updateCatalog: () => writing.promise })
+  await s.open('A')
+  s.editCatalog({ tags: ['first'] }, { tags: ['old'] })
+  const saving = s.save()
+  s.editCatalog({ tags: ['old'] }, { tags: ['old'] })
+  writing.resolve({})
+  await saving
+  assert.deepEqual(s.read().catalog, { tags: ['old'] })
+  assert.equal(s.read().dirty, true)
+  /* While the source is being written, before the row: the same. */
+  const source = deferred<FigureProductRecord>()
+  const t = createFigureProductSession({ ...store, save: () => source.promise })
+  await t.open('A')
+  t.command({ kind: 'rename', name: 'B' } as never)
+  t.editCatalog({ tags: ['first'] }, { tags: ['old'] })
+  const both = t.save()
+  t.editCatalog({ tags: ['old'] }, { tags: ['old'] })
+  source.resolve({ id: 'A', source: t.source() })
+  await both
+  assert.deepEqual(t.read().catalog, { tags: ['old'] })
+  /* Typed again as sent, and the save refused: still held, nothing lost. */
+  const refused = deferred<unknown>()
+  const u = createFigureProductSession({ ...store, updateCatalog: () => refused.promise })
+  await u.open('A')
+  u.editCatalog({ tags: ['first'] }, { tags: ['old'] })
+  const failing = u.save()
+  u.editCatalog({ tags: ['first'] }, { tags: ['old'] })
+  refused.reject(Error('refused'))
+  await assert.rejects(failing)
+  assert.deepEqual(u.read().catalog, { tags: ['first'] })
+  /* After a save lands, back to the old value is no change. */
+  s.editCatalog({ tags: ['old'] }, { tags: ['first'] })
+  assert.deepEqual(s.read().catalog, { tags: ['old'] }, 'compared with what the row holds now')
+})
+
+/* 2026-11-01 third re-check: what a save wrote is told the moment it answers, for a screen to compare with before it reads the row. */
+test('what the last save wrote of the catalogue is told; a save that writes none tells none', async () => {
+  const s = createFigureProductSession(store)
+  await s.open('A')
+  s.editCatalog({ tags: ['first'], category: 'C' }, { tags: ['old'] })
+  await s.save()
+  assert.deepEqual(s.read().catalogWritten, { tags: ['first'], category: 'C' })
+  s.command({ kind: 'rename', name: 'B' } as never)
+  await s.save()
+  assert.deepEqual(s.read().catalogWritten, {}, 'a later save of the source alone')
+  const refused = createFigureProductSession({ ...store, updateCatalog: async () => Promise.reject(Error('refused')) })
+  await refused.open('A')
+  refused.editCatalog({ tags: ['x'] }, {})
+  await assert.rejects(refused.save())
+  assert.deepEqual(refused.read().catalogWritten, {})
+})

package/test/save-conflict.test.ts

@@ -0,0 +1,41 @@
+/*
+ * What differs between the edits on screen and the server's latest when a save is refused for a conflict.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { addFigureBox, applyFigureAuthoring, createFigureAsset } from '@hatiolab/figure-model'
+
+import { saveConflictChangesOf } from '../client/modeller/save-conflict.ts'
+
+const base = (lid = 10) =>
+  addFigureBox(addFigureBox(createFigureAsset('Gate'), { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } }), {
+    id: 'lid',
+    size: { x: 100, y: lid, z: 100 },
+    position: { x: 0, y: 105, z: 0 }
+  })
+
+test('the same figure: nothing differs', () => {
+  assert.deepEqual(saveConflictChangesOf(base(), base()), { changed: [], mineOnly: [], theirsOnly: [], otherChanged: false })
+})
+
+test('a part made differently is named, and only it', () => {
+  const theirs = base(30)
+  assert.deepEqual(saveConflictChangesOf(base(), theirs), { changed: ['lid'], mineOnly: [], theirsOnly: [], otherChanged: false })
+})
+
+test('a part on one side only is named on its side', () => {
+  const mine = addFigureBox(base(), { id: 'arm', size: { x: 10, y: 10, z: 10 }, position: { x: 0, y: 0, z: 0 } })
+  const theirs = addFigureBox(base(), { id: 'leg', size: { x: 10, y: 10, z: 10 }, position: { x: 0, y: 0, z: 0 } })
+  assert.deepEqual(saveConflictChangesOf(mine, theirs), { changed: [], mineOnly: ['arm'], theirsOnly: ['leg'], otherChanged: false })
+})
+
+test('the name differs: not a part, said as something else', () => {
+  const theirs = applyFigureAuthoring(base(), { kind: 'rename', name: 'Gate 2' } as never)
+  assert.deepEqual(saveConflictChangesOf(base(), theirs), { changed: [], mineOnly: [], theirsOnly: [], otherChanged: true })
+})
+
+test('a part\'s look differs: the part is named, not something else', () => {
+  const theirs = base() as unknown as { appearance: { target: string; material: unknown }[] }
+  theirs.appearance = theirs.appearance.map(look => (look.target === 'lid' ? { ...look, material: { token: 'palette.secondary' } } : look))
+  assert.deepEqual(saveConflictChangesOf(base(), theirs as never), { changed: ['lid'], mineOnly: [], theirsOnly: [], otherChanged: false })
+})