@abloatai/humans 0.64.1 → 0.64.3

package/dist/local/BaseSyncedStore.d.ts

@@ -249,10 +249,11 @@ export declare class BaseSyncedStore<TCollaboration extends EventMap<TCollaborat
     /**
      * Bring a scope into view and subscribe to its sync groups. With
      * `{ hydrate: true }`, also backfill the groups' current state into the pool
-     * once the subscription is active. The order matters: subscribing first
-     * guarantees no live delta is missed in the gap before the snapshot lands.
-     * Hydration is best-effort — a failed backfill never rejects `enterScope`,
-     * and the live delta stream keeps flowing regardless.
+     * after subscription reconciliation. Offline reconciliation may only record
+     * interest locally; it is not proof that the server is delivering changes.
+     * Hydration is best-effort: failure leaves the groups unmarked for retry and
+     * does not reject `enterScope`. Snapshot application uses version guards so
+     * older baseline rows cannot overwrite newer deltas already in the pool.
      */
     enterScope(scope: GroupScope, opts?: {
         hydrate?: boolean;

package/dist/local/BaseSyncedStore.js

@@ -167,28 +167,26 @@ export class BaseSyncedStore {
     sendCollaborationEvent(messageType, payload) {
         this.syncWebSocket.sendCollaborationEvent(messageType, payload);
     }
-    // ── Area-of-interest (dynamic read subscription) ─────────────────
+    // ── Group interest and loading ──────────────────────────────────
     //
-    // `enterScope`/`leaveScope` move the connection's read interest as the
-    // user navigates (open or close a record); `pinScope`/`unpinScope`
-    // express prominence (an active claim keeps a group subscribed). All four
-    // resolve the scope to sync-group strings through the same resolver the
-    // claim path uses (`resolveParticipantSyncGroups`), so read interest and
-    // write claims always agree on the string for a given entity. Before the
-    // connection opens they record interest without a wire send, and they
-    // never reject when the transport is offline (see
-    // {@link SubscriptionManager.reconcile}); the on-connect `resync` pushes
-    // whatever interest accumulated.
+    // Authority comes from the server-issued session. Enter/leave track what
+    // this connection wants to receive; pin/unpin keep an active scope subscribed.
+    // All resolve selectors through scopeToGroups. Hydration separately loads
+    // a scoped baseline into the local pool. Leaving interest does not revoke
+    // authority or selectively evict cached records.
+    // Offline interest is recorded locally and reconciled when the connection
+    // opens; recording interest is not confirmation of a server subscription.
     scopeToGroups(scope) {
         return resolveScopeGroups(scope, this.schema);
     }
     /**
      * Bring a scope into view and subscribe to its sync groups. With
      * `{ hydrate: true }`, also backfill the groups' current state into the pool
-     * once the subscription is active. The order matters: subscribing first
-     * guarantees no live delta is missed in the gap before the snapshot lands.
-     * Hydration is best-effort — a failed backfill never rejects `enterScope`,
-     * and the live delta stream keeps flowing regardless.
+     * after subscription reconciliation. Offline reconciliation may only record
+     * interest locally; it is not proof that the server is delivering changes.
+     * Hydration is best-effort: failure leaves the groups unmarked for retry and
+     * does not reject `enterScope`. Snapshot application uses version guards so
+     * older baseline rows cannot overwrite newer deltas already in the pool.
      */
     enterScope(scope, opts) {
         const groups = this.scopeToGroups(scope);

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

@@ -1,10 +1,13 @@
 /**
  * Handles the delta types that change which sync groups a session can see. A
- * sync group is a fan-out scope the server uses to decide which entities a
- * client receives. When a session's membership changes, these handlers update
+ * sync group connects shared state to authorized participant subscriptions.
+ * This module owns the client side of membership changes and local-state
+ * rebuilding; it neither grants server authority nor configures per-group loading.
+ * When a session's membership changes, these handlers update
  * the client's subscription list; when access is revoked, they clear cached
- * data and trigger a full re-bootstrap so revoked rows cannot linger on the
- * device.
+ * managed data and request re-bootstrap. Clients without automatic bootstrap
+ * rely on covering deltas or explicit reads instead. This cannot retract copies
+ * retained outside the managed cache.
  *
  * Every handler takes a {@link GroupChangeContext}, the narrow facade through
  * which it reaches the client's local storage and connection lifecycle hooks.

package/dist/local/sync/groupChange.js

@@ -1,10 +1,13 @@
 /**
  * Handles the delta types that change which sync groups a session can see. A
- * sync group is a fan-out scope the server uses to decide which entities a
- * client receives. When a session's membership changes, these handlers update
+ * sync group connects shared state to authorized participant subscriptions.
+ * This module owns the client side of membership changes and local-state
+ * rebuilding; it neither grants server authority nor configures per-group loading.
+ * When a session's membership changes, these handlers update
  * the client's subscription list; when access is revoked, they clear cached
- * data and trigger a full re-bootstrap so revoked rows cannot linger on the
- * device.
+ * managed data and request re-bootstrap. Clients without automatic bootstrap
+ * rely on covering deltas or explicit reads instead. This cannot retract copies
+ * retained outside the managed cache.
  *
  * Every handler takes a {@link GroupChangeContext}, the narrow facade through
  * which it reaches the client's local storage and connection lifecycle hooks.

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

@@ -1,6 +1,9 @@
 import type { ClaimTarget } from '@abloatai/transaction/types/streams';
 import type { Schema } from '@abloatai/transaction/schema/schema';
-/** A schema-shaped selector used to narrow connection groups and presence reads. */
+/**
+ * Selects group interest using model records or explicit group names. Resolving
+ * a selector names a requested scope; the server still checks authority.
+ */
 export type GroupScope = ClaimTarget | readonly ClaimTarget[] | string | readonly string[] | {
     readonly syncGroup: string;
 } | {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/humans",
-  "version": "0.64.1",
+  "version": "0.64.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,8 @@
     "directory": "packages/humans"
   },
   "dependencies": {
-    "@abloatai/transaction": "0.64.1",
+    "@abloatai/transaction": "0.64.3",
+    "events": "^3.3.0",
     "mobx": "^6.13.7",
     "uuid": "^11.1.0",
     "zod": "^4.4.3"

package/src/local/BaseSyncedStore.ts

@@ -379,18 +379,15 @@ export class BaseSyncedStore<
     this.syncWebSocket.sendCollaborationEvent(messageType, payload);
   }
 
-  // ── Area-of-interest (dynamic read subscription) ─────────────────
+  // ── Group interest and loading ──────────────────────────────────
   //
-  // `enterScope`/`leaveScope` move the connection's read interest as the
-  // user navigates (open or close a record); `pinScope`/`unpinScope`
-  // express prominence (an active claim keeps a group subscribed). All four
-  // resolve the scope to sync-group strings through the same resolver the
-  // claim path uses (`resolveParticipantSyncGroups`), so read interest and
-  // write claims always agree on the string for a given entity. Before the
-  // connection opens they record interest without a wire send, and they
-  // never reject when the transport is offline (see
-  // {@link SubscriptionManager.reconcile}); the on-connect `resync` pushes
-  // whatever interest accumulated.
+  // Authority comes from the server-issued session. Enter/leave track what
+  // this connection wants to receive; pin/unpin keep an active scope subscribed.
+  // All resolve selectors through scopeToGroups. Hydration separately loads
+  // a scoped baseline into the local pool. Leaving interest does not revoke
+  // authority or selectively evict cached records.
+  // Offline interest is recorded locally and reconciled when the connection
+  // opens; recording interest is not confirmation of a server subscription.
 
   private scopeToGroups(scope: GroupScope): string[] {
     return resolveScopeGroups(scope, this.schema);
@@ -399,10 +396,11 @@ export class BaseSyncedStore<
   /**
    * Bring a scope into view and subscribe to its sync groups. With
    * `{ hydrate: true }`, also backfill the groups' current state into the pool
-   * once the subscription is active. The order matters: subscribing first
-   * guarantees no live delta is missed in the gap before the snapshot lands.
-   * Hydration is best-effort — a failed backfill never rejects `enterScope`,
-   * and the live delta stream keeps flowing regardless.
+   * after subscription reconciliation. Offline reconciliation may only record
+   * interest locally; it is not proof that the server is delivering changes.
+   * Hydration is best-effort: failure leaves the groups unmarked for retry and
+   * does not reject `enterScope`. Snapshot application uses version guards so
+   * older baseline rows cannot overwrite newer deltas already in the pool.
    */
   enterScope(scope: GroupScope, opts?: { hydrate?: boolean }): Promise<void> {
     const groups = this.scopeToGroups(scope);

package/src/local/sync/groupChange.ts

@@ -1,10 +1,13 @@
 /**
  * Handles the delta types that change which sync groups a session can see. A
- * sync group is a fan-out scope the server uses to decide which entities a
- * client receives. When a session's membership changes, these handlers update
+ * sync group connects shared state to authorized participant subscriptions.
+ * This module owns the client side of membership changes and local-state
+ * rebuilding; it neither grants server authority nor configures per-group loading.
+ * When a session's membership changes, these handlers update
  * the client's subscription list; when access is revoked, they clear cached
- * data and trigger a full re-bootstrap so revoked rows cannot linger on the
- * device.
+ * managed data and request re-bootstrap. Clients without automatic bootstrap
+ * rely on covering deltas or explicit reads instead. This cannot retract copies
+ * retained outside the managed cache.
  *
  * Every handler takes a {@link GroupChangeContext}, the narrow facade through
  * which it reaches the client's local storage and connection lifecycle hooks.

package/src/local/sync/scopeGroups.ts

@@ -2,7 +2,10 @@ import type { ClaimTarget } from '@abloatai/transaction/types/streams';
 import type { Schema } from '@abloatai/transaction/schema/schema';
 import { scopeKindOf, type ModelDef } from '@abloatai/transaction/schema/model';
 
-/** A schema-shaped selector used to narrow connection groups and presence reads. */
+/**
+ * Selects group interest using model records or explicit group names. Resolving
+ * a selector names a requested scope; the server still checks authority.
+ */
 export type GroupScope =
   | ClaimTarget
   | readonly ClaimTarget[]