fix: preserve divergent synchronized Drafts (Closes #853)

frontend/unfiled-captures.js

@@ -273,8 +273,61 @@ function createUnfiledCaptures({
     return imported.length;
   }
 
+  async function reconcileRemote(drafts, login) {
+    const ownerLogin = String(login || '').trim();
+    if (!ownerLogin || !Array.isArray(drafts)) return 0;
+    const existing = read();
+    const retained = existing.filter(item => item.ownerLogin !== ownerLogin);
+    const reconciled = [];
+    const stagedEvidence = new Map();
+    for (const remote of drafts) {
+      if (!remote || reconciled.length + retained.length >= maxItems) continue;
+      const evidence = Array.isArray(remote.evidence) ? remote.evidence : [];
+      if (evidence.length && !attachmentStore) {
+        throw new Error('The synchronized screenshots cannot be stored on this device.');
+      }
+      const item = {
+        id:String(remote.id || ''), ownerLogin, title:String(remote.title || ''), body:String(remote.body || ''),
+        savedAt:Number(remote.saved_at),
+        ...(Array.isArray(remote.blockers) && remote.blockers.length ? {
+          blockers:remote.blockers, blockerCount:remote.blockers.length,
+        } : {}),
+        ...(evidence.length ? {hasAttachment:true, attachmentCount:evidence.length} : {}),
+      };
+      if (!item.id || !item.title.trim() || !Number.isFinite(item.savedAt)) continue;
+      if (evidence.length) {
+        stagedEvidence.set(item.id, {attachments:evidence.map(entry => ({
+          filename:String(entry.filename), contentType:String(entry.content_type),
+          blob:decodeBytes(String(entry.data), String(entry.content_type)),
+          ...(entry.note ? {note:String(entry.note)} : {}),
+        }))});
+      }
+      reconciled.push(item);
+    }
+    const evidenceIds = new Set(reconciled.filter(item => item.hasAttachment).map(item => item.id));
+    const affectedIds = new Set(stagedEvidence.keys());
+    for (const item of existing) if (item.ownerLogin === ownerLogin && item.hasAttachment) affectedIds.add(item.id);
+    const previousEvidence = new Map();
+    for (const id of affectedIds) previousEvidence.set(id, await attachmentStore?.get(id));
+    try {
+      for (const [id, value] of stagedEvidence) await attachmentStore.put(id, value);
+      for (const item of existing) {
+        if (item.ownerLogin === ownerLogin && item.hasAttachment && !evidenceIds.has(item.id)) {
+          await attachmentStore?.delete(item.id);
+        }
+      }
+      write(reconciled.concat(retained));
+    } catch (error) {
+      for (const [id, value] of previousEvidence) {
+        await Promise.resolve(value ? attachmentStore?.put(id, value) : attachmentStore?.delete(id)).catch(() => {});
+      }
+      throw error;
+    }
+    return reconciled.length;
+  }
+
   return {list, capacity, save, replaceOldest, discard, resume, completeResume,
-    exportOwned, mergeRemote, currentLogin:getCurrentLogin,
+    exportOwned, mergeRemote, reconcileRemote, currentLogin:getCurrentLogin,
     subscribe:listener => (listeners.add(listener), () => listeners.delete(listener))};
 }
 

frontend/unfiled-draft-sync.js

@@ -5,7 +5,10 @@
 })(typeof globalThis !== 'undefined' ? globalThis : this, function () {
   function createUnfiledDraftSync(options, mountedFetch) {
     if (mountedFetch) return createUnfiledDraftSync.mount(options, mountedFetch);
-    const {captures, fetchJson, storage, getLogin = () => '', onState = () => {}} = options;
+    const {
+      captures, fetchJson, storage, getLogin = () => '', onState = () => {},
+      createConflictId = () => 'conflict-' + (globalThis.crypto?.randomUUID?.() || Date.now().toString(36)),
+    } = options;
     const key = 'stackchain.unfiled-draft-sync.v1';
     let inFlight = null;
     let rerun = false;
@@ -18,14 +21,15 @@
           all:all && typeof all === 'object' ? all : {},
           known:new Set(Array.isArray(state?.known) ? state.known : []),
           deleted:new Set(Array.isArray(state?.deleted) ? state.deleted : []),
+          base:state?.base && typeof state.base === 'object' ? state.base : {},
         };
       } catch (_error) {
-        return {all:{}, known:new Set(), deleted:new Set()};
+        return {all:{}, known:new Set(), deleted:new Set(), base:{}};
       }
     }
 
     function write(login, state) {
-      state.all[login] = {known:[...state.known], deleted:[...state.deleted]};
+      state.all[login] = {known:[...state.known], deleted:[...state.deleted], base:state.base};
       storage?.setItem(key, JSON.stringify(state.all));
     }
 
@@ -39,6 +43,33 @@
       return JSON.stringify(left) === JSON.stringify(right);
     }
 
+    async function fingerprint(draft) {
+      if (!draft) return null;
+      const text = JSON.stringify(draft);
+      if (globalThis.crypto?.subtle && globalThis.TextEncoder) {
+        const digest = await globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(text));
+        return [...new Uint8Array(digest)].map(byte => byte.toString(16).padStart(2, '0')).join('');
+      }
+      let first = 2166136261, second = 3335557771;
+      for (let index = 0; index < text.length; index += 1) {
+        first = Math.imul(first ^ text.charCodeAt(index), 16777619);
+        second = Math.imul(second ^ text.charCodeAt(index), 2246822519);
+      }
+      return text.length + ':' + (first >>> 0).toString(16) + (second >>> 0).toString(16);
+    }
+
+    async function reconcile(captures, drafts, owner) {
+      if (typeof captures.reconcileRemote === 'function') {
+        await captures.reconcileRemote(drafts, owner);
+        return;
+      }
+      const finalIds = new Set(drafts.map(item => item.id));
+      for (const item of await captures.exportOwned(owner)) {
+        if (!finalIds.has(item.id)) await captures.discard(item.id);
+      }
+      await captures.mergeRemote(drafts, owner);
+    }
+
     async function runSync(login) {
       const owner = String(login || '').trim();
       if (!owner) return false;
@@ -47,23 +78,39 @@
       try {
         const remote = await fetchJson('api/v1/unfiled-drafts');
         const remoteDrafts = Array.isArray(remote?.drafts) ? remote.drafts : [];
-        const remoteIds = new Set(remoteDrafts.map(item => item.id));
-        const before = await captures.exportOwned(owner);
-
-        for (const local of before) {
-          if (state.known.has(local.id) && !remoteIds.has(local.id) && !state.deleted.has(local.id)) {
-            await captures.discard(local.id);
-          }
-        }
-        await captures.mergeRemote(
-          remoteDrafts.filter(item => !state.deleted.has(item.id)), owner
-        );
         const local = await captures.exportOwned(owner);
         const merged = [];
-        const byId = new Map();
-        for (const item of remoteDrafts) if (!state.deleted.has(item.id)) byId.set(item.id, item);
-        for (const item of local) if (!state.deleted.has(item.id)) byId.set(item.id, item);
-        for (const item of byId.values()) merged.push(item);
+        const localById = new Map(local.map(item => [item.id, item]));
+        const remoteById = new Map(remoteDrafts.map(item => [item.id, item]));
+        const ids = new Set([...state.known, ...localById.keys(), ...remoteById.keys()]);
+        let preservedConflict = false;
+        const usedIds = new Set(ids);
+        for (const id of ids) {
+          const localDraft = state.deleted.has(id) ? null : localById.get(id);
+          const remoteDraft = remoteById.get(id);
+          const localHash = await fingerprint(localDraft);
+          const remoteHash = await fingerprint(remoteDraft);
+          const baseHash = state.base[id] || null;
+          const localChanged = localHash !== baseHash;
+          const remoteChanged = remoteHash !== baseHash;
+          if (localChanged && remoteChanged && localHash !== remoteHash) {
+            preservedConflict = true;
+            if (remoteDraft) merged.push(remoteDraft);
+            if (localDraft) {
+              let conflictId = String(createConflictId()).slice(0, 100);
+              for (let suffix = 2; usedIds.has(conflictId); suffix += 1) {
+                conflictId = (String(createConflictId()).slice(0, 95) + '-' + suffix).slice(0, 100);
+              }
+              usedIds.add(conflictId);
+              const suffix = ' (conflict copy)';
+              merged.push({...localDraft, id:conflictId,
+                title:(String(localDraft.title).slice(0, 255 - suffix.length) + suffix)});
+            }
+            continue;
+          }
+          const selected = localChanged ? localDraft : (remoteChanged ? remoteDraft : (localDraft || remoteDraft));
+          if (selected) merged.push(selected);
+        }
         merged.sort((left, right) => Number(right.saved_at) - Number(left.saved_at));
 
         let finalSnapshot = remote;
@@ -73,10 +120,15 @@
             body:JSON.stringify({revision:Number(remote.revision || 0), drafts:merged}),
           });
         }
+        await reconcile(captures, finalSnapshot.drafts || [], owner);
         state.known = new Set((finalSnapshot.drafts || []).map(item => item.id));
         state.deleted.clear();
+        state.base = {};
+        for (const item of finalSnapshot.drafts || []) state.base[item.id] = await fingerprint(item);
         write(owner, state);
-        publish('ready', 'Drafts synced across devices.');
+        publish(preservedConflict ? 'conflict-preserved' : 'ready', preservedConflict
+          ? 'Draft changed on two devices · both versions were saved.'
+          : 'Drafts synced across devices.');
         return true;
       } catch (error) {
         if (error?.status === 409) {