@abloatai/humans 0.59.2 → 0.61.0

package/dist/local/SyncClient.js

@@ -14,7 +14,7 @@ import { deepEqual, snapshotJsonValue } from '@abloatai/transaction/utils/json';
 // ModelRegistry instance accessed via this.objectPool.registry
 import { LoadStrategy } from '@abloatai/transaction/types';
 import { globalRuntime } from './context.js';
-import { AbloAuthenticationError, AbloError, AbloValidationError } from '@abloatai/transaction/errors';
+import { AbloError, AbloValidationError } from '@abloatai/transaction/errors';
 import { EventEmitter } from 'events';
 import { NetworkMonitor } from './NetworkMonitor.js';
 import { MutationQueue, } from './transactions/mutations/MutationQueue.js';
@@ -25,6 +25,8 @@ import { createLocalMutationPort } from './transactions/localMutation.js';
 import { createReconnectDrain } from './transactions/reconnectDrain.js';
 import { DatabaseCommitOutboxStore } from './transactions/databaseCommitOutbox.js';
 import { toEpochMs, } from './syncClientTypes.js';
+import { batchUploadFiles, uploadFile, } from './fileUploads.js';
+const ignoreSeparatelyObservedMutationFailure = () => undefined;
 export class SyncClient extends EventEmitter {
     runtime;
     objectPool;
@@ -758,7 +760,7 @@ export class SyncClient extends EventEmitter {
      * capturing first ensures those changes are never lost. The captured set is
      * frozen and handed to {@link queueMutation}.
      */
-    mutate(type, model, poolAction, writeOptions) {
+    mutate(type, model, poolAction, writeOptions, capturedChangesOverride) {
         // No-op UPDATE guard (O(1)). An update with no dirty fields would travel
         // to the server, get dropped by `coalesceOperations` Rule 4 (empty input),
         // and — if it was the only op — come back as `lastSyncId: 0`. That trips
@@ -772,21 +774,28 @@ export class SyncClient extends EventEmitter {
         // is false → we fall through to the normal path rather than risk dropping a
         // real write. Only a genuine Model with an empty dirty-set is skipped.
         const hasChanges = model.hasChanges;
-        if (type === 'update' && hasChanges === false) {
-            return;
+        if (type === 'update' &&
+            hasChanges === false &&
+            capturedChangesOverride === undefined) {
+            return Promise.resolve();
         }
         // Capture changes before the pool action runs. Pool operations —
         // upsert in particular — can clear the model's local changes, so
         // capturing first ensures they are never lost.
-        const capturedChanges = type === 'update' || type === 'create' ? this.captureModelChanges(model) : undefined;
+        const capturedChanges = capturedChangesOverride !== undefined
+            ? Object.freeze({ ...capturedChangesOverride })
+            : type === 'update' || type === 'create'
+                ? this.captureModelChanges(model)
+                : undefined;
         poolAction();
-        this.stageMutation(type, model, capturedChanges, writeOptions);
+        const confirmation = this.stageMutation(type, model, capturedChanges, writeOptions);
         this.notifyObservers({
             type,
             modelType: model.getModelName(),
             model: type !== 'delete' ? model : undefined,
             modelId: model.id,
         });
+        return confirmation;
         // QueryProcessor uses `models:changed` to invalidate caches. Coalesce
         // to one event per microtask: a paste of 100 rows should re-run
         // affected queries ONCE, not 100×.
@@ -821,11 +830,11 @@ export class SyncClient extends EventEmitter {
     }
     /** Add new model (CREATE) - works offline */
     add(model, options) {
-        this.mutate('create', model, () => { this.objectPool.add(model, ModelScope.live); }, options);
+        return this.mutate('create', model, () => { this.objectPool.add(model, ModelScope.live); }, options);
     }
     /** Update existing model (UPDATE) - works offline */
-    update(model, options) {
-        this.mutate('update', model, () => { this.objectPool.upsert(model, ModelScope.live); }, options);
+    update(model, options, capturedChanges) {
+        return this.mutate('update', model, () => { this.objectPool.upsert(model, ModelScope.live); }, options, capturedChanges);
     }
     /**
      * Update existing model with pre-computed changes.
@@ -849,7 +858,7 @@ export class SyncClient extends EventEmitter {
         if (capturedChanges === undefined)
             return;
         this.objectPool.upsert(model, ModelScope.live);
-        this.stageMutation('update', model, capturedChanges);
+        void this.stageMutation('update', model, capturedChanges);
         this.notifyObservers({
             type: 'update',
             modelType: model.getModelName(),
@@ -867,101 +876,29 @@ export class SyncClient extends EventEmitter {
     delete(model, options) {
         // Clear pending mutations first to prevent "not found" errors on fast delete
         this.mutationQueue.cancelTransactionsForModel(model.id);
-        this.mutate('delete', model, () => this.objectPool.remove(model.id), options);
+        return this.mutate('delete', model, () => this.objectPool.remove(model.id), options);
     }
-    /**
-     * Upload a file and create its attachment record. The upload runs through
-     * the {@link MutationQueue}, and a model is built from the server's
-     * response and added to the pool.
-     */
-    async uploadFile(file, options) {
-        if (!this.userId || !this.organizationId) {
-            throw new AbloAuthenticationError('Authentication required for file uploads', {
-                code: 'file_upload_auth_required',
-            });
-        }
-        try {
-            // Use MutationQueue to handle the upload mutation
-            const result = await this.mutationQueue.uploadAttachment(file, {
-                id: options.id,
-                attachableType: options.attachableType,
-                attachableId: options.attachableId,
-                metadata: options.metadata,
-            }, {
-                userId: this.userId,
-                organizationId: this.organizationId,
-            });
-            if (result) {
-                // Create model from response using ModelRegistry (generic — no concrete class import)
-                const model = this.objectPool.createFromData({
-                    id: options.id,
-                    ...result,
-                });
-                if (model) {
-                    this.objectPool.add(model, ModelScope.live);
-                    this.notifyObservers({
-                        type: 'create',
-                        modelType: model.getModelName(),
-                        model,
-                    });
-                    return model;
-                }
-            }
-            return null;
-        }
-        catch (error) {
-            this.runtime.observability.captureMutationFailure({
-                context: 'file-upload',
-                error: error instanceof Error ? error : new Error(String(error)),
-            });
-            throw error;
-        }
-    }
-    /**
-     * Batch upload files — single GraphQL call + parallel S3 PUTs.
-     *
-     * Returns the raw `Model[]` built by the object pool (typename is
-     * determined by the payload the server returns — currently always
-     * `Attachment`). The SDK has no knowledge of app-specific model classes,
-     * so it cannot honestly claim a narrower return type; consumers that
-     * need an `Attachment[]` project through their own typed accessor
-     * (e.g. `store.query.attachments.findMany({ where: { id: IN ids } })`)
-     * after the upload resolves.
-     */
-    async batchUploadFiles(files, options) {
-        if (!this.userId || !this.organizationId) {
-            throw new AbloAuthenticationError('Authentication required for file uploads', {
-                code: 'file_upload_auth_required',
-            });
-        }
-        const items = options.ids.map((id) => ({
-            id,
-            attachableType: options.attachableType,
-            attachableId: options.attachableId,
-            metadata: options.metadata,
-        }));
-        const results = await this.mutationQueue.batchUploadAttachments(files, items, {
+    fileUploadContext() {
+        return {
             userId: this.userId,
             organizationId: this.organizationId,
-        });
-        const models = [];
-        for (const result of results) {
-            const model = this.objectPool.createFromData({ ...result });
-            if (model) {
-                this.objectPool.add(model, ModelScope.live);
-                this.notifyObservers({
-                    type: 'create',
-                    modelType: model.getModelName(),
-                    model,
-                });
-                models.push(model);
-            }
-        }
-        return models;
+            mutationQueue: this.mutationQueue,
+            objectPool: this.objectPool,
+            observability: this.runtime.observability,
+            notifyCreated: (model) => {
+                this.notifyObservers({ type: 'create', modelType: model.getModelName(), model });
+            },
+        };
+    }
+    uploadFile(file, options) {
+        return uploadFile(this.fileUploadContext(), file, options);
+    }
+    batchUploadFiles(files, options) {
+        return batchUploadFiles(this.fileUploadContext(), files, options);
     }
     /** Archive model (ARCHIVE) - works offline */
     archive(model) {
-        this.mutate('archive', model, () => { this.objectPool.updateScope(model.id, ModelScope.archived); });
+        return this.mutate('archive', model, () => { this.objectPool.updateScope(model.id, ModelScope.archived); });
     }
     /**
      * Append a mutation to the pending queue and schedule its sync work.
@@ -979,13 +916,20 @@ export class SyncClient extends EventEmitter {
     /** Stage one mutation through the queue, which owns durability and execution. */
     stageMutation(type, model, capturedChanges, writeOptions) {
         if (this.isDisposed)
-            return;
+            return Promise.resolve();
         if (!this.userId || !this.organizationId) {
             this.mutationQueue.deferMutation(type, model, capturedChanges, writeOptions);
             return;
         }
         const context = { userId: this.userId, organizationId: this.organizationId };
         const staging = this.mutationQueue.enqueueModelMutation(type, model, context, capturedChanges, writeOptions);
+        const confirmation = staging.then(async (transaction) => {
+            await transaction.confirmation;
+        });
+        // Most internal callers intentionally use fire-and-forget writes. Observe
+        // their rejection without replacing the exact promise returned to model
+        // operations that need authoritative per-transaction confirmation.
+        void confirmation.catch(ignoreSeparatelyObservedMutationFailure);
         const pending = staging.then(() => undefined).catch((error) => {
             this.runtime.observability.captureMutationFailure({
                 context: `stage-mutation-${type}`,
@@ -996,6 +940,7 @@ export class SyncClient extends EventEmitter {
         });
         this.pendingStages.add(pending);
         void pending.finally(() => this.pendingStages.delete(pending));
+        return confirmation;
     }
     scheduleSync() {
         if (!this.runtime.onlineStatus.isOnline() || this.isDisposed)
@@ -1210,14 +1155,11 @@ export class SyncClient extends EventEmitter {
     markConnected() {
         this.setConnectionState('connected');
         // Browser online state may have marked the client connected before the
-        // WebSocket itself was ready. Always kick both durable lanes on the real
-        // socket event, even when the high-level state did not change.
-        void this.drainPendingConfirmations().catch((error) => {
-            this.runtime.observability.captureMutationFailure({
-                context: 'restore-commit-outbox',
-                error: error instanceof Error ? error : new Error(String(error)),
-            });
-        });
+        // WebSocket itself was ready. Kick the durable lanes through the staging
+        // barrier: a model mutation enters the in-memory store before its journal
+        // row finishes saving, so a direct reconnect drain can otherwise try to
+        // seal a source record that does not exist yet. The pending drain also
+        // starts the atomic commit lane, so one ordered entry point covers both.
         void this.processPendingMutations();
     }
     drainPendingConfirmations() {

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

@@ -6,7 +6,7 @@
  * `read` and `list`, with the same point lookup restricted to the local graph under
  * `local`, the writes `create`, `update`, and `delete`, the coordination
  * namespace `claim` (callable as `claim({ id })`, plus `claim.state`,
- * `claim.queue`, `claim.release`, and `claim.reorder`), `join`, and `onChange`.
+ * `claim.queue`, `claim.release`, and `claim.reorder`), and `onChange`.
  * The factory returns a plain object; the client assembles the `ablo.<model>`
  * lookup table from one of these per model.
  */
@@ -16,11 +16,10 @@ import type { ModelRegistry } from '../ModelRegistry.js';
 import type { InstanceCache } from '../InstanceCache.js';
 import type { SyncClient } from '../SyncClient.js';
 import type { OnDemandLoader } from '../sync/OnDemandLoader.js';
-import type { JoinedParticipant } from '../sync/participants.js';
 import type { Duration, Claim, ClaimHeartbeat, ClaimHeartbeatOptions, HeldClaim, HeldLease, ClaimWaitOptions } from '@abloatai/transaction/types/streams';
-export type { ModelListScope, LocalReadOptions, LocalCountOptions, ServerReadOptions, ListAllOptions, ServerPointReadOptions, ClaimTargetOptions, ClaimParams, ClaimContentionOptions, ClaimAttemptEvent, ClaimQueueView, ClaimSkipOptions, ClaimSkipParams, ClaimLookupParams, ClaimReorderParams, ClaimOptions, ClaimReadApi, AwaitedClaimMethod, ClaimApi, ModelReadParams, ModelCreateParams, ModelUpdateParams, ModelDeleteParams, JoinOptions, } from '@abloatai/transaction/client/resources/modelOperations';
+export type { ModelListScope, LocalReadOptions, LocalCountOptions, ServerReadOptions, ListAllOptions, ServerPointReadOptions, ClaimTargetOptions, ClaimParams, ClaimContentionOptions, ClaimAttemptEvent, ClaimQueueView, ClaimSkipOptions, ClaimSkipParams, ClaimLookupParams, ClaimReorderParams, ClaimOptions, ClaimReadApi, AwaitedClaimMethod, ClaimApi, ModelReadParams, ModelCreateParams, ModelUpdateParams, ModelDeleteParams, } from '@abloatai/transaction/client/resources/modelOperations';
 export type { Claim, ClaimHeartbeat, ClaimHeartbeatOptions, HeldClaim, HeldLease };
-import type { ClaimApi, ClaimAttemptEvent, JoinOptions, LocalCountOptions, LocalReadOptions } from '@abloatai/transaction/client/resources/modelOperations';
+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 ReadSetContext } from '@abloatai/transaction/internal/read-set';
@@ -142,13 +141,6 @@ export interface ModelCollaboration {
      * fire-and-forget, best-effort semantics as `enterScope`.
      */
     pinScope?(scope: Record<string, string>): void | Promise<void>;
-    /**
-     * Opens a presence and claim subscription on this model's sync group(s) and
-     * returns the live participant handle. Backs `ablo.<model>.join(ids)`.
-     * WebSocket only, since presence needs a live socket; it is absent on other
-     * client constructions, where the surface throws a clear error.
-     */
-    createJoin?(modelKey: string, ids: string | readonly string[], options?: JoinOptions): Promise<JoinedParticipant>;
 }
 /**
  * The synchronous, local-only reads — reached as `ablo.<model>.local.*`.
@@ -222,22 +214,6 @@ interface ReactiveModelSurface<T, Fields = T> {
      * ```
      */
     claim: ClaimApi<T, Fields>;
-    /**
-     * Joins the sync group(s) for one or more rows of this model and returns a
-     * live participant handle — presence (`.peers`), the scoped claim stream
-     * (`.claims`), and `.leave()` / `await using` disposal. This is a presence
-     * subscription: it reports who else is here and what they hold, not row
-     * values changing — for the latter, use `onChange`.
-     *
-     * WebSocket only: presence needs a live socket, so this is absent on HTTP
-     * clients and throws on any non-WebSocket construction.
-     *
-     * ```ts
-     * await using participant = await ablo.sections.join(sectionIds, { ttl: '5m' });
-     * participant.peers; // who else is here
-     * ```
-     */
-    join(ids: string | readonly string[], options?: JoinOptions): Promise<JoinedParticipant>;
     /** Subscribe to changes; the callback runs on every change. */
     onChange(callback: (entities: T[]) => void, options?: LocalReadOptions<T>): () => void;
 }

package/dist/local/client/createModelOperations.js

@@ -6,7 +6,7 @@
  * `read` and `list`, with the same point lookup restricted to the local graph under
  * `local`, the writes `create`, `update`, and `delete`, the coordination
  * namespace `claim` (callable as `claim({ id })`, plus `claim.state`,
- * `claim.queue`, `claim.release`, and `claim.reorder`), `join`, and `onChange`.
+ * `claim.queue`, `claim.release`, and `claim.reorder`), and `onChange`.
  * The factory returns a plain object; the client assembles the `ablo.<model>`
  * lookup table from one of these per model.
  */
@@ -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;
         };
     };
@@ -130,7 +132,7 @@ hydration, collaboration, readSetContext) {
         const rows = await hydration.fetch(schemaKey, options);
         return rows.map((row) => modelAsRow(row));
     };
-    const waitForMutation = async (model) => {
+    const waitForMutation = async (model, exactConfirmation) => {
         // Model writes are optimistic locally, but their promise has one stable
         // meaning: authoritative confirmation. Callers that do not need the
         // barrier can keep using the row immediately and leave the promise to the
@@ -142,7 +144,10 @@ hydration, collaboration, readSetContext) {
         // coalescer and producing one SQL transaction per delta.
         await Promise.resolve();
         await syncClient.syncNow();
-        await syncClient.waitForConfirmation(model.getModelName(), model.id);
+        if (exactConfirmation)
+            await exactConfirmation;
+        else
+            await syncClient.waitForConfirmation(model.getModelName(), model.id);
     };
     const activeClaims = new Map();
     const claimIdsByEntity = new Map();
@@ -223,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) => {
@@ -811,12 +816,12 @@ hydration, collaboration, readSetContext) {
                     }
                     : {}),
             };
-            syncClient.add(model, effective);
-            await waitForMutation(model);
+            const confirmation = syncClient.add(model, effective);
+            await waitForMutation(model, confirmation);
             return modelAsRow(model);
         }
         finally {
-            await autoLease?.release?.().catch(() => { });
+            await autoLease?.release?.().catch(ignoreBestEffortClaimReleaseFailure);
         }
     });
     function createRows(params) {
@@ -888,8 +893,8 @@ hydration, collaboration, readSetContext) {
                                     : {}),
                             };
                             model.applyChanges(patch);
-                            syncClient.update(model, effective);
-                            await waitForMutation(model);
+                            const confirmation = syncClient.update(model, effective, patch);
+                            await waitForMutation(model, confirmation);
                             return modelAsRow(model);
                         },
                     });
@@ -939,8 +944,8 @@ hydration, collaboration, readSetContext) {
                 // the server. (`updateFromData` is the hydration path and would discard
                 // the tracking, producing an empty `input: {}` no-op mutation.)
                 model.applyChanges(params.data);
-                syncClient.update(model, effective);
-                await waitForMutation(model);
+                const confirmation = syncClient.update(model, effective, params.data);
+                await waitForMutation(model, confirmation);
                 const updated = modelAsRow(model);
                 await settleClaimsAfterWrite(id, handle);
                 return updated;
@@ -997,19 +1002,13 @@ hydration, collaboration, readSetContext) {
                 ...opts,
                 ...(selected ? { claimRef: { id: selected.id } } : {}),
             };
-            syncClient.delete(model, effective);
-            await waitForMutation(model);
+            const confirmation = syncClient.delete(model, effective);
+            await waitForMutation(model, confirmation);
             await settleClaimsAfterWrite(id, handle);
         }),
         // `claim` is a callable namespace (take a claim) carrying the coordination
         // readers (`claim.state` / `claim.queue` / `claim.release` / `claim.reorder`).
         claim: claimApi,
-        join: guard((ids, options) => {
-            if (!collaboration?.createJoin) {
-                throw new AbloValidationError(`Model "${schemaKey}" was built without a WebSocket runtime, so join() is unavailable here. Presence needs a live socket — use the standard Ablo({ schema, apiKey }) client (not the HTTP transport).`, { code: 'model_join_not_configured' });
-            }
-            return collaboration.createJoin(schemaKey, ids, options);
-        }),
         onChange(callback, options) {
             return autorun(() => {
                 callback(local.list(options));

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

@@ -17,6 +17,7 @@ import type { CommitOutboxScope } from '@abloatai/transaction/commit';
  */
 export type { CredentialProvider } from '@abloatai/transaction/auth/apiKey';
 import type { CredentialProvider } from '@abloatai/transaction/auth/apiKey';
+import type { SessionCredential, SessionEndpoint, SessionProvider } from '@abloatai/transaction/sessions';
 import type { AbloPlugin } from '../../plugin.js';
 import type { ParticipantKind } from '@abloatai/transaction/types/participant';
 /**
@@ -56,18 +57,19 @@ export interface AbloOptions<S extends SchemaRecord = SchemaRecord> {
      *    `ABLO_API_KEY` environment variable, so you usually pass nothing. A
      *    long-lived key needs no refresh; the client uses it as-is.
      *
-     *  - **An async resolver** `() => Promise<string | null>` — the escape hatch for
-     *    when the exchange needs custom headers, a request body, or a non-HTTP mint
-     *    (vault rotation, a cloud token service, an existing auth session). It uses
-     *    the same renewal machinery as the endpoint form.
-     *
-     * The endpoint and resolver forms share one contract: return a token; return
-     * `null` when the login itself is gone (terminal — the client signs out and
-     * fails `ready()` with `session_expired`); or throw on a transient failure, which
-     * backs off and retries without signing out. The endpoint form maps HTTP onto
-     * this for you: only a structured `401 session_expired` means signed out.
+     *  - **An async resolver** for advanced process-owned key rotation, such as a
+     *    vault or workload-identity exchange. Scoped actor renewal belongs in
+     *    `session` instead.
      */
     apiKey?: string | CredentialProvider | null | undefined;
+    /**
+     * Scoped actor identity. Pass a session returned by `sessions.create()` for
+     * bounded work, a provider that re-mints it for a long-lived client, or
+     * `{ endpoint: '/api/ablo-session' }` in a browser. Endpoint responses use
+     * the canonical credential protocol; only a structured `401
+     * session_expired` ends the underlying login.
+     */
+    session?: SessionCredential | SessionProvider | SessionEndpoint | null | undefined;
     /**
      * Pins this client to one Ablo project. During `ready()` the server resolves
      * the API key's actual project and the client refuses to start when it differs.
@@ -84,30 +86,6 @@ export interface AbloOptions<S extends SchemaRecord = SchemaRecord> {
      * environment could reach this process.
      */
     branchId?: string | null | undefined;
-    /**
-     * The session-mint endpoint — the browser-side auth field, and the named
-     * endpoint for the route that mints the signed-in user's short-lived token:
-     *
-     * ```ts
-     * const ablo = Ablo({ schema, authEndpoint: '/api/ablo-session' });
-     * ```
-     *
-     * The client owns the whole exchange: it POSTs the route (same-origin, cookies
-     * included), validates the canonical auth response contract, keeps it fresh
-     * ahead of expiry, and re-mints when the server reports the token stale. Only
-     * a structured `401 session_expired` response means signed out. It also
-     * accepts an async resolver `() => Promise<string | null>` when the exchange
-     * needs custom headers or a body — the same contract as the resolver form of
-     * `apiKey`.
-     *
-     * Mutually exclusive with `apiKey`: a server holds a key, a browser holds a mint
-     * route, and passing both is a validation error.
-     */
-    authEndpoint?: string | CredentialProvider | null | undefined;
-    /** Timeout for a session-mint request. @default 10000 */
-    authTimeoutMs?: number | undefined;
-    /** Explicit opt-in for a cross-origin session-mint endpoint. */
-    allowCrossOriginAuthEndpoint?: boolean | undefined;
     /**
      * Local persistence mode. Pass `indexeddb` only when you want offline
      * queueing and a reload-surviving browser cache.
@@ -222,13 +200,10 @@ export interface InternalAbloOptions<S extends SchemaRecord = SchemaRecord> {
      * the original available as `cause`.
      */
     apiKey?: string | CredentialProvider | null | undefined;
+    /** A scoped session, or a provider that re-mints it for a long-lived client. */
+    session?: SessionCredential | SessionProvider | SessionEndpoint | null | undefined;
     /** Expected project assertion; see {@link AbloOptions.projectId}. */
     projectId?: string | null | undefined;
-    /**
-     * Session-mint endpoint (string or async resolver) — see
-     * {@link AbloOptions.authEndpoint}. Mutually exclusive with `apiKey`.
-     */
-    authEndpoint?: string | CredentialProvider | null | undefined;
     /**
      * A bearer auth token, sent as `Authorization: Bearer <token>` on every request.
      *

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

@@ -2,9 +2,9 @@
  * The reactive engine assembly (ADR 0016). `Ablo({ ... })` resolves auth and
  * capabilities; `humans().init` constructs the store cluster; the lifecycle
  * — first mint, identity, ready() — lives in `./storeLifecycle.ts`. What
- * remains here is assembly around those parts: the claim stream and
- * participant manager, options validation, the typed model proxies, and the
- * commit/claim/session resources — composed into the reactive client.
+ * remains here is assembly around those parts: the claim and presence streams,
+ * options validation, the typed model proxies, and the
+ * commit and claim resources — composed into the reactive client.
  *
  * Extracted from the factory so the composition root stays a root: resolve,
  * dispatch, return. The remaining assembly converts to decoration of a
@@ -43,11 +43,5 @@ export interface ReactiveEngineInputs<S extends SchemaRecord> extends ClientPrel
      * assembles around it and constructs none of it.
      */
     cluster: StoreCluster;
-    /**
-     * Constructs a sibling client (`ablo.agents.create(...)` mints a scoped key
-     * and builds a second engine with it). Injected by the factory — a direct
-     * import back into it would close a runtime cycle.
-     */
-    createSibling: (options: AbloOptions<S>) => Ablo<S>;
 }
 export declare function buildReactiveEngine<const S extends SchemaRecord>(inputs: ReactiveEngineInputs<S>): Ablo<S>;