@glance-apps/sync 1.3.0 → 1.3.2

package/CHANGELOG.md

@@ -7,6 +7,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.3.2] - 2026-06-14
+
+### Fixed
+
+- **`mergeRoutineDefinitions` chip collisions are now ownership-aware.** Routine
+  chips can be claimed by a user (stamping `ownerSyncId`), and claiming is a
+  one-way transition. Previously collisions were resolved purely by newer
+  `lastModified`, so an unclaimed copy of a chip could beat a claimed copy when
+  it carried an equal-or-newer timestamp — a claim made on one device would
+  never reach a device still holding the unclaimed copy. Resolution now prefers
+  the claimed side when exactly one side is claimed, regardless of
+  `lastModified`; when both sides share the same ownership status (both claimed
+  or both unclaimed), the newer `lastModified` still wins. Ordering and
+  tombstone behavior are unchanged.
+
+## [1.3.1] - 2026-06-14
+
+### Fixed
+
+- **`mergeRoutineDefinitions` now applies last-write-wins on chip id collisions.**
+  Previously, when the same chip id existed on both sides, the local chip was
+  kept verbatim and the remote one skipped — `lastModified` was only consulted
+  for tombstone resurrection. As a result, any edit to an existing routine chip
+  (rename, reorder, time change, or stamping `ownerSyncId`) failed to propagate
+  across devices. Colliding chips are now resolved by the newer `lastModified`,
+  matching the behavior of `mergeArrayById` / `mergeHabits`. Ordering and
+  tombstone behavior are preserved.
+
 ## [1.3.0] - 2026-06-14
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glance-apps/sync",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "license": "MIT",
   "type": "module",
   "main": "src/index.js",

package/src/merge.js

@@ -115,8 +115,14 @@ export const mergeArrayById = (localItems, remoteItems, deletedIds, syncHorizon
  *
  * Each side's bucket is an array of { id, name } chips.  The merge preserves
  * local ordering and appends any remote-only chips at the end — mirroring the
- * mergeArrayById strategy.  Chips present in the deletedChipIds tombstone map
- * are excluded from the merged result.
+ * mergeArrayById strategy.  When the same chip id exists on both sides, a
+ * claimed chip (one carrying an `ownerSyncId`) always beats an unclaimed copy —
+ * claiming is a one-way transition, so the unclaimed side is stale regardless of
+ * its `lastModified`.  When both sides share the same ownership status, the
+ * version with the newer `lastModified` wins (field-level last-write-wins), so
+ * edits like renames and time changes still propagate across devices.  Chips
+ * present in the deletedChipIds tombstone map are excluded from the merged
+ * result.
  *
  * @param {Object} localDefs  - Local routine definitions (bucket → chip[])
  * @param {Object} remoteDefs - Remote routine definitions (bucket → chip[])
@@ -141,40 +147,38 @@ export const mergeRoutineDefinitions = (localDefs, remoteDefs, deletedChipIds =
   for (const bucket of allBuckets) {
     const localChips = localDefs[bucket] || [];
     const remoteChips = remoteDefs[bucket] || [];
-    const localIds = new Set(localChips.map(c => String(c.id)));
     const remoteMap = new Map(remoteChips.map(c => [String(c.id), c]));
+    const localMap = new Map(localChips.map(c => [String(c.id), c]));
+    const lm = (c) => c?.lastModified ? new Date(c.lastModified).getTime() : 0;
+    const owned = (c) => !!c?.ownerSyncId;
+    // A claimed chip (has ownerSyncId) always overrides an unclaimed copy of the
+    // same id — claiming is one-way, so the unclaimed side is stale regardless of
+    // its lastModified. Same ownership status on both sides → newer wins.
+    const overrides = (x, y) => owned(x) !== owned(y) ? owned(x) : lm(x) > lm(y);
 
-    // Start with local chips in order, filtering out tombstoned chips
     const bucketMerged = [];
+    // Local chips in order; when a chip also exists remotely, take the winner.
     for (const chip of localChips) {
-      if (isTombstoned(chip)) {
-        localChanged = true; // chip removed locally
-        continue;
+      if (isTombstoned(chip)) { localChanged = true; continue; }
+      const r = remoteMap.get(String(chip.id));
+      if (r && !isTombstoned(r) && overrides(r, chip)) {
+        bucketMerged.push(r); localChanged = true;          // remote version wins
+      } else {
+        bucketMerged.push(chip);
+        if (r && overrides(chip, r)) remoteChanged = true;  // local version wins → push
       }
-      bucketMerged.push(chip);
     }
-
     // Append remote-only chips (skip tombstoned)
-    for (const remoteChip of remoteChips) {
-      const id = String(remoteChip.id);
-      if (localIds.has(id)) continue;
-      if (isTombstoned(remoteChip)) {
-        remoteChanged = true; // tell remote this was deleted
-        continue;
-      }
-      bucketMerged.push(remoteChip);
-      localChanged = true;
+    for (const r of remoteChips) {
+      if (localMap.has(String(r.id))) continue;
+      if (isTombstoned(r)) { remoteChanged = true; continue; }
+      bucketMerged.push(r); localChanged = true;
     }
-
-    // Check for local-only chips (remote needs them)
-    for (const localChip of localChips) {
-      const id = String(localChip.id);
-      if (isTombstoned(localChip)) continue; // don't flag deleted chips as needing push
-      if (!remoteMap.has(id)) {
-        remoteChanged = true;
-      }
+    // Local-only chips → remote needs them
+    for (const c of localChips) {
+      if (isTombstoned(c)) continue;
+      if (!remoteMap.has(String(c.id))) remoteChanged = true;
     }
-
     merged[bucket] = bucketMerged;
   }