@things-factory/figure-ui 10.1.243 → 10.1.245

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-ui",
-  "version": "10.1.243",
+  "version": "10.1.245",
   "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.245",
+    "@things-factory/figure-service": "^10.1.245",
     "@things-factory/figure-viewer": "^10.1.227",
-    "@things-factory/setting-base": "^10.1.241",
+    "@things-factory/setting-base": "^10.1.245",
     "three": "^0.185.1"
   },
-  "gitHead": "70a77f8a032f297a9d756ad530d3072e7a6c4bed"
+  "gitHead": "f7479631094a1c70b486485b556885b069025f88"
 }

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()
@@ -162,6 +226,118 @@ describe('a released figure the server makes a draft again', () => {
     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())

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/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/product-session.test.ts

@@ -187,16 +187,83 @@ test('the source and the catalogue: the source first; a row refused keeps the ca
   s.editCatalog({ type: 'door' }, { type: 'door' })
   assert.equal(s.read().dirty, false, 'the source was saved')
 })
-test('while a save is on the way the catalogue waits; the save done, nothing is held', async () => {
+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 s = createFigureProductSession({ ...store, updateCatalog: () => writing.promise })
+  const sent: object[] = []
+  const s = createFigureProductSession({ ...store, updateCatalog: (_id: string, patch: object) => (sent.push(patch), writing.promise) })
   await s.open('A')
-  s.editCatalog({ tags: ['a'], category: 'C' }, {})
+  s.editCatalog({ tags: ['first'], category: 'C' }, {})
   const saving = s.save()
-  assert.throws(() => s.editCatalog({ tags: ['b'] }, {}), { code: 'SESSION_SAVING' })
+  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, {})
-  assert.equal(s.read().dirty, false)
+  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 })
+})

package/test/save-landed.test.ts

@@ -214,3 +214,78 @@ test('the answer lost after the picture was written: read back by its hash, it w
   assert.equal(session.read().dirty, false, 'source and picture both landed')
   assert.equal(await thumbnailHashOf('not a picture'), undefined)
 })
+
+/*
+  A real conflict -- another editor saved first -- leaves the edits here, with the server's latest kept to compare with
+  and, only when the person says so, to write over or to leave as it is by keeping the edits as a copy (2026-11-01 audit
+  item 6).
+*/
+test('a conflict keeps the latest; written over, the next save expects it; another change meanwhile is a conflict again', async () => {
+  const s = server()
+  const session = createFigureProductSession(s.store)
+  await session.open('a')
+  session.command({ kind: 'rename', name: 'Mine' } as never)
+  const theirs = serializeFigureAsset(addFigureBox(createFigureAsset('Theirs'), { id: 'body', size: { x: 50, y: 50, z: 50 }, position: { x: 0, y: 25, z: 0 } }))
+  s.setRow(theirs)
+  await assert.rejects(session.save(), { code: 'FIGURE_SOURCE_CONFLICT' })
+  assert.deepEqual(session.read().conflict, { latest: theirs })
+  assert.equal(session.read().dirty, true)
+  assert.equal(session.read().name, 'Mine', 'the edits stay')
+  /* Still the other's: saving again is the same conflict. */
+  await assert.rejects(session.save(), { code: 'FIGURE_SOURCE_CONFLICT' })
+  session.overwriteConflict()
+  assert.equal(session.read().conflict, undefined)
+  const third = serializeFigureAsset(createFigureAsset('Third'))
+  s.setRow(third)
+  await assert.rejects(session.save(), { code: 'FIGURE_SOURCE_CONFLICT' }, 'written over only while the latest is what was read')
+  assert.deepEqual(session.read().conflict, { latest: third })
+  session.overwriteConflict()
+  await session.save()
+  assert.equal(JSON.parse(s.row()).name, 'Mine')
+  assert.equal(session.read().conflict, undefined)
+  assert.equal(session.read().dirty, false)
+})
+
+test('a conflict kept as a copy: a new figure under a new creation id, the edits with it, the other figure untouched', async () => {
+  const s = server()
+  const saved: { id?: string; creationId?: string; type?: string }[] = []
+  const rowWrites: [string, object][] = []
+  const store = {
+    ...s.store,
+    save: async (q: { id?: string; source: string; expectedSource?: string; creationId?: string; type?: string }) => (saved.push(q), q.id ? s.store.save(q) : { id: q.creationId!, source: q.source }),
+    updateCatalog: async (id: string, patch: object) => (rowWrites.push([id, patch]), {})
+  }
+  const session = createFigureProductSession(store)
+  await session.open('a')
+  const opened = session.read().creationId
+  assert.throws(() => session.detachAsCopy(), { code: 'SESSION_NO_CONFLICT' }, 'only after a conflict')
+  session.command({ kind: 'rename', name: 'Mine' } as never)
+  session.editCatalog({ category: 'equipment', tags: ['new-tag'], type: 'gate-2' }, { type: 'gate' })
+  const theirs = serializeFigureAsset(createFigureAsset('Theirs'))
+  s.setRow(theirs)
+  await assert.rejects(session.save(), { code: 'FIGURE_SOURCE_CONFLICT' })
+  const copy = session.detachAsCopy()
+  assert.deepEqual(copy.catalog, { category: 'equipment', tags: ['new-tag'] }, 'the category and tags go with the copy; its type is asked anew')
+  assert.equal(copy.id, undefined)
+  assert.notEqual(copy.creationId, opened)
+  assert.equal(copy.conflict, undefined)
+  assert.equal(copy.name, 'Mine')
+  await session.save({ type: 'gate-copy' })
+  assert.deepEqual(saved.at(-1), { ...saved.at(-1), id: undefined, creationId: copy.creationId, type: 'gate-copy', expectedSource: undefined })
+  assert.equal(session.read().id, copy.creationId)
+  assert.deepEqual(rowWrites, [[copy.creationId, { category: 'equipment', tags: ['new-tag'] }]], 'written to the copy once it has a row')
+  assert.equal(session.read().dirty, false)
+  assert.equal(s.row(), theirs, 'the figure it came from is as the server had it')
+})
+
+test('the latest not readable: the conflict stands, and it cannot be written over blind', async () => {
+  const s = server()
+  const session = createFigureProductSession(s.store)
+  await session.open('a')
+  session.command({ kind: 'rename', name: 'Mine' } as never)
+  s.setRow(serializeFigureAsset(createFigureAsset('Theirs')))
+  s.state.loadFails = true
+  await assert.rejects(session.save(), { code: 'FIGURE_SOURCE_CONFLICT' })
+  assert.deepEqual(session.read().conflict, { latest: undefined })
+  assert.throws(() => session.overwriteConflict(), { code: 'SESSION_NO_CONFLICT' })
+})

package/translations/en.json

@@ -1294,5 +1294,16 @@
   "figure.text.data-capability-fields": "Data {name} reads itself: {fields}.",
   "figure.label.data-binding-resting": "resting",
   "figure.text.data-binding-rests": "In {where} the {name} capability does this instead.",
-  "figure.text.data-binding-rests-targets": "In {where} the {name} capability does this instead for: {targets}"
+  "figure.text.data-binding-rests-targets": "In {where} the {name} capability does this instead for: {targets}",
+  "figure.title.save-conflict": "save conflict",
+  "figure.text.save-conflict-desc": "This figure was saved elsewhere first. Your edits are still here on this screen.",
+  "figure.label.conflict-changed": "parts that differ",
+  "figure.label.conflict-mine-only": "parts only in your edits",
+  "figure.label.conflict-theirs-only": "parts only in the latest",
+  "figure.text.conflict-other-changed": "Settings outside the parts (name, inputs, capabilities...) differ too.",
+  "figure.text.conflict-latest-unread": "The latest could not be read, so it was not compared. It cannot be overwritten.",
+  "figure.button.save-as-copy": "save as a copy",
+  "figure.button.open-latest": "open the latest in a new tab",
+  "figure.button.overwrite-latest": "overwrite with my edits",
+  "figure.text.overwrite-latest-warning": "What changed in the latest is replaced by your edits and not kept. Overwrite?"
 }

package/translations/es.json

@@ -1294,5 +1294,16 @@
   "figure.text.data-capability-fields": "Datos que {name} lee por sí misma: {fields}.",
   "figure.label.data-binding-resting": "en pausa",
   "figure.text.data-binding-rests": "En {where} la capacidad {name} se encarga en su lugar.",
-  "figure.text.data-binding-rests-targets": "En {where} la capacidad {name} se encarga en su lugar de: {targets}"
+  "figure.text.data-binding-rests-targets": "En {where} la capacidad {name} se encarga en su lugar de: {targets}",
+  "figure.title.save-conflict": "conflicto al guardar",
+  "figure.text.save-conflict-desc": "Esta figura se guardó antes en otro lugar. Tus ediciones siguen en esta pantalla.",
+  "figure.label.conflict-changed": "partes distintas",
+  "figure.label.conflict-mine-only": "partes solo en tus ediciones",
+  "figure.label.conflict-theirs-only": "partes solo en la última versión",
+  "figure.text.conflict-other-changed": "También difieren ajustes fuera de las partes (nombre, entradas, capacidades...).",
+  "figure.text.conflict-latest-unread": "No se pudo leer la última versión, así que no se comparó. No se puede sobrescribir.",
+  "figure.button.save-as-copy": "guardar como copia",
+  "figure.button.open-latest": "abrir la última versión en una pestaña nueva",
+  "figure.button.overwrite-latest": "sobrescribir con mis ediciones",
+  "figure.text.overwrite-latest-warning": "Lo que cambió en la última versión se reemplaza por tus ediciones y no se conserva. ¿Sobrescribir?"
 }

package/translations/ja.json

@@ -1294,5 +1294,16 @@
   "figure.text.data-capability-fields": "{name} 能力が読むデータ: {fields}。",
   "figure.label.data-binding-resting": "休止",
   "figure.text.data-binding-rests": "{where} では {name} 能力が代わりに受け持ちます。",
-  "figure.text.data-binding-rests-targets": "{where} では {name} 能力が代わりに受け持ちます: {targets}"
+  "figure.text.data-binding-rests-targets": "{where} では {name} 能力が代わりに受け持ちます: {targets}",
+  "figure.title.save-conflict": "保存の競合",
+  "figure.text.save-conflict-desc": "別の場所でこの Figure が先に保存されました。編集内容はこの画面にそのまま残っています。",
+  "figure.label.conflict-changed": "異なる部品",
+  "figure.label.conflict-mine-only": "自分の編集にだけある部品",
+  "figure.label.conflict-theirs-only": "最新版にだけある部品",
+  "figure.text.conflict-other-changed": "部品以外の設定（名前・入力・能力など）も異なります。",
+  "figure.text.conflict-latest-unread": "最新版を読み込めなかったため比較できませんでした。上書きはできません。",
+  "figure.button.save-as-copy": "コピーとして保存",
+  "figure.button.open-latest": "最新版を新しいタブで開く",
+  "figure.button.overwrite-latest": "自分の編集で上書き",
+  "figure.text.overwrite-latest-warning": "最新版で変更された内容は自分の編集に置き換えられ、残りません。上書きしますか？"
 }

package/translations/ko.json

@@ -1294,5 +1294,16 @@
   "figure.text.data-capability-fields": "{name} 능력이 읽는 데이터: {fields}.",
   "figure.label.data-binding-resting": "쉼",
   "figure.text.data-binding-rests": "{where}에서는 {name} 능력이 대신합니다.",
-  "figure.text.data-binding-rests-targets": "{where}에서는 {name} 능력이 대신합니다: {targets}"
+  "figure.text.data-binding-rests-targets": "{where}에서는 {name} 능력이 대신합니다: {targets}",
+  "figure.title.save-conflict": "저장 충돌",
+  "figure.text.save-conflict-desc": "다른 곳에서 이 피규어를 먼저 저장했습니다. 내 편집은 이 화면에 그대로 있습니다.",
+  "figure.label.conflict-changed": "달라진 부품",
+  "figure.label.conflict-mine-only": "내 편집에만 있는 부품",
+  "figure.label.conflict-theirs-only": "최신본에만 있는 부품",
+  "figure.text.conflict-other-changed": "부품 밖의 설정(이름·입력·능력 등)도 다릅니다.",
+  "figure.text.conflict-latest-unread": "최신본을 읽지 못해 비교하지 못했습니다. 덮어쓰기는 할 수 없습니다.",
+  "figure.button.save-as-copy": "사본으로 저장",
+  "figure.button.open-latest": "최신본을 새 탭에서 열기",
+  "figure.button.overwrite-latest": "내 편집으로 덮어쓰기",
+  "figure.text.overwrite-latest-warning": "최신본에서 바뀐 내용은 내 편집으로 바뀌고 남지 않습니다. 덮어쓸까요?"
 }

package/translations/ms.json

@@ -1294,5 +1294,16 @@
   "figure.text.data-capability-fields": "Data yang {name} baca sendiri: {fields}.",
   "figure.label.data-binding-resting": "rehat",
   "figure.text.data-binding-rests": "Dalam {where} keupayaan {name} mengambil alih.",
-  "figure.text.data-binding-rests-targets": "Dalam {where} keupayaan {name} mengambil alih: {targets}"
+  "figure.text.data-binding-rests-targets": "Dalam {where} keupayaan {name} mengambil alih: {targets}",
+  "figure.title.save-conflict": "konflik simpanan",
+  "figure.text.save-conflict-desc": "Figura ini telah disimpan di tempat lain dahulu. Suntingan anda masih ada pada skrin ini.",
+  "figure.label.conflict-changed": "bahagian yang berbeza",
+  "figure.label.conflict-mine-only": "bahagian hanya dalam suntingan anda",
+  "figure.label.conflict-theirs-only": "bahagian hanya dalam versi terkini",
+  "figure.text.conflict-other-changed": "Tetapan di luar bahagian (nama, input, keupayaan...) juga berbeza.",
+  "figure.text.conflict-latest-unread": "Versi terkini tidak dapat dibaca, jadi tidak dibandingkan. Ia tidak boleh ditulis ganti.",
+  "figure.button.save-as-copy": "simpan sebagai salinan",
+  "figure.button.open-latest": "buka versi terkini dalam tab baharu",
+  "figure.button.overwrite-latest": "tulis ganti dengan suntingan saya",
+  "figure.text.overwrite-latest-warning": "Perubahan dalam versi terkini akan diganti oleh suntingan anda dan tidak disimpan. Tulis ganti?"
 }

package/translations/zh.json

@@ -1294,5 +1294,16 @@
   "figure.text.data-capability-fields": "{name} 能力自己读取的数据：{fields}。",
   "figure.label.data-binding-resting": "暂停",
   "figure.text.data-binding-rests": "在 {where} 中由 {name} 能力代为处理。",
-  "figure.text.data-binding-rests-targets": "在 {where} 中由 {name} 能力代为处理：{targets}"
+  "figure.text.data-binding-rests-targets": "在 {where} 中由 {name} 能力代为处理：{targets}",
+  "figure.title.save-conflict": "保存冲突",
+  "figure.text.save-conflict-desc": "此 Figure 已在别处先行保存。你的编辑仍保留在此画面中。",
+  "figure.label.conflict-changed": "不同的部件",
+  "figure.label.conflict-mine-only": "仅在你的编辑中的部件",
+  "figure.label.conflict-theirs-only": "仅在最新版本中的部件",
+  "figure.text.conflict-other-changed": "部件以外的设置（名称、输入、能力等）也不同。",
+  "figure.text.conflict-latest-unread": "无法读取最新版本，因此未能比较。无法覆盖。",
+  "figure.button.save-as-copy": "另存为副本",
+  "figure.button.open-latest": "在新标签页中打开最新版本",
+  "figure.button.overwrite-latest": "用我的编辑覆盖",
+  "figure.text.overwrite-latest-warning": "最新版本中的更改将被你的编辑替换且不会保留。要覆盖吗？"
 }