@abloatai/humans 0.60.0 → 0.62.0

package/dist/local/client/clientPrelude.js

@@ -11,7 +11,9 @@
  * `./Ablo.ts` calls this once and hands the result to whichever client the
  * plugin list selected.
  */
+import { AbloValidationError } from '@abloatai/transaction/errors';
 import { createAuthCredentialSource, } from '@abloatai/transaction/auth/credentialSource';
+import { createPresenceSessionSource, } from '@abloatai/transaction/presence';
 import { assertBrowserSafety, readProcessEnv, rejectRemovedDatabaseUrlOption, resolveApiKey, resolveAuthToken, resolveBaseURL, resolveCredentialResolver, warnIfCliKeyMismatch, } from '@abloatai/transaction/auth/apiKey';
 import { createConsoleLogger, resolveLogLevel } from './consoleLogger.js';
 /**
@@ -22,6 +24,14 @@ import { createConsoleLogger, resolveLogLevel } from './consoleLogger.js';
  * different project than the one being addressed (a warning, not a throw).
  */
 export function resolveClientPrelude(options) {
+    // This package owns the reactive materialiser, not transport selection.
+    // TypeScript can miss excess properties on generic calls and object spreads,
+    // so reject a misplaced selector before resolving any credentials or
+    // constructing local state. The core `Ablo` client owns `transport`.
+    if ('transport' in options) {
+        throw new AbloValidationError("The reactive client does not accept `transport`. Import `Ablo` from " +
+            "'@abloatai/ablo' when selecting HTTP or WebSocket transport.", { code: 'invalid_options', param: 'transport' });
+    }
     const env = readProcessEnv();
     const internalOptions = {
         ...options,
@@ -32,9 +42,10 @@ export function resolveClientPrelude(options) {
     const configuredApiKey = resolveApiKey(authInput);
     const configuredAuthToken = resolveAuthToken(authInput);
     const credentialResolver = resolveCredentialResolver(configuredApiKey);
+    const presenceSession = createPresenceSessionSource();
     const authCredentials = createAuthCredentialSource(
     // eslint-disable-next-line @typescript-eslint/no-deprecated -- load-bearing on the self-hosted path; server-internal cap-mint (Phase 3) not shipped
-    internalOptions.capabilityToken ?? configuredAuthToken);
+    internalOptions.capabilityToken ?? configuredAuthToken, presenceSession);
     rejectRemovedDatabaseUrlOption(options);
     assertBrowserSafety({
         apiKey: configuredApiKey,
@@ -56,6 +67,7 @@ export function resolveClientPrelude(options) {
         configuredAuthToken,
         credentialResolver,
         authCredentials,
+        presenceSession,
         logger,
         url: resolveBaseURL(authInput),
         participantId,

package/dist/local/client/createInternalComponents.js

@@ -39,6 +39,7 @@ export function createInternalComponents(input) {
         syncGroups: options.syncGroups,
         instantModels: deriveInstantModels(schema),
         getAuthToken: auth?.getAuthToken,
+        presenceSession: auth?.presenceSession,
         runtime,
     });
     const database = new Database(modelRegistry, bootstrapHelper, {
@@ -61,6 +62,7 @@ export function createInternalComponents(input) {
         schema,
         baseUrl: bootstrapBaseUrl,
         getAuthToken: auth?.getAuthToken,
+        presenceSession: auth?.presenceSession,
         runtime,
         // The one canonical log position; the loader reads its floor when a query
         // leaves so a late answer cannot overwrite a row the pool already knows to

package/dist/local/client/createModelOperations.d.ts

@@ -22,6 +22,7 @@ export type { Claim, ClaimHeartbeat, ClaimHeartbeatOptions, HeldClaim, HeldLease
 import type { ClaimApi, ClaimAttemptEvent, LocalCountOptions, LocalReadOptions } from '@abloatai/transaction/client/resources/modelOperations';
 import type { HttpModelClient } from '@abloatai/transaction/transport/http';
 import type { ParticipantKind } from '@abloatai/transaction/types/participant';
+import type { PresenceSession } from '@abloatai/transaction/presence';
 import { type ReadSetContext } from '@abloatai/transaction/internal/read-set';
 export interface ModelClientMeta {
     readonly key: string;
@@ -34,6 +35,8 @@ export declare function getModelClientMeta(modelClient: unknown): ModelClientMet
  */
 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[];
     /** Exact point evidence from the HTTP read boundary (stamp captured before data). */
     readPoint(model: string, id: string): Promise<{
         data: unknown;
@@ -187,6 +190,8 @@ export interface LocalReads<T> {
 interface ReactiveModelSurface<T, Fields = T> {
     /** The synchronous local-graph reads. */
     local: LocalReads<T>;
+    /** Sessions currently active on this model, optionally narrowed to one record. */
+    presence(recordId?: string): readonly PresenceSession[];
     /**
      * 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

package/dist/local/client/createModelOperations.js

@@ -31,6 +31,8 @@ import { ModelScope } from '@abloatai/transaction/types';
 import { bindClaimLifetime, claimLifetimeOf, } from '@abloatai/transaction/claims/lifetime';
 import { claimQueueView, resolveClaimContentionOptions, } from '@abloatai/transaction/client/resources/modelOperations';
 import { capturePointRead, prepareReadSet, } from '@abloatai/transaction/internal/read-set';
+const ignoreSeparatelyObservedMutationFailure = () => undefined;
+const ignoreBestEffortClaimReleaseFailure = () => undefined;
 const modelClientMeta = new WeakMap();
 export function getModelClientMeta(modelClient) {
     if (typeof modelClient !== 'object' || modelClient === null)
@@ -113,7 +115,7 @@ hydration, collaboration, readSetContext) {
             // await does not create an unhandled-rejection process error. Returning
             // the original promise preserves normal rejection for callers that do
             // await or attach their own catch handler.
-            void confirmation.catch(() => undefined);
+            void confirmation.catch(ignoreSeparatelyObservedMutationFailure);
             return confirmation;
         };
     };
@@ -226,9 +228,9 @@ hydration, collaboration, readSetContext) {
         // This runs after authoritative confirmation. A best-effort abandon frame
         // cannot turn a committed write into an apparent failure; the server has
         // already fulfilled the participant's claims as part of that commit.
-        await releaseClaimsForEntity(entityId).catch(() => undefined);
+        await releaseClaimsForEntity(entityId).catch(ignoreBestEffortClaimReleaseFailure);
         if (explicit && !explicitWasLocal) {
-            await explicit.release?.().catch(() => undefined);
+            await explicit.release?.().catch(ignoreBestEffortClaimReleaseFailure);
         }
     };
     const takeClaim = async (params) => {
@@ -819,7 +821,7 @@ hydration, collaboration, readSetContext) {
             return modelAsRow(model);
         }
         finally {
-            await autoLease?.release?.().catch(() => { });
+            await autoLease?.release?.().catch(ignoreBestEffortClaimReleaseFailure);
         }
     });
     function createRows(params) {
@@ -827,6 +829,7 @@ hydration, collaboration, readSetContext) {
     }
     const operations = {
         local,
+        presence: (recordId) => collaboration?.presence(registeredModelName, recordId) ?? [],
         get,
         read,
         // No automatic scope enrolment on bulk `list`: that would subscribe to an

package/dist/local/client/reactiveEngine.d.ts

@@ -14,7 +14,7 @@
 import type { SchemaRecord } from '@abloatai/transaction/schema/schema';
 import type { StoreCluster } from './storeCluster.js';
 import type { SyncWebSocket } from '../sync/SyncWebSocket.js';
-import type { AttachablePresenceStream } from '../../presenceStream.js';
+import { type AttachablePresence } from '../../presence/index.js';
 import type { AbloOptions } from './options.js';
 import type { ClientPrelude } from './clientPrelude.js';
 import type { AbloClient as Ablo } from '../../client.js';
@@ -36,7 +36,7 @@ export interface ReactiveEngineInputs<S extends SchemaRecord> extends ClientPrel
     transport: SyncWebSocket;
     /** The humans() plugin's contribution — built by its `init`, already
      *  attached to the connection the context carried. */
-    presence: AttachablePresenceStream;
+    presence: AttachablePresence;
     /**
      * The store cluster `humans().init` constructed from the widened context:
      * this client's runtime, the component graph, and the store. The engine

package/dist/local/client/reactiveEngine.js

@@ -20,6 +20,7 @@ import { startStoreLifecycle } from './storeLifecycle.js';
 import { createClaimStream } from '../sync/createClaimStream.js';
 import { awaitClaimGrant } from '@abloatai/transaction/claims';
 import { bindClaimLifetime, claimLifetimeOf, } from '@abloatai/transaction/claims/lifetime';
+import { attachPresenceToClient, } from '../../presence/index.js';
 import { resolveApiKeyValue, resolveBootstrapBaseUrl } from '@abloatai/transaction/auth/apiKey';
 import { claimAttemptFailure, emitClaimStatus, } from '@abloatai/transaction/client/resources/modelOperations';
 import { createModelOperations } from './createModelOperations.js';
@@ -80,7 +81,7 @@ export function buildReactiveEngine(inputs) {
     // filter own echoes by participant id, seeded in `ready()` alongside the
     // locals above.
     const presenceStream = presence;
-    const claimStream = createClaimStream({ participantId, logger }, transport);
+    const claimStream = createClaimStream({ logger }, transport, presenceStream);
     // 6. Validate options up front — fail loudly on obviously wrong inputs so
     //    strangers don't get silent empty results. Validation errors are written
     //    into `store.syncStatus` (the single source of truth).
@@ -131,17 +132,11 @@ export function buildReactiveEngine(inputs) {
         kind,
         logger,
         validationError: _validationError,
-        onIdentityResolved: ({ userId, participantKind, accountScope, syncGroups, authority }) => {
+        onIdentityResolved: ({ userId, participantKind, accountScope, authority }) => {
             selfParticipantId = userId;
             selfParticipantKind = participantKind;
             _resolvedOrganizationId = accountScope;
             _resolvedIdentity = authority;
-            presenceStream.setParticipant({
-                id: userId,
-                kind: participantKind,
-                syncGroups: [...syncGroups],
-            });
-            claimStream.setParticipant({ id: userId });
         },
     });
     const ready = lifecycle.ready;
@@ -398,6 +393,7 @@ export function buildReactiveEngine(inputs) {
     for (const [schemaKey, modelDef] of Object.entries(schema.models)) {
         const registeredModelName = modelDef.typename ?? schemaKey;
         modelProxies[schemaKey] = createModelOperations(schemaKey, registeredModelName, objectPool, syncClient, modelRegistry, hydration, {
+            presence: (model, recordId) => presenceStream.forModel(model, recordId),
             createClaim: (claimOptions) => publicClaims.create(claimOptions),
             // Lazily referenced: `commits` is declared below this loop, and this
             // only runs when someone actually writes a batch.
@@ -599,6 +595,10 @@ export function buildReactiveEngine(inputs) {
         get syncStatus() {
             return store.syncStatus;
         },
+        // The humans capability owns the connection-backed presence projection.
+        // Keep it on the base client as well as in the plugin surface so the
+        // concrete AbloClient contract and runtime object agree before layering.
+        presence: presenceStream,
         schema,
         // ── Internal accessors for framework integration ─────────────────
         // These expose internal components for consumers that need direct
@@ -611,13 +611,11 @@ export function buildReactiveEngine(inputs) {
         get _pool() { return objectPool; },
         /** The SyncWebSocket — for collaboration events (selection, cursors). */
         get _ws() { return store.getSyncWebSocket(); },
-        /** Presence livestream — same socket as entity sync, no second
-         *  connection. Stable reference across the engine's lifetime. */
-        presence: presenceStream,
         /** Claim livestream — same socket. Stable reference. */
         claims: publicClaims,
         commits,
     };
+    attachPresenceToClient(engine, presenceStream);
     Object.defineProperty(engine, kReadEvidence, {
         value: {
             context: cluster.readSetContext,

package/dist/local/fileUploads.d.ts

@@ -0,0 +1,27 @@
+/** File-upload behavior owned beneath the SyncClient boundary. */
+import type { RuntimeContext } from './RuntimeContext.js';
+import { Model } from './Model.js';
+import { InstanceCache } from './InstanceCache.js';
+import type { MutationQueue } from './transactions/mutations/MutationQueue.js';
+export interface FileUploadOptions {
+    readonly id: string;
+    readonly attachableType: string;
+    readonly attachableId: string;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface BatchFileUploadOptions {
+    readonly ids: string[];
+    readonly attachableType: string;
+    readonly attachableId: string;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface FileUploadContext {
+    readonly userId: string | null;
+    readonly organizationId: string | null;
+    readonly mutationQueue: MutationQueue;
+    readonly objectPool: InstanceCache;
+    readonly observability: RuntimeContext['observability'];
+    readonly notifyCreated: (model: Model) => void;
+}
+export declare function uploadFile(context: FileUploadContext, file: File, options: FileUploadOptions): Promise<Model | null>;
+export declare function batchUploadFiles(context: FileUploadContext, files: File[], options: BatchFileUploadOptions): Promise<Model[]>;

package/dist/local/fileUploads.js

@@ -0,0 +1,55 @@
+/** File-upload behavior owned beneath the SyncClient boundary. */
+import { AbloAuthenticationError } from '@abloatai/transaction/errors';
+import { Model } from './Model.js';
+import { InstanceCache, ModelScope } from './InstanceCache.js';
+function authenticatedContext(context) {
+    if (!context.userId || !context.organizationId) {
+        throw new AbloAuthenticationError('Authentication required for file uploads', {
+            code: 'file_upload_auth_required',
+        });
+    }
+    return { userId: context.userId, organizationId: context.organizationId };
+}
+function acceptUploadedModel(context, data) {
+    const model = context.objectPool.createFromData(data);
+    if (!model)
+        return null;
+    context.objectPool.add(model, ModelScope.live);
+    context.notifyCreated(model);
+    return model;
+}
+export async function uploadFile(context, file, options) {
+    const identity = authenticatedContext(context);
+    try {
+        const result = await context.mutationQueue.uploadAttachment(file, {
+            id: options.id,
+            attachableType: options.attachableType,
+            attachableId: options.attachableId,
+            metadata: options.metadata,
+        }, identity);
+        return result
+            ? acceptUploadedModel(context, { id: options.id, ...result })
+            : null;
+    }
+    catch (error) {
+        context.observability.captureMutationFailure({
+            context: 'file-upload',
+            error: error instanceof Error ? error : new Error(String(error)),
+        });
+        throw error;
+    }
+}
+export async function batchUploadFiles(context, files, options) {
+    const identity = authenticatedContext(context);
+    const items = options.ids.map((id) => ({
+        id,
+        attachableType: options.attachableType,
+        attachableId: options.attachableId,
+        metadata: options.metadata,
+    }));
+    const results = await context.mutationQueue.batchUploadAttachments(files, items, identity);
+    return results.flatMap((result) => {
+        const model = acceptUploadedModel(context, { ...result });
+        return model ? [model] : [];
+    });
+}

package/dist/local/query/client.d.ts

@@ -15,6 +15,7 @@ import type { QueryBatch, QueryBatchResult } from './types.js';
 import { type RecoveryClass } from '@abloatai/transaction/errorCodes';
 import { type AuthTokenGetter } from '@abloatai/transaction/auth/credentialSource';
 import type { RuntimeContext } from '../RuntimeContext.js';
+import type { PresenceSessionSource } from '@abloatai/transaction/presence';
 export interface PostQueryOptions {
     /**
      * Full base URL of the sync server including the `/api` prefix.
@@ -38,6 +39,8 @@ export interface PostQueryOptions {
      * effect without rebuilding the client.
      */
     capabilityToken?: string;
+    /** Server-bound attribution shared with the owning WebSocket. */
+    presenceSession?: PresenceSessionSource;
     /**
      * An optional hook that tries to recover from a rejected credential. When a
      * query comes back with a 401, its {@link RecoveryClass} is passed here: a

package/dist/local/query/client.js

@@ -74,7 +74,7 @@ export async function postQuery(options, batch) {
         try {
             // Recomputed per attempt: `withAuthHeaders` reads the live credential
             // source, so a replay after recovery carries the freshly-minted key.
-            const headers = withAuthHeaders(options.getAuthToken, { 'Content-Type': 'application/json' }, options.capabilityToken);
+            const headers = withAuthHeaders(options.getAuthToken, { 'Content-Type': 'application/json' }, options.capabilityToken, options.presenceSession);
             const response = await fetch(url, {
                 method: 'POST',
                 headers,

package/dist/local/stores/syncAction.d.ts

@@ -10,10 +10,10 @@ export declare const syncActionSchema: z.ZodObject<{
     modelName: z.ZodString;
     modelId: z.ZodString;
     action: z.ZodEnum<{
-        A: "A";
         I: "I";
         U: "U";
         D: "D";
+        A: "A";
         V: "V";
         C: "C";
         G: "G";

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

@@ -94,6 +94,8 @@ export interface BootstrapOptions {
      * {@link BootstrapFetcher.setAuthToken}.
      */
     getAuthToken?: AuthTokenGetter;
+    /** Server-bound attribution shared with the owning WebSocket. */
+    presenceSession?: import('@abloatai/transaction/presence').PresenceSessionSource;
     /** The owning client's runtime. Defaults to the module-global bridge. */
     runtime?: RuntimeContext;
 }

package/dist/local/sync/BootstrapFetcher.js

@@ -172,7 +172,7 @@ export class BootstrapFetcher {
         try {
             const res = await fetch(`${this.options.baseUrl}/schema`, {
                 method: 'GET',
-                headers: withAuthHeaders(this.options.getAuthToken, {}, this.options.authToken),
+                headers: withAuthHeaders(this.options.getAuthToken, {}, this.options.authToken, this.options.presenceSession),
             });
             if (!res.ok)
                 throw new Error(`schema read-back ${res.status}`);
@@ -570,7 +570,7 @@ export class BootstrapFetcher {
         // conditional revalidation (If-None-Match) implement it at their own
         // level where they own the cache-key namespace. The 304 branch below
         // remains defensively in place for when a caller enables revalidation.
-        const headers = withAuthHeaders(this.options.getAuthToken, { 'Content-Type': 'application/json' }, this.options.authToken);
+        const headers = withAuthHeaders(this.options.getAuthToken, { 'Content-Type': 'application/json' }, this.options.authToken, this.options.presenceSession);
         const controller = new AbortController();
         this.activeControllers.set(controller, 'bootstrap');
         try {
@@ -738,7 +738,7 @@ export class BootstrapFetcher {
                     'Content-Type': 'application/json',
                     'Cache-Control': 'no-cache, no-store, must-revalidate',
                     Pragma: 'no-cache',
-                }, this.options.authToken),
+                }, this.options.authToken, this.options.presenceSession),
                 signal: controller.signal,
                 cache: 'no-store', // Force browser to not cache
             });
@@ -797,7 +797,7 @@ export class BootstrapFetcher {
                 method: 'GET',
                 headers: withAuthHeaders(this.options.getAuthToken, {
                     'Content-Type': 'application/json',
-                }, this.options.authToken),
+                }, this.options.authToken, this.options.presenceSession),
                 signal: controller.signal,
             });
         }

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

@@ -37,6 +37,7 @@ import type { LoadWhere, WhereClause } from '../query/types.js';
 import { normalizeWhere } from '@abloatai/transaction/client/resources/where';
 import type { Schema } from '@abloatai/transaction/schema/schema';
 import type { LogPositionPort } from '../logPosition.js';
+import type { PresenceSessionSource } from '@abloatai/transaction/presence';
 export interface OnDemandLoaderOptions {
     readonly objectPool: InstanceCache;
     /**
@@ -53,6 +54,7 @@ export interface OnDemandLoaderOptions {
      * propagate without re-instantiating the coordinator.
      */
     readonly getAuthToken?: () => string | null;
+    readonly presenceSession?: PresenceSessionSource;
     /** @deprecated Use `getAuthToken`. */
     readonly getCapabilityToken?: () => string | null;
     /** The owning client's runtime. Defaults to the module-global bridge. */

package/dist/local/sync/OnDemandLoader.js

@@ -452,6 +452,7 @@ export class OnDemandLoader {
             getAuthToken: this.authTokenProvider ?? undefined,
             recoverCredential: this.credentialRecovery ?? undefined,
             runtime: this.opts.runtime,
+            presenceSession: this.opts.presenceSession,
         }, { queries: [query] });
         const rows = Array.isArray(result.results[0]) ? result.results[0] : [];
         const evidence = result.evidence?.[0] ?? [];

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

@@ -12,7 +12,7 @@
 import { type ClientSyncDelta } from '@abloatai/transaction/observation';
 import { WsTransport, type WsTransportOptions, type EventMap, type DefaultCollaborationEvents } from '@abloatai/transaction/transport/websocket';
 export type { CommitAck } from './commitFrames.js';
-export type { SyncCapabilities, BootstrapHint, BootstrapDataEvent, PresenceUpdate, CoreSyncEventMap, DefaultCollaborationEvents, EventMap, SyncWebSocketEventMap, } from '@abloatai/transaction/transport/websocket';
+export type { SyncCapabilities, BootstrapHint, BootstrapDataEvent, CoreSyncEventMap, DefaultCollaborationEvents, EventMap, SyncWebSocketEventMap, } from '@abloatai/transaction/transport/websocket';
 /**
  * The wire delta the client receives. It is inferred from the canonical
  * `clientSyncDeltaSchema` so the client and server share one contract rather
@@ -67,7 +67,7 @@ export declare class SyncWebSocket<TCollaboration extends EventMap<TCollaboratio
     protected resumeCursor(): string;
     /**
      * The open ritual, run by the transport between its `connected` emit and the
-     * heartbeat start: announce presence, tell the server where we left off,
+     * heartbeat start: tell the server where we left off,
      * request the deltas we missed, and start the catch-up poll.
      */
     protected onOpened(): void;
@@ -121,19 +121,6 @@ export declare class SyncWebSocket<TCollaboration extends EventMap<TCollaboratio
      * Public wrapper for sending ack from outside the class
      */
     acknowledge(syncId: number): void;
-    /**
-     * Send presence update to server.
-     * Use this for:
-     * - Updating timezone (improves localTime accuracy shown to other users)
-     * - Manual status changes (away, custom status)
-     *
-     * Note: "online" status is automatically set by server on WebSocket connect,
-     * and "offline" is set on disconnect. You don't need to call this for basic online/offline.
-     *
-     * @param status - "online", "away", or custom status string
-     * @param customStatus - Optional custom status message
-     */
-    sendPresenceUpdate(status?: 'online' | 'away' | 'offline', customStatus?: string): void;
     /**
      * Stop the periodic catchup interval
      */

package/dist/local/sync/SyncWebSocket.js

@@ -53,13 +53,10 @@ export class SyncWebSocket extends WsTransport {
     }
     /**
      * The open ritual, run by the transport between its `connected` emit and the
-     * heartbeat start: announce presence, tell the server where we left off,
+     * heartbeat start: tell the server where we left off,
      * request the deltas we missed, and start the catch-up poll.
      */
     onOpened() {
-        // Send presence update with timezone (server sets presence to "online" on connect,
-        // this improves localTime accuracy by providing the user's actual timezone)
-        this.sendPresenceUpdate('online');
         // Immediately request incremental sync based on our stored cursor.
         // `requestIncrementalSync` is async — a bare call inside try/catch is a
         // rejection hole (the catch never sees it); route failures through
@@ -224,38 +221,6 @@ export class SyncWebSocket extends WsTransport {
     acknowledge(syncId) {
         this.sendAck(syncId);
     }
-    /**
-     * Send presence update to server.
-     * Use this for:
-     * - Updating timezone (improves localTime accuracy shown to other users)
-     * - Manual status changes (away, custom status)
-     *
-     * Note: "online" status is automatically set by server on WebSocket connect,
-     * and "offline" is set on disconnect. You don't need to call this for basic online/offline.
-     *
-     * @param status - "online", "away", or custom status string
-     * @param customStatus - Optional custom status message
-     */
-    sendPresenceUpdate(status = 'online', customStatus) {
-        if (!this.isConnected())
-            return;
-        const timezone = (() => {
-            try {
-                return Intl.DateTimeFormat().resolvedOptions().timeZone;
-            }
-            catch {
-                return 'UTC';
-            }
-        })();
-        this.send({
-            type: 'presence_update',
-            payload: {
-                status,
-                timezone,
-                ...(customStatus ? { customStatus } : {}),
-            },
-        });
-    }
     /**
      * Stop the periodic catchup interval
      */

package/dist/local/sync/contextOnChange.js

@@ -37,7 +37,7 @@ export function contextOnChange(transport, pool, reads, listener) {
     // already advanced this exact row in the pool.
     for (const read of rowReads) {
         const resident = pool.peek(read.id);
-        if (!resident || resident.getModelName().toLowerCase() !== read.model.toLowerCase()) {
+        if (resident?.getModelName().toLowerCase() !== read.model.toLowerCase()) {
             continue;
         }
         const observed = pool.watermarks.of(resident);

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;