@abloatai/humans 0.61.0 → 0.62.0

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

@@ -5,10 +5,8 @@
  * everyone else's, and watch the wait queue when a claim is contended.
  *
  * The stream is built directly on the sync WebSocket and shares that one
- * connection. It learns about other participants' claims from the same
- * `presence_update` frames the {@link createPresenceStream} presence stream
- * consumes — the server piggybacks each participant's `activeClaims` on every
- * presence frame — and sends its own claims as `claim_begin` and
+ * connection. It learns about other sessions' claims from the normalized
+ * presence projection and sends its own claims as `claim_begin` and
  * `claim_abandon` frames.
  *
  * Wire frames:
@@ -16,12 +14,12 @@
  *       entityId, description, field?, estimatedMs? }`.
  *   • Outbound `claim_abandon` — release it: `{ claimId, entityType?,
  *       entityId? }`.
- *   • Inbound, via presence — `event.activeClaims`, each stamped with
- *       `declaredAt` and `expiresAt`.
+ *   • Inbound, via presence — authoritative `claim` activities.
  *   • Inbound `claim_rejected` — the server refused the claim, with conflict
  *       metadata.
  */
 import type { WsTransport } from '@abloatai/transaction/transport/websocket';
+import type { PresenceSession } from '@abloatai/transaction/presence';
 import type { ClaimOptions, Claim, ClaimStream, PresenceTarget } from '@abloatai/transaction/types/streams';
 import { type Logger } from '@abloatai/transaction/logger';
 /**
@@ -34,11 +32,13 @@ import { type Logger } from '@abloatai/transaction/logger';
  */
 export type ClaimTransport = Pick<WsTransport, 'subscribe' | 'isConnected' | 'send'>;
 export interface ClaimStreamConfig {
-    /** Identity used to filter our own active claims out of `others`. */
-    participantId: string;
     /** Where the coordination trace is logged. Defaults to silent. */
     logger?: Logger;
 }
+export interface ClaimPresenceSource {
+    readonly others: readonly PresenceSession[];
+    onChange(listener: () => void): () => void;
+}
 export interface AttachableClaimStream extends ClaimStream {
     /**
      * Mints the local handle and sends its `claim_begin` frame. The handle is a
@@ -54,16 +54,6 @@ export interface AttachableClaimStream extends ClaimStream {
      */
     claim(target: PresenceTarget, opts?: ClaimOptions, claimId?: string): Claim;
     attach(transport: ClaimTransport): void;
-    /**
-     * Seeds the participant identity once the host resolves it. The stream can
-     * be built before identity is known — a hosted client learns who it is
-     * from its credential's scope during connect — and until then the
-     * construction-time id (possibly empty) would let the participant's own
-     * claims into `others`. Idempotent; later frames filter on the new id.
-     */
-    setParticipant(participant: {
-        id: string;
-    }): void;
     dispose(): void;
 }
-export declare function createClaimStream(config: ClaimStreamConfig, transport?: ClaimTransport | null): AttachableClaimStream;
+export declare function createClaimStream(config: ClaimStreamConfig, transport?: ClaimTransport | null, presence?: ClaimPresenceSource | null): AttachableClaimStream;

package/dist/local/sync/createClaimStream.js

@@ -5,10 +5,8 @@
  * everyone else's, and watch the wait queue when a claim is contended.
  *
  * The stream is built directly on the sync WebSocket and shares that one
- * connection. It learns about other participants' claims from the same
- * `presence_update` frames the {@link createPresenceStream} presence stream
- * consumes — the server piggybacks each participant's `activeClaims` on every
- * presence frame — and sends its own claims as `claim_begin` and
+ * connection. It learns about other sessions' claims from the normalized
+ * presence projection and sends its own claims as `claim_begin` and
  * `claim_abandon` frames.
  *
  * Wire frames:
@@ -16,8 +14,7 @@
  *       entityId, description, field?, estimatedMs? }`.
  *   • Outbound `claim_abandon` — release it: `{ claimId, entityType?,
  *       entityId? }`.
- *   • Inbound, via presence — `event.activeClaims`, each stamped with
- *       `declaredAt` and `expiresAt`.
+ *   • Inbound, via presence — authoritative `claim` activities.
  *   • Inbound `claim_rejected` — the server refused the claim, with conflict
  *       metadata.
  */
@@ -40,10 +37,7 @@ function claimLabel(type, id, field) {
  * above a round trip, comfortably below the ttl/3 beat cadence.
  */
 const HEARTBEAT_ACK_TIMEOUT_MS = 10_000;
-export function createClaimStream(config, transport = null) {
-    // Mutable: the host seeds the resolved identity via `setParticipant` once
-    // it is known; the own-claim filter always reads the current value.
-    let participantId = config.participantId;
+export function createClaimStream(config, transport = null, presence = null) {
     const logger = config.logger ?? noopLogger;
     // ── State: others' open claims, keyed by claimId ───────────────
     const activeByClaimId = new Map();
@@ -113,48 +107,7 @@ export function createClaimStream(config, transport = null) {
         if (attached)
             return;
         attached = t;
-        // (1) Inbound presence frames carry every participant's full
-        //     active-claim set. Prune previous claims by holder, then
-        //     re-add from the frame — the frame is authoritative for that
-        //     participant's open claims at that moment.
-        unsubs.push(t.subscribe('presence_update', (event) => {
-            if (!event.userId)
-                return;
-            if (event.userId === participantId)
-                return;
-            let mutated = false;
-            if (event.kind === 'leave') {
-                for (const [id, claim] of activeByClaimId) {
-                    if (claim.heldBy === event.userId) {
-                        activeByClaimId.delete(id);
-                        mutated = true;
-                    }
-                }
-                if (mutated)
-                    notifyListeners();
-                return;
-            }
-            for (const [id, claim] of activeByClaimId) {
-                if (claim.heldBy === event.userId) {
-                    activeByClaimId.delete(id);
-                    mutated = true;
-                }
-            }
-            for (const claim of event.activeClaims ?? []) {
-                // Terminal-status entries (committed / expired / canceled) are
-                // one-shot "this claim ended" signals. The holder sweep above
-                // already removed the prior active entry; skipping the re-add
-                // drops it from `others`, which is what resolves a contender's
-                // `settled()`. Absent status means active (wire back-compat).
-                if (claim.status && claim.status !== 'active')
-                    continue;
-                observeForeignClaim(event.userId, claim, event.participantKind, event.isAgent);
-                mutated = true;
-            }
-            if (mutated)
-                notifyListeners();
-        }));
-        // (2) Server-side rejection frames.
+        // Server-side rejection frames.
         unsubs.push(t.subscribe('claim_rejected', (rejection) => {
             if (!rejection.claimId)
                 return;
@@ -290,6 +243,41 @@ export function createClaimStream(config, transport = null) {
     }
     if (transport)
         attach(transport);
+    const refreshPresenceClaims = () => {
+        if (presence === null)
+            return;
+        activeByClaimId.clear();
+        for (const session of presence.others) {
+            for (const activity of session.activities) {
+                if (activity.operation !== 'claim'
+                    || activity.source !== 'claim'
+                    || activity.target.id === undefined)
+                    continue;
+                const claimId = activity.id.startsWith('claim:')
+                    ? activity.id.slice('claim:'.length)
+                    : activity.id;
+                observeForeignClaim(session.participant.id, {
+                    claimId,
+                    entityType: activity.target.model,
+                    entityId: activity.target.id,
+                    ...(activity.target.field !== undefined
+                        ? { field: activity.target.field }
+                        : {}),
+                    ...(activity.target.fields !== undefined
+                        ? { fields: activity.target.fields }
+                        : {}),
+                    description: 'claim',
+                    declaredAt: Date.parse(activity.startedAt),
+                    expiresAt: Date.parse(activity.expiresAt),
+                }, session.participant.kind);
+            }
+        }
+        notifyListeners();
+    };
+    if (presence !== null) {
+        refreshPresenceClaims();
+        unsubs.push(presence.onChange(refreshPresenceClaims));
+    }
     // ── Outbound ────────────────────────────────────────────────────
     function sendBegin(claimId, claim) {
         if (!attached?.isConnected())
@@ -475,9 +463,6 @@ export function createClaimStream(config, transport = null) {
             }, () => claimsSnapshot);
         },
         attach,
-        setParticipant(participant) {
-            participantId = participant.id;
-        },
         dispose() {
             for (const off of unsubs)
                 off();

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

@@ -5,7 +5,7 @@ import type { InstanceCache } from '../InstanceCache.js';
 import type { ConnectionManager } from './ConnectionManager.js';
 import type { SubscriptionManager } from './SubscriptionManager.js';
 import type { SyncStatus } from '../storeContract.js';
-import type { BootstrapHint, BootstrapDataEvent, PresenceUpdate, SyncWebSocket, EventMap } from './SyncWebSocket.js';
+import type { BootstrapHint, BootstrapDataEvent, SyncWebSocket, EventMap } from './SyncWebSocket.js';
 import type { SyncDelta } from './SyncWebSocket.js';
 export interface SocketEventHost<TCollaboration extends EventMap<TCollaboration>> {
     syncWebSocket: SyncWebSocket<TCollaboration>;
@@ -23,7 +23,6 @@ export interface SocketEventHost<TCollaboration extends EventMap<TCollaboration>
     applyDeltaFrame(deltas: SyncDelta[]): void;
     handleBootstrapRequired(hint: BootstrapHint): void;
     handleBootstrapData(data: BootstrapDataEvent): void;
-    handlePresenceUpdate(data: PresenceUpdate): void;
     performCredentialRefresh(): Promise<'refreshed' | 'session_error' | 'network_error'>;
     handleTerminalSessionError(error: Error): void;
     nudgeReconnect(): void;

package/dist/local/sync/socketEventWiring.js

@@ -43,10 +43,6 @@ export function wireSocketEvents(deps) {
         const data = args[0];
         deps.handleBootstrapData(data);
     });
-    const onPresenceUpdate = deps.syncWebSocket.subscribe('presence_update', (...args) => {
-        const data = args[0];
-        deps.handlePresenceUpdate(data);
-    });
     // Error events
     const onError = deps.syncWebSocket.subscribe('error', (error) => {
         if (error.message === 'Network is offline' || error.message === 'WebSocket connection failed') {
@@ -126,5 +122,5 @@ export function wireSocketEvents(deps) {
         deps.runtime.logger.debug('[BaseSyncedStore] WebSocket reconnection gave up', { attempts });
         deps.updateSyncStatus({ state: 'reconnecting' });
     });
-    deps.disposers.push(onConnected, onDisconnected, onReconnecting, onDelta, onDeltaBatch, onBootstrapRequired, onBootstrapData, onPresenceUpdate, onError, onSessionError, onHandshakeFailed, onReconnectFailed, () => { deps.areaOfInterest.dispose(); });
+    deps.disposers.push(onConnected, onDisconnected, onReconnecting, onDelta, onDeltaBatch, onBootstrapRequired, onBootstrapData, onError, onSessionError, onHandshakeFailed, onReconnectFailed, () => { deps.areaOfInterest.dispose(); });
 }

package/dist/local/transactions/mutations/MutationQueue.d.ts

@@ -476,7 +476,7 @@ export declare class MutationQueue extends EventEmitter {
         awaitingDeltaCount: number;
         awaitingDeltaTransactions: {
             id: string;
-            type: "update" | "create" | "delete" | "archive" | "unarchive";
+            type: "create" | "update" | "delete" | "archive" | "unarchive";
             modelName: string;
             modelId: string;
             syncIdNeeded: number | undefined;
@@ -485,13 +485,13 @@ export declare class MutationQueue extends EventEmitter {
         }[];
         pendingTransactions: {
             id: string;
-            type: "update" | "create" | "delete" | "archive" | "unarchive";
+            type: "create" | "update" | "delete" | "archive" | "unarchive";
             modelName: string;
             modelId: string;
         }[];
         executingTransactions: {
             id: string;
-            type: "update" | "create" | "delete" | "archive" | "unarchive";
+            type: "create" | "update" | "delete" | "archive" | "unarchive";
             modelName: string;
             modelId: string;
         }[];

package/dist/local/transactions/mutations/replayValidation.d.ts

@@ -27,8 +27,8 @@ import type { RuntimeContext } from '../../RuntimeContext.js';
 export declare const persistedTransactionSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodEnum<{
-        update: "update";
         create: "create";
+        update: "update";
         delete: "delete";
         archive: "archive";
         unarchive: "unarchive";
@@ -95,8 +95,8 @@ export declare function deserializePersistedTransaction(row: unknown, runtime?:
 export declare const persistedMutationSchema: z.ZodObject<{
     mutationId: z.ZodOptional<z.ZodString>;
     type: z.ZodEnum<{
-        update: "update";
         create: "create";
+        update: "update";
         delete: "delete";
         archive: "archive";
     }>;
@@ -138,8 +138,8 @@ export declare const legacyPendingMutationRecordSchema: z.ZodObject<{
     type: z.ZodLiteral<"pending_mutation">;
     mutation: z.ZodObject<{
         type: z.ZodEnum<{
-            update: "update";
             create: "create";
+            update: "update";
             delete: "delete";
             archive: "archive";
         }>;
@@ -180,8 +180,8 @@ export declare const pendingMutationRecordSchema: z.ZodObject<{
     type: z.ZodLiteral<"pending_mutation">;
     mutation: z.ZodObject<{
         type: z.ZodEnum<{
-            update: "update";
             create: "create";
+            update: "update";
             delete: "delete";
             archive: "archive";
         }>;

package/dist/presence/index.d.ts

@@ -0,0 +1,15 @@
+import { type PresenceProjection, type PresenceProjectionEvents, type PresenceView } from '@abloatai/transaction/presence';
+/** Reactive-client presence backed by the client's existing live connection. */
+export interface ReactivePresence extends PresenceView {
+    forModel(model: string, recordId?: string): ReturnType<PresenceProjection['forModel']>;
+    onChange(listener: () => void): () => void;
+}
+/** Lifecycle hooks kept inside the humans composition boundary. */
+export interface AttachablePresence extends ReactivePresence {
+    attach(transport: PresenceProjectionEvents): void;
+    dispose(): void;
+}
+/** Framework bridge that does not consume a string key on the model namespace. */
+export declare function attachPresenceToClient(client: object, presence: ReactivePresence): void;
+export declare function presenceOfClient(client: object): ReactivePresence;
+export declare function createPresence(transport?: PresenceProjectionEvents | null): AttachablePresence;

package/dist/presence/index.js

@@ -0,0 +1,49 @@
+import { createPresenceProjection, } from '@abloatai/transaction/presence';
+const clientPresence = new WeakMap();
+/** Framework bridge that does not consume a string key on the model namespace. */
+export function attachPresenceToClient(client, presence) {
+    clientPresence.set(client, presence);
+}
+export function presenceOfClient(client) {
+    const presence = clientPresence.get(client);
+    if (presence === undefined)
+        throw new Error('presence is not attached to this client');
+    return presence;
+}
+export function createPresence(transport = null) {
+    let projection = null;
+    const listeners = new Set();
+    let unsubscribe = null;
+    const notify = () => {
+        for (const listener of listeners)
+            listener();
+    };
+    const attach = (events) => {
+        if (projection !== null)
+            return;
+        projection = createPresenceProjection(events);
+        unsubscribe = projection.subscribe(notify);
+        notify();
+    };
+    if (transport !== null)
+        attach(transport);
+    return {
+        get active() { return projection?.active ?? []; },
+        get others() { return projection?.others ?? []; },
+        onChange(listener) {
+            listeners.add(listener);
+            return () => { listeners.delete(listener); };
+        },
+        attach,
+        forModel(model, recordId) {
+            return projection?.forModel(model, recordId) ?? [];
+        },
+        dispose() {
+            unsubscribe?.();
+            unsubscribe = null;
+            projection?.dispose();
+            projection = null;
+            listeners.clear();
+        },
+    };
+}

package/dist/react/AbloProvider.d.ts

@@ -1,7 +1,7 @@
 import { type ReactNode } from 'react';
 import type { SchemaRecord } from '@abloatai/transaction/schema/schema';
 import type { AbloClient as Ablo } from '../client.js';
-import type { Peer } from '@abloatai/transaction/types/streams';
+import type { PresenceSession } from '@abloatai/transaction/presence';
 import type { GroupScope } from '../local/sync/scopeGroups.js';
 import { type SyncStoreContract } from './context.js';
 /**
@@ -109,7 +109,7 @@ export interface AbloProviderProps<R extends SchemaRecord = SchemaRecord> {
 export declare function AbloProvider<R extends SchemaRecord = SchemaRecord>(props: AbloProviderProps<R>): React.ReactElement;
 export type { GroupScope };
 /**
- * Read-only presence: the OTHER participants currently visible to this
+ * Read-only presence: the other sessions currently visible to this
  * connection, bridged to React. This is a pure reader of the engine's
  * already-flowing presence stream; it does not mutate connection groups.
  *
@@ -127,7 +127,7 @@ export type { GroupScope };
  * const alone = !peers.some((p) => p.participantKind === 'user');
  * ```
  */
-export declare function usePeers(scope?: GroupScope): readonly Peer[];
+export declare function usePeers(scope?: GroupScope): readonly PresenceSession[];
 /**
  * Returns the raw `SyncEngine` proxy. Typically you want the typed
  * hooks (`useQuery`, `useOne`, `useMutate`) — this is for rare cases

package/dist/react/AbloProvider.js

@@ -7,6 +7,7 @@ import { AbloInternalContext } from './internalContext.js';
 import { AbloValidationError } from '@abloatai/transaction/errors';
 import { useSyncStatus } from './useSyncStatus.js';
 import { DefaultFallback } from './DefaultFallback.js';
+import { presenceOfClient } from '../presence/index.js';
 // ── Implementation ───────────────────────────────────────────────────
 /**
  * Lightweight event emitter for provider-level errors. Lives on the
@@ -201,7 +202,7 @@ function BootstrapGate({ fallback, children, }) {
 }
 const EMPTY_PRESENCE = Object.freeze([]);
 /**
- * Read-only presence: the OTHER participants currently visible to this
+ * Read-only presence: the other sessions currently visible to this
  * connection, bridged to React. This is a pure reader of the engine's
  * already-flowing presence stream; it does not mutate connection groups.
  *
@@ -232,10 +233,10 @@ export function usePeers(scope) {
             setPeers(EMPTY_PRESENCE);
             return;
         }
-        const presence = engine.presence;
+        const presence = presenceOfClient(engine);
         const compute = () => groups.length === 0
             ? presence.others
-            : presence.others.filter((p) => p.syncGroups.some((g) => groups.includes(g)));
+            : presence.others.filter((session) => session.activities.some(({ target }) => target.id !== undefined && groups.includes(`${target.model.toLowerCase()}:${target.id}`)));
         // Plain useState + onChange — presence changes on connect/disconnect/activity
         // only (never on cursor traffic, a separate channel), so this fires
         // rarely; a frame of stale presence is harmless.

package/dist/surface.d.ts

@@ -19,7 +19,7 @@
  * tuple, so it is the one list of model-verb names a generated summary can
  * describe.
  */
-export declare const PUBLIC_MODEL_VERBS: readonly ["get", "read", "list", "listAll", "local", "create", "update", "delete", "claim", "onChange"];
+export declare const PUBLIC_MODEL_VERBS: readonly ["get", "read", "list", "listAll", "local", "presence", "create", "update", "delete", "claim", "onChange"];
 /**
  * The option keys accepted by `local.list` and `onChange`, matching the
  * keys of {@link LocalReadOptions}. Note that the lifecycle filter is named

package/dist/surface.js

@@ -26,6 +26,7 @@ export const PUBLIC_MODEL_VERBS = [
     'list',
     'listAll',
     'local',
+    'presence',
     'create',
     'update',
     'delete',

package/package.json

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

package/src/Ablo.ts

@@ -99,7 +99,7 @@ export type Ablo<S extends SchemaRecord> = AbloClient<S>;
  * const ablo = Ablo({ schema, session: { endpoint: '/api/ablo-session' } });
  * ```
  *
- * Server-side agents, workers, and services use `@abloatai/transaction`.
+ * Server-side agents, workers, and services use `@abloatai/ablo`.
  */
 export function Ablo<
   const S extends SchemaRecord,
@@ -117,7 +117,15 @@ export function Ablo<const S extends SchemaRecord>(
   //    resolver, the base URL, the logger, and this participant's identity —
   //    and fails on a misconfiguration before anything is constructed.
   const prelude = resolveClientPrelude(options);
-  const { internalOptions, authCredentials, logger, url, participantId, kind } = prelude;
+  const {
+    internalOptions,
+    authCredentials,
+    presenceSession,
+    logger,
+    url,
+    participantId,
+    kind,
+  } = prelude;
 
   // 2. The connection, built here in the composition root — before the plugin
   //    list resolves, so `PluginContext.transport` carries the instance a
@@ -134,6 +142,7 @@ export function Ablo<const S extends SchemaRecord>(
         baseUrl: url,
         kind,
         getAuthToken: authCredentials.getAuthToken,
+        presenceSession,
         collaborationEvents: [...(internalOptions.collaborationEvents ?? [])],
         syncGroups: [...(internalOptions.syncGroups ?? [])],
         deferConnect: true,
@@ -223,7 +232,7 @@ export function Ablo<const S extends SchemaRecord>(
 //
 // One default import, with types hung underneath via namespace dots:
 // `import { Ablo } from "@abloatai/humans"` gets the factory, its return type, and
-// every type a typical consumer references (`Ablo.Peer`,
+// every type a typical consumer references (`Ablo.PresenceSession`,
 // and so on) — all purely type-level, with zero runtime cost.
 //
 // The types still live in their canonical homes (`types/streams`, `principal`,
@@ -272,10 +281,10 @@ export namespace Ablo {
   export type Duration = _Streams.Duration;
 
   // ── Real-time multiplayer (flat — heterogeneous cluster) ──────────
-  export type PresenceStream = _Streams.PresenceStream;
+  export type Presence = import('./presence/index.js').ReactivePresence;
+  export type PresenceSession = import('@abloatai/transaction/presence').PresenceSession;
+  export type PresenceActivity = import('@abloatai/transaction/presence').PresenceActivity;
   export type ClaimStream = _Streams.ClaimStream;
-  export type Peer = _Streams.Peer;
-  export type Activity = _Streams.Activity;
   export type Claim = _Streams.Claim;
   export type ClaimRejection = _Streams.ClaimRejection;
   export type ClaimLost = _Streams.ClaimLost;

package/src/client.ts

@@ -18,7 +18,6 @@ import type {
   InferCreate,
   InferRow,
 } from '@abloatai/transaction/schema/schema';
-import type { PresenceStream } from '@abloatai/transaction/types/streams';
 import type { InstanceCache } from './local/InstanceCache.js';
 import type { SyncStoreContract } from './react/context.js';
 import type { SyncWebSocket, CoreSyncEventMap } from './local/sync/SyncWebSocket.js';
@@ -31,6 +30,7 @@ import type {
 import type { EffectiveAuthority } from '@abloatai/transaction/auth';
 import type { ReadDependency } from '@abloatai/transaction/coordination';
 import type { CapturedRow } from '@abloatai/transaction/transport/http';
+import type { ReactivePresence } from './presence/index.js';
 export type { LocalReadOptions } from './local/client/resourceTypes.js';
 
 /** The typed sync engine client — one property per model in the schema */
@@ -232,20 +232,15 @@ export type AbloClient<S extends SchemaRecord> = {
    */
   readonly syncStatus: SyncStatus;
 
-  /** The underlying schema */
-  readonly schema: Schema<S>;
-
   /**
-   * A real-time presence livestream — who else is connected on this engine's
-   * sync groups, what they're doing, and a write surface for announcing this
-   * user's own activity. It rides the engine's existing WebSocket; opening a
-   * participant for presence does not open a second socket. See
-   * {@link PresenceStream}.
-   *
-   * The reference is stable for the engine's lifetime — the underlying connection
-   * is rotated on `dispose()`, but this object stays the same.
+   * Session-owned live activity projected from this client's existing
+   * connection. Use `active` for every visible activity, `others` to exclude
+   * this session, and `forModel(model, id?)` for a model-native view.
    */
-  readonly presence: PresenceStream;
+  readonly presence: ReactivePresence;
+
+  /** The underlying schema */
+  readonly schema: Schema<S>;
 
   /**
    * @internal The supported coordination API is `ablo.<model>.claim`. This

package/src/humans.ts

@@ -7,7 +7,7 @@
  */
 import type { AbloPlugin, PluginContext, AppliedChange } from './plugin.js';
 import { AbloValidationError } from '@abloatai/transaction/errors';
-import { createPresenceStream, type AttachablePresenceStream } from './presenceStream.js';
+import { createPresence, type AttachablePresence } from './presence/index.js';
 import {
   buildStoreCluster,
   kStoreCluster,
@@ -16,7 +16,7 @@ import {
 } from './local/client/storeCluster.js';
 
 export interface HumansSurface {
-  readonly presence: AttachablePresenceStream;
+  readonly presence: AttachablePresence;
   readonly [kStoreCluster]?: StoreCluster;
 }
 
@@ -45,14 +45,7 @@ export function humans() {
         applyChanges = (changes) => { cluster.store.applyChangesToPool(changes); };
       }
       return {
-        presence: createPresenceStream(
-          {
-            participantId: context.participant?.id ?? '',
-            syncGroups: [...(context.syncGroups ?? [])],
-            isAgent: context.participant?.kind === 'agent',
-          },
-          context.transport ?? null,
-        ),
+        presence: createPresence(context.transport ?? null),
         ...(cluster ? { [kStoreCluster]: cluster } : {}),
       };
     },

package/src/local/BaseSyncedStore.ts

@@ -35,7 +35,6 @@ import {
   type GroupRemovedPayload,
   type BootstrapHint,
   type BootstrapDataEvent,
-  type PresenceUpdate,
   type EventMap,
   type DefaultCollaborationEvents,
   type SyncWebSocketEventMap,
@@ -238,7 +237,6 @@ export type {
   GroupRemovedPayload,
   BootstrapHint,
   BootstrapDataEvent,
-  PresenceUpdate,
 };
 
 // deriveSyncPlanFromSchema derives a sync plan from a schema and is
@@ -1500,7 +1498,6 @@ export class BaseSyncedStore<
       applyDeltaFrame: (deltas) => { this.applyDeltaFrame(deltas); },
       handleBootstrapRequired: (hint) => { this.handleBootstrapRequired(hint); },
       handleBootstrapData: (data) => { this.handleBootstrapData(data); },
-      handlePresenceUpdate: (data) => { this.handlePresenceUpdate(data); },
       performCredentialRefresh: () => this.performCredentialRefresh(),
       handleTerminalSessionError: (error) => { this.terminalSessionLifecycle.start(error); },
       nudgeReconnect: () => { this.nudgeReconnect(); },
@@ -1935,9 +1932,6 @@ export class BaseSyncedStore<
     this.updateSyncStatus({ state: 'syncing' });
   }
 
-  /** Handle presence_update event. Override in subclass. */
-  protected handlePresenceUpdate(_data: PresenceUpdate): void {}
-
   // ── Pending changes tracking ─────────────────────────────────────────────
 
   protected incrementPendingChanges(): void {