fix(SyncProcess): Avoid recreating items that already have a mapping to an existing target tree item

Signed-off-by: Marcel Klehr <mklehr@gmx.net>

Author: marcelklehr

src/lib/strategies/Default.ts

@@ -947,6 +947,44 @@ export default class SyncProcess {
         return
       }
 
+      // The scan flagged this as a creation, but a surviving mapping may already point it at an item
+      // that still exists on the target. This happens when the common-ancestor cache was reset
+      // (account.init() wipes cache+mappings) or rolled back (an interrupted atomic sync persists
+      // cache+mappings while the server discards its working copy): the scan re-sees an
+      // already-synced item as "new". Re-creating it would duplicate it on the target and the later
+      // addMapping would evict the surviving mapping, orphaning one copy → a silent drop. Instead,
+      // reconcile the source subtree against the existing target item and only create genuinely-new
+      // descendants.
+      const mappedTargetId = Mappings.mapId(mappingsSnapshot, action.payload, targetLocation)
+      const existingTargetItem = (typeof mappedTargetId !== 'undefined' && mappedTargetId !== null)
+        ? targetTree.findItem(action.payload.type, mappedTargetId)
+        : null
+      // Only treat it as already-present if it is still genuinely mergeable. A URL change, for
+      // instance, keeps the local id (so the mapping survives) but is intentionally recreated
+      // rather than merged (Scanner refuses to merge bookmarks whose url changed) — that must fall
+      // through to a real CREATE, not be swallowed here.
+      if (existingTargetItem && action.payload.canMergeWith(existingTargetItem)) {
+        const subScanner = new Scanner(
+          this.mappings,
+          existingTargetItem, // target tree
+          action.payload, // source tree
+          (oldItem, newItem) => (
+            oldItem.type === newItem.type &&
+            oldItem.canMergeWith(newItem) &&
+            !Mappings.wouldEvictUnrelatedMapping(mappingsSnapshot, oldItem, newItem)
+          ),
+          this.hashSettings,
+          false,
+          true,
+          true,
+        )
+        const scanResult = await subScanner.run()
+        scanResult.CREATE.getActions().forEach(a =>
+          targetPlan.CREATE.commit({type: a.type, payload: a.payload})
+        )
+        return
+      }
+
       const concurrentRemoval = targetScanResult.REMOVE.getActions().find(targetRemoval =>
         // target removal removed this creation's target (via some chain)
         Diff.findChain(mappingsSnapshot, allCreateAndMoveActions, sourceTree, action.payload, targetRemoval, findChainCacheForCreations)