@things-factory/figure-ui 10.1.243 → 10.1.244

package/client/modeller/editor.ts

@@ -8,7 +8,7 @@ import { openPopup } from '@operato/layout'
 import { OxPrompt } from '@operato/popup'
 import { customElement, property, state } from 'lit/decorators.js'
 import { live } from 'lit/directives/live.js'
-import { figureFastenAxesOf, figurePartFaceOf, PART_LIMIT, parseFigureRecipe, resolveFigureRecipe, figurePartCountOf, figurePartIdFor, figureRecipeIdFor, figureSizeEditOf, figureSizeEditorOf, figureSectionMeasuresOf, figurePlaneAlignChanges, type FigurePlaneContact, figureRowOf, type FigureRowReading, figureFaceOverhangOf, type FigureFaceOverhang } from '@hatiolab/figure-model'
+import { parseFigureAsset, figureFastenAxesOf, figurePartFaceOf, PART_LIMIT, parseFigureRecipe, resolveFigureRecipe, figurePartCountOf, figurePartIdFor, figureRecipeIdFor, figureSizeEditOf, figureSizeEditorOf, figureSectionMeasuresOf, figurePlaneAlignChanges, type FigurePlaneContact, figureRowOf, type FigureRowReading, figureFaceOverhangOf, type FigureFaceOverhang } from '@hatiolab/figure-model'
 import type { RecipeTemplate } from './recipes.js'
 import './figure-recipe-catalog.js'
 import type { FigureAsset, FigureAuthoringAction, FigureEvaluatedShape, FigureInputChange, FigurePartEdit, FigurePrimitiveCreation, FigureProposalStep, FigureRecipe, FigureRecipeValue, FigurePlacement, FigureFaceMappingNeed, FigureFaceRemap } from '@hatiolab/figure-model'
@@ -29,6 +29,9 @@ import './figure-controls.js'
 import './figure-clips.js'
 import './figure-data-panel.js'
 import type { FigurePreview } from './figure-preview.js'
+import './figure-save-conflict.js'
+import type { SaveConflictChoice } from './figure-save-conflict.js'
+import { saveConflictChangesOf, type SaveConflictChanges } from './save-conflict.js'
 import './figure-preview.js'
 import './figure-settings.js'
 import { DEFAULT_VIEW, type ViewSettings } from '@things-factory/figure-viewer/dist-client/figure-view.js'
@@ -479,12 +482,54 @@ export class FigureEditor extends LitElement {
       await promise
       this.error = ''
     } catch (error) {
+      /* Another editor saved first: the ways on are asked, not a refusal said that saving again would only repeat. */
+      if (this.session.read().conflict) void this.resolveConflict()
       /* Not reached: whether it was written is not known, and the edits are still here -- said so, not "not saved". */
-      this.error = (error as { code?: string })?.code === 'SAVE_UNREACHABLE' ? i18next.t('figure.text.save-unreachable') : this.said(error)
+      else this.error = (error as { code?: string })?.code === 'SAVE_UNREACHABLE' ? i18next.t('figure.text.save-unreachable') : this.said(error)
     } finally {
       this.changed()
     }
   }
+  /**
+   * After a conflict (2026-11-01 audit item 6): what differs from the server's latest, and the way on the person
+   * chooses. A copy is a new figure saved by the first save's question; the latest opens in a new tab at this figure's
+   * address, the edits staying here; writing over is asked once more, since the other's change is lost.
+   */
+  private async resolveConflict() {
+    const session = this.session!
+    const latest = session.read().conflict?.latest
+    const mine = session.revisionNow()?.asset
+    let changes: SaveConflictChanges | null = null
+    try {
+      changes = latest && mine ? saveConflictChangesOf(mine, parseFigureAsset(latest)) : null
+    } catch {
+      /* A latest this figure-model cannot read is not compared; it is still offered to keep a copy or to look at it. */
+    }
+    const choice = await openPopup(html`<figure-save-conflict .changes=${changes}></figure-save-conflict>`, {
+      backdrop: true,
+      size: 'small',
+      title: i18next.t('figure.title.save-conflict')
+    }).result as SaveConflictChoice | undefined
+    if (this.session !== session || !session.read().conflict) return
+    if (choice === 'latest') window.open(location.href, '_blank', 'noopener')
+    else if (choice === 'copy') {
+      session.detachAsCopy()
+      /* The page forgets the row of the figure left: the copy's identifier is asked, not the other's offered. */
+      this.dispatchEvent(new CustomEvent('figure-detached', { bubbles: true, composed: true }))
+      this.changed()
+      await this.save()
+    } else if (choice === 'overwrite') {
+      const agreed = await OxPrompt.open({
+        type: 'warning',
+        text: i18next.t('figure.text.overwrite-latest-warning'),
+        confirmButton: { text: i18next.t('figure.button.overwrite-latest') },
+        cancelButton: { text: i18next.t('figure.button.keep-editing') }
+      })
+      if (!agreed || this.session !== session || !session.read().conflict) return
+      session.overwriteConflict()
+      await this.save()
+    }
+  }
   private add(kind: FigurePaletteKind) {
     if (!this.session) return
     this.run(() => {
@@ -1659,6 +1704,7 @@ export class FigureEditor extends LitElement {
       .kept=${kept}
       .pointBlocked=${this.pointBlockedOf(drawn)}
       .revision=${this.session?.read().revision ?? 0}
+      ?active=${this.active}
       .faceMapping=${this.faceMapping?.from === 'section-editor' ? this.faceMapping.need : undefined}
       @command=${(e: CustomEvent) => {
         /* Held for a choice of where things go: the editor stays open, the choice shown in it. */

package/client/modeller/figure-save-conflict.ts

@@ -0,0 +1,73 @@
+import { LitElement, html, css, nothing } from 'lit'
+import { customElement, property } from 'lit/decorators.js'
+import { i18next } from '@operato/i18n'
+import { closePopup } from '@operato/popup'
+import '@operato/popup/ox-popup-actions.js'
+import { CommonPopupStyles } from '@operato/styles'
+import '@material/web/button/filled-button.js'
+import '@material/web/button/outlined-button.js'
+import '@material/web/button/text-button.js'
+
+import { partLabelOf } from './fields.js'
+import type { SaveConflictChanges } from './save-conflict.js'
+
+/** What the person chose after a conflict; nothing when closed -- the edits stay, unsaved. */
+export type SaveConflictChoice = 'copy' | 'latest' | 'overwrite'
+
+/**
+ * A save refused because another editor saved this figure first (2026-11-01 audit item 6). The edits stay on screen;
+ * what differs from the server's latest is said by part, and the ways on are offered: keep the edits as a copy (first,
+ * since nothing is lost), look at the latest in a new tab, or write the edits over it.
+ */
+@customElement('figure-save-conflict')
+export class FigureSaveConflict extends LitElement {
+  static styles = [
+    CommonPopupStyles,
+    css`
+      :host {
+        overflow-y: auto;
+      }
+      ul {
+        margin: 0;
+        padding-inline-start: 18px;
+        font-size: var(--popup-font-size-small);
+      }
+      li span {
+        color: var(--md-sys-color-on-surface-variant);
+      }
+      div[ways] {
+        display: grid;
+        gap: 6px;
+      }
+    `
+  ]
+
+  /** What differs from the server's latest; null when the latest could not be read. */
+  @property({ attribute: false }) changes: SaveConflictChanges | null = null
+
+  render() {
+    const changes = this.changes
+    const line = (key: string, parts: string[]) =>
+      parts.length ? html`<li><span>${i18next.t(key)}</span> ${parts.map(partLabelOf).join(', ')}</li>` : nothing
+    return html`
+      <div class="what">${i18next.t('figure.text.save-conflict-desc')}</div>
+      ${changes
+        ? html`<ul differs>
+            ${line('figure.label.conflict-changed', changes.changed)} ${line('figure.label.conflict-mine-only', changes.mineOnly)}
+            ${line('figure.label.conflict-theirs-only', changes.theirsOnly)}
+            ${changes.otherChanged ? html`<li>${i18next.t('figure.text.conflict-other-changed')}</li>` : nothing}
+          </ul>`
+        : html`<div class="note">${i18next.t('figure.text.conflict-latest-unread')}</div>`}
+      <div ways>
+        <md-filled-button copy @click=${() => closePopup(this, 'copy')}>${i18next.t('figure.button.save-as-copy')}</md-filled-button>
+        <md-outlined-button latest @click=${() => closePopup(this, 'latest')}>${i18next.t('figure.button.open-latest')}</md-outlined-button>
+        ${changes
+          ? html`<md-text-button overwrite @click=${() => closePopup(this, 'overwrite')}>${i18next.t('figure.button.overwrite-latest')}</md-text-button>`
+          : nothing}
+      </div>
+      <ox-popup-actions>
+        <md-text-button slot="cancel" @click=${() => closePopup(this)}>${i18next.t('figure.button.keep-editing')}</md-text-button>
+      </ox-popup-actions>
+    `
+  }
+}

package/client/modeller/figure-section-editor.ts

@@ -273,6 +273,8 @@ export class FigureSectionEditor extends localize(i18next)(LitElement) {
   @property({ attribute: false }) pointBlocked = ''
   /** The figure's revision now; the editor remembers the one it opened at. */
   @property({ type: Number }) revision = 0
+  /** The page in front, as the modeller has it: a page left keeps this editor on the window, and its keys are not its (2026-11-01 audit item 1). */
+  @property({ type: Boolean }) active = true
   /** What stands on the faces the last apply takes away (ADR-0100 A8): asked here, where the edit was made. */
   @property({ attribute: false }) faceMapping?: FigureFaceMappingNeed
   /** Narrow: the outline or the solid behind. */
@@ -344,6 +346,7 @@ export class FigureSectionEditor extends localize(i18next)(LitElement) {
    * would take Esc as "select nothing" and Delete as "delete the part".
    */
   private keys = (e: KeyboardEvent) => {
+    if (!this.active) return
     const inField = (e.composedPath()[0] as HTMLElement)?.tagName === 'INPUT'
     /* A number being typed in the inside's drawing: Esc there puts the number back, not the editor away. */
     if (inField && e.composedPath().some(el => (el as HTMLElement).tagName === 'FIGURE-CAVITY-DRAWING')) return

package/client/modeller/product-session.ts

@@ -88,8 +88,21 @@ export function createFigureProductSession(store: FigureProductStore) {
   */
   let done: Array<string | undefined> = [],
     undone: Array<string | undefined> = []
+  /*
+    A save refused because the server holds another source than the one opened (FIGURE_SOURCE_CONFLICT, not one of
+    this session's own sends): the edits stay, and the server's latest is kept here to compare with and, if the person
+    says so, to write over (2026-11-01 audit item 6). Undefined source: the latest could not be read.
+  */
+  let conflict: { source?: string } | undefined
   /* The catalogue fields changed and not saved yet; none of the history -- undo is the figure's steps. */
   let catalog: FigureCatalogPatch = {}
+  /* The catalogue fields a save is writing now: what the row will hold, not what it held, until it is done. */
+  let catalogSending: FigureCatalogPatch | undefined
+  /*
+    The catalogue fields the last save wrote, known to be on the row from the moment it answered: a screen compares
+    with them before it has read the row again (2026-11-01 third re-check). Empty from the start of each save.
+  */
+  let catalogWritten: FigureCatalogPatch = {}
   const catalogHeld = () => Object.keys(catalog).length > 0
   /* The author's size ends the last step moved without being asked (ADR-0087 decision 6), told once. */
   let fitted: FigureSizeRangeFit[] = []
@@ -113,7 +126,7 @@ export function createFigureProductSession(store: FigureProductStore) {
   */
   function read() {
     const view = workspace.read()
-    return { ...view, dirty: view.dirty || catalogHeld(), catalog: { ...catalog }, id, creationId, loading, saving, error }
+    return { ...view, dirty: view.dirty || catalogHeld(), catalog: { ...catalog }, catalogWritten: { ...catalogWritten }, conflict: conflict ? { latest: conflict.source } : undefined, id, creationId, loading, saving, error }
   }
   /*
     The version on screen, one object for as long as it is the version: the workspace hands out one asset per version
@@ -166,6 +179,8 @@ export function createFigureProductSession(store: FigureProductStore) {
     saving = false
     creationId = undefined
     catalog = {}
+    catalogWritten = {}
+    conflict = undefined
     done = []
     undone = []
   }
@@ -184,19 +199,50 @@ export function createFigureProductSession(store: FigureProductStore) {
     confirmedSource: () => (id ? baseline : undefined),
     /**
      * A catalogue field changed, held for the next save; one changed back to what the row holds (`saved`) is no
-     * change. Only a saved figure has a row to write: a new figure's type goes with its first save.
+     * change. Only a saved figure has a row to write: a new figure's type goes with its first save. Taken while a save
+     * is on its way too: the field shows it, so it is held for the save after (2026-11-01 re-check). A field that save
+     * is writing is held whatever it is changed to -- back to the old value too, which the save is about to replace;
+     * the save done lets go only of a value it wrote (2026-11-01 second re-check).
      */
     editCatalog(patch: FigureCatalogPatch, saved: FigureCatalogPatch) {
       if (!id) throw refusal('SESSION_NOT_SAVED', '먼저 저장해 주세요.')
-      if (saving) throw refusal('SESSION_SAVING', '저장이 끝난 뒤 편집해 주세요.')
       const next = { ...catalog }
       for (const key of Object.keys(patch) as (keyof FigureCatalogPatch)[]) {
-        if (sameValue(patch[key], saved[key])) delete next[key]
+        if (!(catalogSending && key in catalogSending) && sameValue(patch[key], saved[key])) delete next[key]
         else (next as Record<string, unknown>)[key] = patch[key]
       }
       catalog = next
       return read()
     },
+    /**
+     * After a conflict, the edits written over the server's latest: the next save expects that latest, so it goes
+     * through only while the server still holds it -- a third change meanwhile is a conflict again.
+     */
+    overwriteConflict() {
+      if (saving) throw refusal('SESSION_SAVING', '저장이 끝난 뒤 편집해 주세요.')
+      if (!conflict?.source) throw refusal('SESSION_NO_CONFLICT', '덮어쓸 최신본을 읽지 못했습니다.')
+      baseline = conflict.source
+      conflict = undefined
+      unconfirmed.clear()
+      return read()
+    },
+    /**
+     * After a conflict, the edits kept as a figure of their own: from here they are a new figure, under a new creation
+     * id, saved by the first save's question; the figure they came from is left as the server holds it.
+     */
+    detachAsCopy() {
+      if (saving) throw refusal('SESSION_SAVING', '저장이 끝난 뒤 편집해 주세요.')
+      if (!conflict) throw refusal('SESSION_NO_CONFLICT', '충돌한 저장이 없습니다.')
+      id = undefined
+      baseline = undefined
+      creationId = crypto.randomUUID()
+      conflict = undefined
+      /* The category and tags changed go with the copy, written once its first save gives it a row; its type is asked anew. */
+      const { type: _type, ...kept } = catalog
+      catalog = kept
+      unconfirmed.clear()
+      return read()
+    },
     /** A new figure, named in the screen's language by the page: the session has no words of its own. */
     startNew({ discard = false, name }: { discard?: boolean; name: string }) {
       canLeave(discard)
@@ -338,6 +384,8 @@ export function createFigureProductSession(store: FigureProductStore) {
       const proposalKeys = inEffect()
       const sentCatalog = { ...catalog }
       saving = true
+      catalogSending = sentCatalog
+      catalogWritten = {}
       try {
         /* Only the catalogue changed: the source is not written again -- a released figure would be made a draft for nothing. */
         if (id === undefined || workspace.read().dirty) await saveSource()
@@ -345,11 +393,15 @@ export function createFigureProductSession(store: FigureProductStore) {
         if (id !== undefined && Object.keys(sentCatalog).length) {
           await store.updateCatalog(id, sentCatalog)
           if (requestEpoch !== epoch) return read()
-          /* Nothing could change it on the way: an edit waits for the save (editCatalog). */
-          catalog = {}
+          catalogWritten = sentCatalog
+          /* What was sent is saved; a field changed again while it was on its way stays held. */
+          const next = { ...catalog }
+          for (const key of Object.keys(sentCatalog) as (keyof FigureCatalogPatch)[]) if (sameValue(next[key], sentCatalog[key])) delete next[key]
+          catalog = next
         }
       } finally {
         if (requestEpoch === epoch) saving = false
+        catalogSending = undefined
       }
       return read()
 
@@ -392,6 +444,7 @@ export function createFigureProductSession(store: FigureProductStore) {
             record = await store.save({ id, source: exported.text, expectedSource: baseline, creationId, thumbnail, proposalKeys, ...(id || !type ? {} : { type }), ...(id || !namespace ? {} : { namespace }) })
           } else {
             if (code === 'SAVE_UNREACHABLE') unconfirmed.set(exported.text, { thumbnail })
+            if (code === 'FIGURE_SOURCE_CONFLICT' && requestEpoch === epoch) conflict = { source: landed?.source }
             throw error
           }
         }
@@ -403,6 +456,7 @@ export function createFigureProductSession(store: FigureProductStore) {
         id = record.id
         baseline = record.source
         unconfirmed.clear()
+        conflict = undefined
         /*
           Edited while it was saving: what was sent is saved, the edits since are not -- they stay, and the model stays
           unsaved (the workspace refuses a stale acknowledgement). Never marked saved, never wiped.

package/client/modeller/save-conflict.ts

@@ -0,0 +1,91 @@
+import type { FigureAsset } from '@hatiolab/figure-model'
+
+/*
+ * A save refused because the server holds another source than the one this editor opened (FIGURE_SOURCE_CONFLICT):
+ * what differs between the edits on screen and the server's latest, by part, so the person chooses with it in view --
+ * keep the edits as a copy, look at the latest, or write over it (2026-11-01 audit item 6). Read apart from the screen
+ * so the rule is tested without a browser.
+ */
+
+export interface SaveConflictChanges {
+  /** Parts on both sides, made differently. */
+  changed: string[]
+  /** Parts only the edits on screen have. */
+  mineOnly: string[]
+  /** Parts only the server's latest has. */
+  theirsOnly: string[]
+  /** Something not of one part differs too: the name, the figure's inputs, its capabilities, its clips... */
+  otherChanged: boolean
+}
+
+interface Node {
+  id: string
+  op: string
+}
+interface Model {
+  nodes: Node[]
+  constants?: { id: string }[]
+  inputs?: { id: string }[]
+}
+
+type Look = { target?: unknown }
+const looksOf = (asset: FigureAsset) => ((asset as unknown as { appearance?: Look[] }).appearance ?? [])
+
+/** Every node, constant and input by id, each with the values the figure gives it; a part's look under the part. */
+function itemsOf(asset: FigureAsset): Map<string, string> {
+  const model = asset.document.model as unknown as Model
+  const design = (asset.designInputs ?? {}) as Record<string, unknown>
+  const state = (asset.stateDefaults ?? {}) as Record<string, unknown>
+  const items = new Map<string, string>()
+  for (const node of model.nodes) items.set(node.id, JSON.stringify(['node', node]))
+  for (const constant of model.constants ?? []) items.set(constant.id, JSON.stringify(['constant', constant]))
+  for (const input of model.inputs ?? []) items.set(input.id, JSON.stringify(['input', input, design[input.id] ?? null, state[input.id] ?? null]))
+  const looks = new Map<string, Look[]>()
+  for (const look of looksOf(asset)) if (typeof look.target === 'string') looks.set(look.target, [...(looks.get(look.target) ?? []), look])
+  for (const [target, of] of looks) items.set(`${target}.appearance`, JSON.stringify(['look', of]))
+  return items
+}
+
+/**
+ * A part and all it is made of: figure-model names a part's nodes, constants and inputs under it (`lid.shape`,
+ * `lid.size.y`), and its arguments point at their outputs, not at node ids.
+ */
+function closureOf(asset: FigureAsset, part: string): Set<string> {
+  return new Set([...itemsOf(asset).keys()].filter(id => id === part || id.startsWith(part + '.')))
+}
+
+const partsOf = (asset: FigureAsset) => (asset.document.model as unknown as Model).nodes.filter(node => node.op === 'place@1').map(node => node.id)
+
+const madeOf = (items: Map<string, string>, ids: Set<string>) => JSON.stringify([...ids].sort().map(id => [id, items.get(id) ?? null]))
+
+/** Everything of an asset but its items: its name, palette, the look not of one part, capabilities, version. */
+function restOf(asset: FigureAsset): string {
+  const { document, designInputs: _design, stateDefaults: _state, appearance: _looks, ...rest } = asset as FigureAsset & Record<string, unknown>
+  const { model: _model, ...documentRest } = document as unknown as Record<string, unknown>
+  return JSON.stringify([rest, documentRest, looksOf(asset).filter(look => typeof look.target !== 'string')])
+}
+
+export function saveConflictChangesOf(mine: FigureAsset, theirs: FigureAsset): SaveConflictChanges {
+  const mineItems = itemsOf(mine),
+    theirItems = itemsOf(theirs)
+  const mineParts = partsOf(mine),
+    theirParts = partsOf(theirs)
+  const covered = new Set<string>()
+  const changed: string[] = []
+  for (const part of mineParts) {
+    const ours = closureOf(mine, part)
+    ours.forEach(id => covered.add(id))
+    if (!theirParts.includes(part)) continue
+    const their = closureOf(theirs, part)
+    their.forEach(id => covered.add(id))
+    if (madeOf(mineItems, ours) !== madeOf(theirItems, their)) changed.push(part)
+  }
+  for (const part of theirParts) if (!mineParts.includes(part)) closureOf(theirs, part).forEach(id => covered.add(id))
+  const outside = (items: Map<string, string>) => JSON.stringify([...items].filter(([id]) => !covered.has(id)).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)))
+  return {
+    changed,
+    mineOnly: mineParts.filter(part => !theirParts.includes(part)),
+    theirsOnly: theirParts.filter(part => !mineParts.includes(part)),
+    otherChanged: restOf(mine) !== restOf(theirs) || outside(mineItems) !== outside(theirItems)
+  }
+}

package/client/pages/figure-modeller-page.ts

@@ -147,9 +147,9 @@ export class FigureModellerPage extends PageView {
   @state() private releaseBlockers: FigureGateFinding[] = []
   @state() private budget?: FigureBudgetLine
   private wasDirty = false
-  /** The catalogue fields held at the last change, and the figure they were held for. */
-  private held: FigureCatalogPatch = {}
-  private heldFor?: string
+  private wasSaving = false
+  /** The row reading asked last: an answer to an earlier one, come back after, is not the row now. */
+  private rowReading = 0
   private titled?: string | null
   /** The figure the AI dock was last told about - another id is another conversation. */
   private assistantFor?: string
@@ -231,14 +231,21 @@ export class FigureModellerPage extends PageView {
       navigate(modellerPathOf({ id: view.id }), true)
     }
     /* 저장이 끝난 순간 행을 다시 읽는다 — 발행된 피규어를 고쳐 저장하면 서버가 초안으로 내린다. */
-    if (this.wasDirty && !view.dirty && !view.saving && view.id) {
-      /* The catalogue fields just saved stand in the row until it is read again: the old ones did not flash back. */
-      if (view.id === this.heldFor) this.row = { ...this.row, ...this.held }
+    /*
+      Read again after every save that ends, not only one that leaves nothing unsaved: a field changed while it was
+      being written is still held, and is compared with what the row holds now (2026-11-01 second re-check).
+    */
+    if (view.id && !view.saving && ((this.wasDirty && !view.dirty) || this.wasSaving)) {
+      /*
+        What the save wrote is the row's from the moment it answered: the next change is compared with it at once, not
+        with the row as it was until the reading comes back -- a value typed in between was let go, then written over
+        (2026-11-01 third re-check). The old ones do not flash back either.
+      */
+      if (this.wasSaving) this.row = { ...this.row, ...view.catalogWritten }
       this.readRow(view.id)
     }
     this.wasDirty = !!view.dirty
-    this.held = view.catalog
-    this.heldFor = view.id
+    this.wasSaving = !!view.saving
   }
   /*
     A released figure changed on the server -- its source saved, or its category or tags -- comes back a draft, and a
@@ -250,8 +257,10 @@ export class FigureModellerPage extends PageView {
     if (before === 'released' && after === 'draft') notify({ level: 'info', message: i18next.t('figure.text.released-now-draft') })
   }
   private async readRow(id: string) {
+    const reading = ++this.rowReading
     try {
       const figure = await fetchFigure(id)
+      if (reading !== this.rowReading) return
       if (this.session.read().id === id) this.toldDemoted(this.row.state, figure.state)
       if (this.session.read().id === id)
         this.row = {
@@ -333,6 +342,15 @@ export class FigureModellerPage extends PageView {
     const patch = (event as CustomEvent).detail as { category?: string; tags?: string[] }
     if (this.session.read().id && patch) this.editCatalog(patch)
   }
+  /*
+    The edits kept as a copy after a conflict: a new figure from here. The row and address of the figure left are let
+    go, so the first save asks a new identifier and the copy's address replaces this one once saved.
+  */
+  private detached = () => {
+    this.row = { version: 0 }
+    this.routeId = undefined
+    this.withdrawAssistant()
+  }
   private released = (event: Event) => {
     const figure = (event as CustomEvent).detail?.figure
     /* Keep the rest of the row: rebuilding it from these two dropped the type, and the locked type field went blank. */
@@ -515,7 +533,7 @@ export class FigureModellerPage extends PageView {
     const view = this.session.read()
     const shown = this.shownRow()
     /* A new figure's third way to start: the app's assistant dock, with a request put in its input for the author to finish and send (B, U04). */
-    return html`<figure-editor .session=${this.session} .releaseState=${this.row} .releaseBlockers=${this.releaseBlockers} .templates=${this.templates} .guideOf=${this.guideOf} .thumbnailOf=${this.thumbnailOf} .firstSave=${this.askFirstSave} .revision=${this.revision} .budget=${this.budget} ?active=${this.active} aiDraft @ask-ai-draft=${() => askAssistant({ draft: i18next.t('figure.text.ai-draft-request') })} @changed=${this.changed}>
+    return html`<figure-editor .session=${this.session} .releaseState=${this.row} .releaseBlockers=${this.releaseBlockers} .templates=${this.templates} .guideOf=${this.guideOf} .thumbnailOf=${this.thumbnailOf} .firstSave=${this.askFirstSave} .revision=${this.revision} .budget=${this.budget} ?active=${this.active} aiDraft @figure-detached=${this.detached} @ask-ai-draft=${() => askAssistant({ draft: i18next.t('figure.text.ai-draft-request') })} @changed=${this.changed}>
       ${this.commandError ? html`<p slot="notice" fit-error role="alert">${this.commandError}</p>` : ''}
       <figure-properties
         slot="figure"

package/dist-client/modeller/editor.d.ts

@@ -13,6 +13,7 @@ import './figure-fasten-dialog.js';
 import './figure-controls.js';
 import './figure-clips.js';
 import './figure-data-panel.js';
+import './figure-save-conflict.js';
 import './figure-preview.js';
 import './figure-settings.js';
 import './figure-capability-panel.js';
@@ -173,6 +174,12 @@ export declare class FigureEditor extends LitElement {
     private holdAction;
     private changed;
     private save;
+    /**
+     * After a conflict (2026-11-01 audit item 6): what differs from the server's latest, and the way on the person
+     * chooses. A copy is a new figure saved by the first save's question; the latest opens in a new tab at this figure's
+     * address, the edits staying here; writing over is asked once more, since the other's change is lost.
+     */
+    private resolveConflict;
     private add;
     /**
      * A GLB made into a mesh part (ADR-0129): the server reads and keeps it, the author picks the whole file or one node

package/dist-client/modeller/editor.js

@@ -6,9 +6,10 @@ import { isMacOS } from '@operato/utils';
 import { unitWord } from './unit-words.js';
 import '@operato/layout';
 import { openPopup } from '@operato/layout';
+import { OxPrompt } from '@operato/popup';
 import { customElement, property, state } from 'lit/decorators.js';
 import { live } from 'lit/directives/live.js';
-import { figureFastenAxesOf, figurePartFaceOf, PART_LIMIT, parseFigureRecipe, resolveFigureRecipe, figurePartCountOf, figurePartIdFor, figureRecipeIdFor, figureSizeEditOf, figureSizeEditorOf, figureSectionMeasuresOf, figurePlaneAlignChanges, figureRowOf, figureFaceOverhangOf } from '@hatiolab/figure-model';
+import { parseFigureAsset, figureFastenAxesOf, figurePartFaceOf, PART_LIMIT, parseFigureRecipe, resolveFigureRecipe, figurePartCountOf, figurePartIdFor, figureRecipeIdFor, figureSizeEditOf, figureSizeEditorOf, figureSectionMeasuresOf, figurePlaneAlignChanges, figureRowOf, figureFaceOverhangOf } from '@hatiolab/figure-model';
 import './figure-recipe-catalog.js';
 import { captureFigureThumbnail } from './thumbnail.js';
 import { drawableFigureParts } from './renderer.js';
@@ -25,6 +26,8 @@ import './figure-fasten-dialog.js';
 import './figure-controls.js';
 import './figure-clips.js';
 import './figure-data-panel.js';
+import './figure-save-conflict.js';
+import { saveConflictChangesOf } from './save-conflict.js';
 import './figure-preview.js';
 import './figure-settings.js';
 import { DEFAULT_VIEW } from '@things-factory/figure-viewer/dist-client/figure-view.js';
@@ -462,13 +465,62 @@ let FigureEditor = class FigureEditor extends LitElement {
             this.error = '';
         }
         catch (error) {
+            /* Another editor saved first: the ways on are asked, not a refusal said that saving again would only repeat. */
+            if (this.session.read().conflict)
+                void this.resolveConflict();
             /* Not reached: whether it was written is not known, and the edits are still here -- said so, not "not saved". */
-            this.error = error?.code === 'SAVE_UNREACHABLE' ? i18next.t('figure.text.save-unreachable') : this.said(error);
+            else
+                this.error = error?.code === 'SAVE_UNREACHABLE' ? i18next.t('figure.text.save-unreachable') : this.said(error);
         }
         finally {
             this.changed();
         }
     }
+    /**
+     * After a conflict (2026-11-01 audit item 6): what differs from the server's latest, and the way on the person
+     * chooses. A copy is a new figure saved by the first save's question; the latest opens in a new tab at this figure's
+     * address, the edits staying here; writing over is asked once more, since the other's change is lost.
+     */
+    async resolveConflict() {
+        const session = this.session;
+        const latest = session.read().conflict?.latest;
+        const mine = session.revisionNow()?.asset;
+        let changes = null;
+        try {
+            changes = latest && mine ? saveConflictChangesOf(mine, parseFigureAsset(latest)) : null;
+        }
+        catch {
+            /* A latest this figure-model cannot read is not compared; it is still offered to keep a copy or to look at it. */
+        }
+        const choice = await openPopup(html `<figure-save-conflict .changes=${changes}></figure-save-conflict>`, {
+            backdrop: true,
+            size: 'small',
+            title: i18next.t('figure.title.save-conflict')
+        }).result;
+        if (this.session !== session || !session.read().conflict)
+            return;
+        if (choice === 'latest')
+            window.open(location.href, '_blank', 'noopener');
+        else if (choice === 'copy') {
+            session.detachAsCopy();
+            /* The page forgets the row of the figure left: the copy's identifier is asked, not the other's offered. */
+            this.dispatchEvent(new CustomEvent('figure-detached', { bubbles: true, composed: true }));
+            this.changed();
+            await this.save();
+        }
+        else if (choice === 'overwrite') {
+            const agreed = await OxPrompt.open({
+                type: 'warning',
+                text: i18next.t('figure.text.overwrite-latest-warning'),
+                confirmButton: { text: i18next.t('figure.button.overwrite-latest') },
+                cancelButton: { text: i18next.t('figure.button.keep-editing') }
+            });
+            if (!agreed || this.session !== session || !session.read().conflict)
+                return;
+            session.overwriteConflict();
+            await this.save();
+        }
+    }
     add(kind) {
         if (!this.session)
             return;
@@ -1688,6 +1740,7 @@ let FigureEditor = class FigureEditor extends LitElement {
       .kept=${kept}
       .pointBlocked=${this.pointBlockedOf(drawn)}
       .revision=${this.session?.read().revision ?? 0}
+      ?active=${this.active}
       .faceMapping=${this.faceMapping?.from === 'section-editor' ? this.faceMapping.need : undefined}
       @command=${(e) => {
             /* Held for a choice of where things go: the editor stays open, the choice shown in it. */