@glance-apps/sync 1.3.1 → 1.3.2

package/CHANGELOG.md

@@ -7,6 +7,21 @@ 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

package/package.json

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

package/src/merge.js

@@ -115,11 +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.  When the same chip id exists on both sides, the
+ * 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, time changes, or ownership stamps propagate across
- * devices.  Chips present in the deletedChipIds tombstone map are excluded from
- * the merged result.
+ * 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[])
@@ -147,17 +150,22 @@ export const mergeRoutineDefinitions = (localDefs, remoteDefs, deletedChipIds =
     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);
 
     const bucketMerged = [];
-    // Local chips in order; when a chip also exists remotely, take the newer one.
+    // Local chips in order; when a chip also exists remotely, take the winner.
     for (const chip of localChips) {
       if (isTombstoned(chip)) { localChanged = true; continue; }
       const r = remoteMap.get(String(chip.id));
-      if (r && !isTombstoned(r) && lm(r) > lm(chip)) {
-        bucketMerged.push(r); localChanged = true;          // remote edit wins
+      if (r && !isTombstoned(r) && overrides(r, chip)) {
+        bucketMerged.push(r); localChanged = true;          // remote version wins
       } else {
         bucketMerged.push(chip);
-        if (r && lm(chip) > lm(r)) remoteChanged = true;    // local edit is newer
+        if (r && overrides(chip, r)) remoteChanged = true;  // local version wins → push
       }
     }
     // Append remote-only chips (skip tombstoned)