@abloatai/humans 0.62.0 → 0.63.1

package/dist/react/AbloProvider.js

@@ -44,7 +44,7 @@ export function AbloProvider(props) {
     const schema = engine.schema;
     // Account scope isn't a prop — read it from `_store.orgId` once `ready()`
     // resolves the identity from the client's auth.
-    const [resolvedAccountScope, setResolvedAccountScope] = useState(null);
+    const [resolvedScope, setResolvedScope] = useState(null);
     // ── Error emitter (provider-instance scoped) ─────────────────────
     const errorEmitterRef = useRef(null);
     if (!errorEmitterRef.current) {
@@ -98,7 +98,10 @@ export function AbloProvider(props) {
             .then(() => {
             if (stale)
                 return;
-            setResolvedAccountScope(engine._store.orgId ?? null);
+            setResolvedScope({
+                engine,
+                account: engine._store.orgId ?? null,
+            });
         })
             .catch((err) => {
             if (stale)
@@ -133,7 +136,7 @@ export function AbloProvider(props) {
     // unknown until `ready()` resolves identity — so `syncValue` is null until
     // then, which drives the initial fallback below.
     const syncValue = useMemo(() => {
-        const currentAccountScope = resolvedAccountScope ??
+        const currentAccountScope = (resolvedScope?.engine === engine ? resolvedScope.account : null) ??
             engine._store.orgId;
         if (!currentAccountScope)
             return null;
@@ -142,7 +145,7 @@ export function AbloProvider(props) {
             organizationId: currentAccountScope,
             schema,
         };
-    }, [engine, resolvedAccountScope, schema]);
+    }, [engine, resolvedScope, schema]);
     // ── Internal context (currentUserId + error subscription) ────────
     const internalValue = useMemo(() => ({
         currentUserId: userId ?? null,
@@ -152,28 +155,10 @@ export function AbloProvider(props) {
     }), [userId, errorEmitter, engine]);
     // ── Render ───────────────────────────────────────────────────────
     //
-    // Two-phase gate (see `BootstrapGate` below for the latch logic):
-    //
-    //   1. Engine is null on first render (constructed in the effect
-    //      above, not in render). We render `fallback` directly — there
-    //      is no SyncContext to read status from, and by definition the
-    //      engine hasn't started bootstrapping.
-    //   2. Engine exists. Mount SyncContext. `BootstrapGate` then reads
-    //      `useSyncStatus()` and shows `fallback` only during the very
-    //      first `connecting` transition; children render on every
-    //      subsequent state change, including reconnects and auth
-    //      failures (the app's own UI handles those).
-    //
-    // `fallback === 'passthrough'` short-circuits both branches — children
-    // render immediately without any gate, restoring pre-gate behavior
-    // for consumers who need debug helpers / error boundaries / analytics
-    // to mount before the engine is ready.
+    // Keep the context tree stable during startup so passthrough children retain
+    // their component state when authenticated row scope becomes available.
     const passthrough = fallback === 'passthrough';
-    const initialFallback = passthrough ? children : fallback;
-    if (!syncValue) {
-        return (_jsx(AbloInternalContext.Provider, { value: internalValue, children: initialFallback }));
-    }
-    return (_jsx(AbloInternalContext.Provider, { value: internalValue, children: _jsx(SyncContext.Provider, { value: syncValue, children: passthrough ? (children) : (_jsx(BootstrapGate, { fallback: fallback, children: children }, engineKey)) }) }));
+    return (_jsx(AbloInternalContext.Provider, { value: internalValue, children: _jsx(SyncContext.Provider, { value: syncValue, children: passthrough ? (children) : syncValue ? (_jsx(BootstrapGate, { fallback: fallback, children: children }, engineKey)) : fallback }) }));
 }
 /**
  * Internal gate that renders `fallback` only during the very first
@@ -183,8 +168,7 @@ export function AbloProvider(props) {
  * re-show the fallback, because by then the app has already rendered
  * once and its own reconnect UI should take over.
  *
- * Re-keyed on `engineState.key` in the parent so engine rotations
- * (userId/org/url change) reset the latch — a new engine genuinely IS
+ * Re-keyed when the client instance changes so account rotations reset the latch — a new engine genuinely IS
  * a new "first bootstrap" cycle.
  */
 function BootstrapGate({ fallback, children, }) {

package/dist/react/createAbloReact.d.ts

@@ -25,6 +25,8 @@ import { type AbloSelector, type ModelClientSelector, type UseAbloHydratedModelR
 import type { AbloClient as Ablo } from '../client.js';
 import type { ModelOperations } from '../local/client/createModelOperations.js';
 import type { Schema, SchemaRecord } from '@abloatai/transaction/schema/schema';
+import { type PresenceModelSelector } from './usePresence.js';
+import type { PresenceSession } from '@abloatai/transaction/presence';
 /** What a binding returns: the provider and the hook, with `S` fixed. */
 export interface AbloReactBinding<S extends SchemaRecord> {
     /** `AbloProvider` with its `client` prop typed `Ablo<S>` — same component,
@@ -40,6 +42,8 @@ export interface AbloReactBinding<S extends SchemaRecord> {
         }): UseAbloHydratedModelResult<T>;
         <T, C>(modelClientOrSelect: ModelOperations<T, C> | ModelClientSelector<S, T, C>, id: string, options?: UseAbloModelOptions<T>): UseAbloModelResult<T>;
     };
+    /** Declare and reactively read record presence with the same model clients. */
+    usePresence: <T, C>(modelOrSelect: ModelOperations<T, C> | PresenceModelSelector<S, T, C>, recordId: string) => readonly PresenceSession[];
 }
 /**
  * Bind the react surface to one schema. The schema value is taken for

package/dist/react/createAbloReact.js

@@ -22,7 +22,8 @@
  */
 import { createContext, createElement, useContext } from 'react';
 import { AbloProvider, } from './AbloProvider.js';
-import { useAbloImpl, } from './useAblo.js';
+import { useAbloImpl, useAbloClientImpl, } from './useAblo.js';
+import { usePresenceImpl, } from './usePresence.js';
 /**
  * Bind the react surface to one schema. The schema value is taken for
  * inference — write `createAbloReact(schema)`, never a hand-spelled type
@@ -44,5 +45,14 @@ export function createAbloReact(schema) {
         const bound = useContext(BoundClientContext);
         return useAbloImpl(bound, modelOrSelect, id, options);
     }
-    return { AbloProvider: BoundAbloProvider, useAblo: useBoundAblo };
+    function useBoundPresence(modelOrSelect, recordId) {
+        const bound = useContext(BoundClientContext);
+        const engine = useAbloClientImpl(bound);
+        return usePresenceImpl(engine, modelOrSelect, recordId);
+    }
+    return {
+        AbloProvider: BoundAbloProvider,
+        useAblo: useBoundAblo,
+        usePresence: useBoundPresence,
+    };
 }

package/dist/react/useAblo.d.ts

@@ -60,7 +60,7 @@ export type UseAbloHydratedModelResult<T> = Omit<UseAbloModelResult<T>, 'data'>
  * // are typed as snapshot rows — data fields + computeds, no relation
  * // accessors — matching what the hook actually returns:
  * const doc = useAblo((ablo) => ablo.records.local.get(id)) ?? serverDoc;
- * const active = useAblo((ablo) => ablo.records.claim.state({ id }));
+ * const { claimed } = useAblo((ablo) => ablo.records, id);
  *
  * // Without the augmentation, pass the schema as a type argument:
  * const ablo = useAblo<(typeof schema)['models']>();
@@ -93,4 +93,6 @@ export declare function useAblo<R extends SchemaRecord = DefaultModels, T = Reco
  * legacy mount migrates.
  */
 export declare function useAbloImpl<R extends SchemaRecord, T = Record<string, unknown>, C = unknown>(boundClient: Ablo<R> | null, modelOrSelect?: ModelOperations<T, C> | ModelClientSelector<R, T, C> | AbloSelector<R, T>, id?: string, options?: UseAbloModelOptions<T>): Ablo<R> | null | UseAbloModelResult<T> | T | undefined;
+/** @internal Resolve the bound or legacy provider client through one rebind seam. */
+export declare function useAbloClientImpl<R extends SchemaRecord>(boundClient: Ablo<R> | null): Ablo<R> | null;
 export {};

package/dist/react/useAblo.js

@@ -70,11 +70,7 @@ export function useAblo(modelOrSelect, id, options) {
  * legacy mount migrates.
  */
 export function useAbloImpl(boundClient, modelOrSelect, id, options) {
-    const ctx = useContext(AbloInternalContext);
-    // The bound client wins — it is already `Ablo<R>`, no rebinding. The
-    // fallback is the ONE remaining schema rebind in the SDK; it retires with
-    // the last legacy provider mount (docs/plans/typed-react-binding.md).
-    const engine = boundClient ?? (ctx?.engine ? rebindEngine(ctx.engine) : null);
+    const engine = useAbloClientImpl(boundClient);
     const initial = options?.initial;
     const isSelectorOnly = typeof modelOrSelect === 'function' && id === undefined;
     const modelClient = typeof modelOrSelect === 'function' && id !== undefined
@@ -86,12 +82,9 @@ export function useAbloImpl(boundClient, modelOrSelect, id, options) {
             : modelOrSelect;
     // Claims arrive through an event emitter (engine.claims), not through MobX, so
     // the useReactive reactions below cannot track them; we bridge changes with a
-    // setState bump instead. Only the model-row form (`id !== undefined`) reads
-    // claims, so we subscribe only when `id` is set. The selector-only form never
-    // reads claims, and subscribing it to the workspace-wide claim stream would
-    // re-render and recompute it on every claim or presence change anywhere — a
-    // real storm during AI editing or live collaboration — for a value that cannot
-    // change.
+    // setState bump instead. Subscribe the model-row form (`id !== undefined`)
+    // to claims. Selector-only reads track MobX model data; callers displaying
+    // ownership use the row form's `claims` / `claimed` result.
     const [claimVersion, setClaimVersion] = useState(0);
     useEffect(() => {
         if (!engine || id === undefined)
@@ -118,3 +111,12 @@ export function useAbloImpl(boundClient, modelOrSelect, id, options) {
         return modelResult;
     return engine;
 }
+/** @internal Resolve the bound or legacy provider client through one rebind seam. */
+export function useAbloClientImpl(boundClient) {
+    const ctx = useContext(AbloInternalContext);
+    // The bound client wins — it is already `Ablo<R>`, no rebinding. The
+    // fallback is the ONE remaining schema rebind in the SDK; it retires with
+    // the last legacy provider mount (docs/plans/typed-react-binding.md).
+    const engine = boundClient ?? (ctx?.engine ? rebindEngine(ctx.engine) : null);
+    return engine;
+}

package/dist/react/usePresence.d.ts

@@ -0,0 +1,19 @@
+import type { PresenceSession } from '@abloatai/transaction/presence';
+import { type ModelOperations } from '../local/client/createModelOperations.js';
+import type { AbloClient as Ablo } from '../client.js';
+import type { SchemaRecord } from '@abloatai/transaction/schema/schema';
+import type { ResolveSchema } from '@abloatai/transaction/types/global';
+type DefaultModels = ResolveSchema extends {
+    models: infer M;
+} ? M extends SchemaRecord ? M : SchemaRecord : SchemaRecord;
+export type PresenceModelSelector<R extends SchemaRecord, T, C> = (ablo: Ablo<R>) => ModelOperations<T, C>;
+/**
+ * Declare that this component is reading one row and return every live session
+ * reading or otherwise acting on that row. Ablo owns the lease, refresh,
+ * reconnect, and cleanup mechanics for the component's lifetime.
+ */
+export declare function usePresence<T, C>(modelClient: ModelOperations<T, C>, recordId: string): readonly PresenceSession[];
+export declare function usePresence<R extends SchemaRecord = DefaultModels, T = Record<string, unknown>, C = unknown>(select: PresenceModelSelector<R, T, C>, recordId: string): readonly PresenceSession[];
+/** @internal Shared by the global hook and schema-bound React factory. */
+export declare function usePresenceImpl<R extends SchemaRecord, T, C>(engine: Ablo<R> | null, modelOrSelect: ModelOperations<T, C> | PresenceModelSelector<R, T, C>, recordId: string): readonly PresenceSession[];
+export {};

package/dist/react/usePresence.js

@@ -0,0 +1,28 @@
+'use client';
+import { useEffect, useState } from 'react';
+import { AbloValidationError } from '@abloatai/transaction/errors';
+import { getModelClientMeta, } from '../local/client/createModelOperations.js';
+import { useAbloClientImpl } from './useAblo.js';
+export function usePresence(modelOrSelect, recordId) {
+    const engine = useAbloClientImpl(null);
+    return usePresenceImpl(engine, modelOrSelect, recordId);
+}
+/** @internal Shared by the global hook and schema-bound React factory. */
+export function usePresenceImpl(engine, modelOrSelect, recordId) {
+    if (recordId.length === 0) {
+        throw new AbloValidationError('usePresence requires a non-empty record id.', { code: 'invalid_request', param: 'recordId' });
+    }
+    const modelClient = typeof modelOrSelect === 'function'
+        ? engine
+            ? modelOrSelect(engine)
+            : null
+        : modelOrSelect;
+    const presence = modelClient ? getModelClientMeta(modelClient)?.presence : undefined;
+    if (modelClient !== null && presence === undefined) {
+        throw new AbloValidationError('usePresence requires a model from the reactive Ablo client.', { code: 'invalid_request', param: 'modelClient' });
+    }
+    const [, render] = useState(0);
+    useEffect(() => presence?.subscribe(() => { render((version) => version + 1); }), [presence]);
+    useEffect(() => presence?.read(recordId), [presence, recordId]);
+    return presence?.get(recordId) ?? [];
+}

package/dist/react/useSyncStatus.js

@@ -1,10 +1,21 @@
 'use client';
-import { useCallback } from 'react';
-import { useSyncContext, } from './context.js';
+import { useCallback, useContext } from 'react';
+import { SyncContext, } from './context.js';
+import { AbloInternalContext } from './internalContext.js';
+import { AbloValidationError } from '@abloatai/transaction/errors';
 import { useReactive } from '../useReactive.js';
 /** Reactively exposes the local store's connection and confirmation status. */
 export function useSyncStatus() {
-    const { store } = useSyncContext();
+    const provider = useContext(AbloInternalContext);
+    const sync = useContext(SyncContext);
+    // Status does not require authenticated row scope. The client exists before
+    // ready() resolves, including inside passthrough children and custom fallbacks.
+    const store = provider?.engine?._store ?? sync?.store;
+    if (!store) {
+        throw new AbloValidationError('Sync hooks must be used within an <AbloProvider>.', {
+            code: 'sync_context_missing_provider',
+        });
+    }
     const compute = useCallback(() => deriveStatus(store), [store]);
     return useReactive(compute, sameSnapshot);
 }

package/dist/react.d.ts

@@ -3,6 +3,7 @@ export { useReactive } from './useReactive.js';
 export { useCurrentUserId } from './react/useCurrentUserId.js';
 export { useErrorListener } from './react/useErrorListener.js';
 export { useSyncStatus, type SyncStatusSnapshot } from './react/useSyncStatus.js';
+export { usePresence, type PresenceModelSelector, } from './react/usePresence.js';
 export { useMutationFailureListener, type MutationFailurePayload, } from './react/useMutationFailureListener.js';
 export { AbloProvider, usePeers, useSync, useSyncStore, type AbloProviderProps, type GroupScope, } from './react/AbloProvider.js';
 export { ClientSideSuspense, type ClientSideSuspenseProps, } from './react/ClientSideSuspense.js';

package/dist/react.js

@@ -3,6 +3,7 @@ export { useReactive } from './useReactive.js';
 export { useCurrentUserId } from './react/useCurrentUserId.js';
 export { useErrorListener } from './react/useErrorListener.js';
 export { useSyncStatus } from './react/useSyncStatus.js';
+export { usePresence, } from './react/usePresence.js';
 export { useMutationFailureListener, } from './react/useMutationFailureListener.js';
 export { AbloProvider, usePeers, useSync, useSyncStore, } from './react/AbloProvider.js';
 export { ClientSideSuspense, } from './react/ClientSideSuspense.js';

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", "presence", "create", "update", "delete", "claim", "onChange"];
+export declare const PUBLIC_MODEL_VERBS: readonly ["get", "read", "list", "listAll", "local", "presence", "events", "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

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

package/dist/useReactive.js

@@ -11,7 +11,6 @@ export function useReactive(compute, equals = defaultEquals) {
     const computeRef = useRef(compute);
     const equalsRef = useRef(equals);
     const snapshotRef = useRef(null);
-    const versionRef = useRef(0);
     equalsRef.current = equals;
     if (snapshotRef.current === null) {
         snapshotRef.current = { value: compute() };
@@ -20,7 +19,6 @@ export function useReactive(compute, equals = defaultEquals) {
         const next = compute();
         if (!equals(snapshotRef.current.value, next)) {
             snapshotRef.current = { value: next };
-            versionRef.current++;
         }
     }
     computeRef.current = compute;
@@ -30,7 +28,7 @@ export function useReactive(compute, equals = defaultEquals) {
             snapshotRef.current = { value: next };
             onChange();
         }
-    }), [versionRef.current]);
+    }), [compute]);
     const getSnapshot = useCallback(() => snapshotRef.current.value, []);
     return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/humans",
-  "version": "0.62.0",
+  "version": "0.63.1",
   "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.62.0",
+    "@abloatai/transaction": "^0.63.1",
     "mobx": "^6.13.7",
     "uuid": "^11.1.0",
     "zod": "^4.4.3"

package/src/index.ts

@@ -9,6 +9,7 @@ export type {
 } from './Ablo.js';
 export { humans, type HumansSurface } from './humans.js';
 export type { AbloClient } from './client.js';
+export type { CollaborationEventContext } from '@abloatai/transaction/collaboration';
 export type {
   AbloPlugin,
   MergedSurface,

package/src/local/InstanceCache.ts

@@ -1257,7 +1257,7 @@ export class InstanceCache {
   }
 
   private startGC(): void {
-    if (this.gcTimer) return;
+    if (this.gcTimer || this.config.gcInterval <= 0) return;
     this.gcTimer = setInterval(() => this.gc(), this.config.gcInterval);
     // Don't hold a headless Node process open just for pool GC — without
     // this, an agent that never calls disconnect() can never exit. No-op in

package/src/local/client/createModelOperations.ts

@@ -144,6 +144,13 @@ import type {
 } from '@abloatai/transaction/transport/http';
 import type { ParticipantKind } from '@abloatai/transaction/types/participant';
 import type { PresenceSession } from '@abloatai/transaction/presence';
+import type {
+  CollaborationEventContext,
+  ModelEventEnvelope,
+  ModelEventInput,
+  ModelEventTarget,
+} from '@abloatai/transaction/collaboration';
+import { modelEventInputSchema } from '@abloatai/transaction/collaboration';
 import {
   capturePointRead,
   prepareReadSet,
@@ -152,10 +159,16 @@ import {
 
 const ignoreSeparatelyObservedMutationFailure = (): undefined => undefined;
 const ignoreBestEffortClaimReleaseFailure = (): undefined => undefined;
+const ignoreBestEffortScopeFailure = (): undefined => undefined;
 
 export interface ModelClientMeta {
   readonly key: string;
   readonly typename: string;
+  readonly presence?: {
+    get(recordId: string): readonly PresenceSession[];
+    subscribe(listener: () => void): () => void;
+    read(recordId: string): () => void;
+  };
 }
 
 const modelClientMeta = new WeakMap<object, ModelClientMeta>();
@@ -180,6 +193,13 @@ type EntityHalf = Pick<ModelTarget, 'model' | 'id'>;
 export interface ModelCollaboration {
   /** Session projections already held by this client's one presence store. */
   presence(model: string, recordId?: string): readonly PresenceSession[];
+  /** Subscribe once to the connection-owned presence projection. */
+  onPresenceChange(listener: () => void): () => void;
+  /** Start one session-owned read activity and return its cleanup. */
+  startReadPresence(target: EntityHalf): () => void;
+  modelEventTarget(recordId: string): ModelEventTarget;
+  sendModelEvent(input: ModelEventInput): void;
+  onModelEvent(listener: (event: ModelEventEnvelope) => void): () => void;
   /** Exact point evidence from the HTTP read boundary (stamp captured before data). */
   readPoint(model: string, id: string): Promise<{ data: unknown; stamp: number }>;
   /**
@@ -281,6 +301,8 @@ export interface ModelCollaboration {
    * test doubles can omit it.
    */
   enterScope?(scope: Record<string, string>): void | Promise<void>;
+  /** Release read interest previously acquired through {@link enterScope}. */
+  leaveScope?(scope: Record<string, string>): void | Promise<void>;
   /**
    * Pins a scope's sync group(s) — write intent: a row this client holds an
    * active claim on stays subscribed regardless of navigation. Same
@@ -342,6 +364,9 @@ interface ReactiveModelSurface<T, Fields = T> {
   /** Sessions currently active on this model, optionally narrowed to one record. */
   presence(recordId?: string): readonly PresenceSession[];
 
+  /** Lossy, model-record-addressed application events such as cursor or selection. */
+  events: ModelEvents;
+
   /**
    * Claim a row so other writers wait or are rejected until you're done, and
    * inspect or manage that coordination through the same namespace. Call it to
@@ -377,6 +402,50 @@ interface ReactiveModelSurface<T, Fields = T> {
   ): () => void;
 }
 
+export interface ModelEvents {
+  send(
+    recordId: string,
+    event: string,
+    payload: Readonly<Record<string, unknown>>,
+  ): void;
+  subscribe(
+    recordId: string,
+    event: string,
+    handler: (
+      payload: Readonly<Record<string, unknown>>,
+      context: CollaborationEventContext,
+    ) => void,
+  ): () => void;
+}
+
+function subscribeInModelScope(
+  collaboration: ModelCollaboration,
+  scope: Record<string, string>,
+  subscribe: () => () => void,
+): () => void {
+  let stopped = false;
+  let entered = false;
+  let unsubscribe: (() => void) | null = null;
+
+  void Promise.resolve(collaboration.enterScope?.(scope))
+    .then(() => {
+      entered = true;
+      if (stopped) {
+        void collaboration.leaveScope?.(scope);
+        return;
+      }
+      unsubscribe = subscribe();
+    })
+    .catch(ignoreBestEffortScopeFailure);
+
+  return () => {
+    if (stopped) return;
+    stopped = true;
+    unsubscribe?.();
+    if (entered) void collaboration.leaveScope?.(scope);
+  };
+}
+
 /**
  * Everything reachable as `ablo.<model>` on a reactive client.
  *
@@ -1411,6 +1480,52 @@ export function createModelOperations<T, C>(
 
     presence: (recordId?: string) => collaboration?.presence(registeredModelName, recordId) ?? [],
 
+    events: {
+      send(recordId, event, payload) {
+        if (!collaboration) return;
+        const target = collaboration.modelEventTarget(recordId);
+        const parsed = modelEventInputSchema.safeParse({ target, event, payload });
+        if (!parsed.success) {
+          throw new AbloValidationError('Invalid model event.', {
+            code: 'invalid_request',
+            param: 'event',
+            cause: parsed.error,
+          });
+        }
+        const scope = { [schemaKey]: recordId };
+        void Promise.resolve(collaboration.enterScope?.(scope))
+          .then(() => { collaboration.sendModelEvent(parsed.data); })
+          .finally(() => { void collaboration.leaveScope?.(scope); });
+      },
+      subscribe(recordId, event, handler) {
+        if (!collaboration) return () => undefined;
+        const target = collaboration.modelEventTarget(recordId);
+        const parsed = modelEventInputSchema.safeParse({ target, event, payload: {} });
+        if (!parsed.success) {
+          throw new AbloValidationError('Invalid model event subscription.', {
+            code: 'invalid_request',
+            param: 'event',
+            cause: parsed.error,
+          });
+        }
+        const scope = { [schemaKey]: recordId };
+        return subscribeInModelScope(collaboration, scope, () =>
+          collaboration.onModelEvent((incoming) => {
+            if (
+              incoming.target.model !== target.model ||
+              incoming.target.id !== target.id ||
+              incoming.target.syncGroup !== target.syncGroup ||
+              incoming.event !== parsed.data.event
+            ) return;
+            handler(incoming.payload, {
+              sender: incoming.sender,
+              sentAt: incoming.sentAt,
+            });
+          }),
+        );
+      },
+    },
+
     get,
     read,
 
@@ -1666,6 +1781,23 @@ export function createModelOperations<T, C>(
   modelClientMeta.set(operations, {
     key: schemaKey,
     typename: registeredModelName,
+    ...(collaboration
+      ? {
+          presence: {
+            get: (recordId: string) => collaboration.presence(registeredModelName, recordId),
+            subscribe: (listener: () => void) => collaboration.onPresenceChange(listener),
+            read: (recordId: string) => {
+              const scope = { [schemaKey]: recordId };
+              return subscribeInModelScope(collaboration, scope, () =>
+                collaboration.startReadPresence({
+                  model: registeredModelName,
+                  id: recordId,
+                }),
+              );
+            },
+          },
+        }
+      : {}),
   });
 
   return operations;

package/src/local/client/reactiveEngine.ts

@@ -78,6 +78,7 @@ import {
   prepareReadSet,
 } from '@abloatai/transaction/internal/read-set';
 import { contextOnChange } from '../sync/contextOnChange.js';
+import { resolveScopeGroups } from '../sync/scopeGroups.js';
 import type { ReadDependency } from '@abloatai/transaction/coordination';
 import type { CapturedRow } from '@abloatai/transaction/transport/http';
 
@@ -575,6 +576,20 @@ export function buildReactiveEngine<const S extends SchemaRecord>(
       hydration,
       {
         presence: (model, recordId) => presenceStream.forModel(model, recordId),
+        onPresenceChange: (listener) => presenceStream.onChange(listener),
+        startReadPresence: (target) => presenceStream.startRead(target),
+        modelEventTarget: (recordId) => {
+          const syncGroup = resolveScopeGroups({ [schemaKey]: recordId }, schema)[0];
+          if (syncGroup === undefined) {
+            throw new AbloValidationError('A model event requires a record scope.', {
+              code: 'invalid_request',
+              param: 'recordId',
+            });
+          }
+          return { model: registeredModelName, id: recordId, syncGroup };
+        },
+        sendModelEvent: (input) => { transport.sendModelEvent(input); },
+        onModelEvent: (listener) => transport.subscribe('model_event', listener),
         createClaim: (claimOptions) => publicClaims.create(claimOptions),
         // Lazily referenced: `commits` is declared below this loop, and this
         // only runs when someone actually writes a batch.
@@ -617,6 +632,7 @@ export function buildReactiveEngine<const S extends SchemaRecord>(
         // stay fire-and-forget. It's soft either way — the store swallows
         // reconcile errors so read interest never makes a read reject or stall.
         enterScope: (scope) => store.enterScope(scope),
+        leaveScope: (scope) => store.leaveScope(scope),
         pinScope: (scope) => store.pinScope(scope),
       },
       readSetContext,