@abloatai/humans 0.66.1 → 0.66.3

package/dist/local/mutators/undoApply.d.ts

@@ -16,7 +16,9 @@
  * counterparts (`paired`), which carry the value each operation established: on
  * undo the forwards say what you set, and on redo the inverses say what undo
  * restored. For `update` and `updateMany` operations it drops any field whose
- * live value no longer matches that established value. The `create` and
+ * live value no longer matches that established value. Plain JSON objects are
+ * compared recursively, so independent nested changes can still be undone.
+ * Arrays and object/type replacements remain atomic. The `create` and
  * `delete` families are structural and always applied — undoing a create
  * removes the row you added, and undoing a delete restores it.
  *
@@ -30,7 +32,7 @@ import { deepEqual } from '@abloatai/transaction/utils/json';
  * How undo and redo treat a field that a collaborator changed after your
  * operation.
  *
- *   - `skip-stale` (the default): leave the field alone. Your change has
+ *   - `skip-stale` (the default): leave superseded fields/JSON leaves alone. Your change has
  *     already been superseded, so reverting it would overwrite the
  *     collaborator's value. This is what keeps undo scoped to your own edits.
  *   - `last-writer-wins`: apply the operation verbatim, so your undo overwrites

package/dist/local/mutators/undoApply.js

@@ -16,7 +16,9 @@
  * counterparts (`paired`), which carry the value each operation established: on
  * undo the forwards say what you set, and on redo the inverses say what undo
  * restored. For `update` and `updateMany` operations it drops any field whose
- * live value no longer matches that established value. The `create` and
+ * live value no longer matches that established value. Plain JSON objects are
+ * compared recursively, so independent nested changes can still be undone.
+ * Arrays and object/type replacements remain atomic. The `create` and
  * `delete` families are structural and always applied — undoing a create
  * removes the row you added, and undoing a delete restores it.
  *
@@ -56,10 +58,34 @@ function readCurrentField(store, id, field) {
     const json = model.toJSON?.();
     return json ? json[field] : undefined;
 }
+// Missing object properties differ from properties whose value is undefined.
+const MISSING = Symbol('missing undo property');
+const ownValue = (value, key) => Object.hasOwn(value, key) ? value[key] : MISSING;
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+/** Replay changed JSON leaves; arrays and replacements remain atomic. */
+function replayValue(value, established, current) {
+    if (deepEqual(value, established))
+        return current;
+    if (deepEqual(current, established))
+        return value;
+    if (isPlainObject(value) && isPlainObject(established) && isPlainObject(current)) {
+        const keys = new Set([...Object.keys(current), ...Object.keys(established), ...Object.keys(value)]);
+        // fromEntries keeps keys such as __proto__ as ordinary own properties.
+        return Object.fromEntries([...keys].flatMap(key => {
+            const next = replayValue(ownValue(value, key), ownValue(established, key), ownValue(current, key));
+            return next === MISSING ? [] : [[key, next]];
+        }));
+    }
+    return current;
+}
 /**
- * Keep only the fields whose live value still equals what this op established
- * (`established[field]`). Returns `null` if nothing survives (the whole op is a
- * no-op — every field was superseded by a collaborator).
+ * Replay only changes that still stand, retaining collaborators' JSON leaves.
+ * Returns `null` when no effective change survives.
  */
 function filterStalePatch(store, patch, established) {
     const out = { id: patch.id };
@@ -68,11 +94,10 @@ function filterStalePatch(store, patch, established) {
         if (field === 'id')
             continue;
         if (established && field in established) {
-            // Apply only if the field still holds the value we established, meaning no
-            // collaborator has overwritten it since. Otherwise skip it, so the
-            // collaborator's change is left intact.
-            if (deepEqual(readCurrentField(store, patch.id, field), established[field])) {
-                out[field] = patch[field];
+            const current = readCurrentField(store, patch.id, field);
+            const next = replayValue(patch[field], established[field], current);
+            if (!deepEqual(next, current)) {
+                out[field] = next;
                 kept++;
             }
         }

package/dist/local/sync/SubscriptionManager.d.ts

@@ -137,12 +137,12 @@ export declare class SubscriptionManager {
     /**
      * Re-asserts the full desired set against the transport, forgetting what was
      * previously confirmed. Call this after a reconnect: a fresh
-     * {@link SyncWebSocket} starts from the sync groups named in the connect-time
-     * URL, so the manager's diff baseline no longer reflects the new socket.
+     * {@link SyncWebSocket} starts from the groups confirmed during connection,
+     * so the manager's diff baseline no longer reflects the new socket.
      * Clearing that baseline makes the next reconcile push one
      * `update_subscription` frame that re-establishes the current interest —
      * including any warm or pinned groups that drifted while the connection was
-     * down. The connect-time URL already carries the last-acknowledged set, so
+     * down. The connection already carries the last-acknowledged set, so
      * this is a correction, not the primary mechanism.
      */
     resync(): Promise<void>;

package/dist/local/sync/SubscriptionManager.js

@@ -174,12 +174,12 @@ export class SubscriptionManager {
     /**
      * Re-asserts the full desired set against the transport, forgetting what was
      * previously confirmed. Call this after a reconnect: a fresh
-     * {@link SyncWebSocket} starts from the sync groups named in the connect-time
-     * URL, so the manager's diff baseline no longer reflects the new socket.
+     * {@link SyncWebSocket} starts from the groups confirmed during connection,
+     * so the manager's diff baseline no longer reflects the new socket.
      * Clearing that baseline makes the next reconcile push one
      * `update_subscription` frame that re-establishes the current interest —
      * including any warm or pinned groups that drifted while the connection was
-     * down. The connect-time URL already carries the last-acknowledged set, so
+     * down. The connection already carries the last-acknowledged set, so
      * this is a correction, not the primary mechanism.
      */
     resync() {

package/dist/local/sync/socketEventWiring.js

@@ -11,9 +11,9 @@ export function wireSocketEvents(deps) {
             deps.updateSyncStatus({ offlineSince: undefined });
         }
         // Re-assert read interest on every (re)connect. After a transient
-        // reconnect the socket re-sends its URL groups, but interest may have
-        // changed while offline; after a full reconnect the new socket's URL
-        // carries only base groups. `resync` re-pushes the current desired set
+        // reconnect the socket restores its last confirmed groups, but interest
+        // may have changed while offline; after a full reconnect the new socket
+        // starts with only base groups. `resync` re-pushes the current desired set
         // so the server-side index matches what the user is actually viewing.
         void deps.areaOfInterest.resync();
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/humans",
-  "version": "0.66.1",
+  "version": "0.66.3",
   "description": "The optional human-facing local-state package for Ablo: presence, live queries, and React bindings.",
   "license": "Apache-2.0",
   "type": "module",
@@ -85,7 +85,7 @@
     "directory": "packages/humans"
   },
   "dependencies": {
-    "@abloatai/transaction": "0.66.1",
+    "@abloatai/transaction": "0.66.3",
     "events": "^3.3.0",
     "mobx": "^6.13.7",
     "uuid": "^11.1.0",

package/src/local/mutators/undoApply.ts

@@ -16,7 +16,9 @@
  * counterparts (`paired`), which carry the value each operation established: on
  * undo the forwards say what you set, and on redo the inverses say what undo
  * restored. For `update` and `updateMany` operations it drops any field whose
- * live value no longer matches that established value. The `create` and
+ * live value no longer matches that established value. Plain JSON objects are
+ * compared recursively, so independent nested changes can still be undone.
+ * Arrays and object/type replacements remain atomic. The `create` and
  * `delete` families are structural and always applied — undoing a create
  * removes the row you added, and undoing a delete restores it.
  *
@@ -32,7 +34,7 @@ import { deepEqual } from '@abloatai/transaction/utils/json';
  * How undo and redo treat a field that a collaborator changed after your
  * operation.
  *
- *   - `skip-stale` (the default): leave the field alone. Your change has
+ *   - `skip-stale` (the default): leave superseded fields/JSON leaves alone. Your change has
  *     already been superseded, so reverting it would overwrite the
  *     collaborator's value. This is what keeps undo scoped to your own edits.
  *   - `last-writer-wins`: apply the operation verbatim, so your undo overwrites
@@ -75,10 +77,35 @@ function readCurrentField(store: SyncStoreContract, id: string, field: string):
 
 type Patch = { id: string } & Record<string, unknown>;
 
+// Missing object properties differ from properties whose value is undefined.
+const MISSING = Symbol('missing undo property');
+const ownValue = (value: Record<string, unknown>, key: string): unknown =>
+  Object.hasOwn(value, key) ? value[key] : MISSING;
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== 'object') return false;
+  const prototype: unknown = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+/** Replay changed JSON leaves; arrays and replacements remain atomic. */
+function replayValue(value: unknown, established: unknown, current: unknown): unknown {
+  if (deepEqual(value, established)) return current;
+  if (deepEqual(current, established)) return value;
+  if (isPlainObject(value) && isPlainObject(established) && isPlainObject(current)) {
+    const keys = new Set([...Object.keys(current), ...Object.keys(established), ...Object.keys(value)]);
+    // fromEntries keeps keys such as __proto__ as ordinary own properties.
+    return Object.fromEntries([...keys].flatMap(key => {
+      const next = replayValue(ownValue(value, key), ownValue(established, key), ownValue(current, key));
+      return next === MISSING ? [] : [[key, next]];
+    }));
+  }
+  return current;
+}
+
 /**
- * Keep only the fields whose live value still equals what this op established
- * (`established[field]`). Returns `null` if nothing survives (the whole op is a
- * no-op — every field was superseded by a collaborator).
+ * Replay only changes that still stand, retaining collaborators' JSON leaves.
+ * Returns `null` when no effective change survives.
  */
 function filterStalePatch(
   store: SyncStoreContract,
@@ -90,11 +117,10 @@ function filterStalePatch(
   for (const field of Object.keys(patch)) {
     if (field === 'id') continue;
     if (established && field in established) {
-      // Apply only if the field still holds the value we established, meaning no
-      // collaborator has overwritten it since. Otherwise skip it, so the
-      // collaborator's change is left intact.
-      if (deepEqual(readCurrentField(store, patch.id, field), established[field])) {
-        out[field] = patch[field];
+      const current = readCurrentField(store, patch.id, field);
+      const next = replayValue(patch[field], established[field], current);
+      if (!deepEqual(next, current)) {
+        out[field] = next;
         kept++;
       }
     } else {

package/src/local/sync/SubscriptionManager.ts

@@ -232,12 +232,12 @@ export class SubscriptionManager {
   /**
    * Re-asserts the full desired set against the transport, forgetting what was
    * previously confirmed. Call this after a reconnect: a fresh
-   * {@link SyncWebSocket} starts from the sync groups named in the connect-time
-   * URL, so the manager's diff baseline no longer reflects the new socket.
+   * {@link SyncWebSocket} starts from the groups confirmed during connection,
+   * so the manager's diff baseline no longer reflects the new socket.
    * Clearing that baseline makes the next reconcile push one
    * `update_subscription` frame that re-establishes the current interest —
    * including any warm or pinned groups that drifted while the connection was
-   * down. The connect-time URL already carries the last-acknowledged set, so
+   * down. The connection already carries the last-acknowledged set, so
    * this is a correction, not the primary mechanism.
    */
   resync(): Promise<void> {

package/src/local/sync/socketEventWiring.ts

@@ -49,9 +49,9 @@ export function wireSocketEvents<TCollaboration extends EventMap<TCollaboration>
         deps.updateSyncStatus({ offlineSince: undefined });
       }
       // Re-assert read interest on every (re)connect. After a transient
-      // reconnect the socket re-sends its URL groups, but interest may have
-      // changed while offline; after a full reconnect the new socket's URL
-      // carries only base groups. `resync` re-pushes the current desired set
+      // reconnect the socket restores its last confirmed groups, but interest
+      // may have changed while offline; after a full reconnect the new socket
+      // starts with only base groups. `resync` re-pushes the current desired set
       // so the server-side index matches what the user is actually viewing.
       void deps.areaOfInterest.resync();
     });