@abloatai/humans 0.62.0 → 0.63.1

package/src/local/transactions/mutations/MutationQueue.ts

@@ -246,6 +246,8 @@ export class MutationQueue extends EventEmitter {
   private isProcessing = false;
   private processTimer?: NodeJS.Timeout;
   private processScheduled = false;
+  private disposed = false;
+  private retryTimers = new Set<ReturnType<typeof setTimeout>>();
 
   // Staging area for transactions created in the same event-loop tick. Each one
   // lands here first, then a microtask commits them together.
@@ -331,10 +333,11 @@ export class MutationQueue extends EventEmitter {
       isDefinitiveRejection: (error) => this.isDefinitiveRejection(error),
       isPermanentError: (error) => this.isPermanentError(error),
       scheduleRetry: (delayMs) => {
+        if (this.disposed) return;
         if (this.commitRetryTimer !== null) clearTimeout(this.commitRetryTimer);
         this.commitRetryTimer = setTimeout(() => {
           this.commitRetryTimer = null;
-          void this.processCommitLane();
+          if (!this.disposed) void this.processCommitLane();
         }, delayMs);
       },
       emitCommitLifecycle: (event, payload) => { this.emitCommitLifecycle(event, payload); },
@@ -463,6 +466,7 @@ export class MutationQueue extends EventEmitter {
       isPermanentError: (error) => this.isPermanentError(error),
       rollbackOptimistic: (transaction, reason, error) => this.rollbackOptimistic(transaction, reason, error),
       enqueue: (transaction) => { this.enqueue(transaction); },
+      scheduleRetry: (callback, delayMs) => { this.scheduleRetry(callback, delayMs); },
       getLastPermanentErrorSignature: () => this.lastPermanentErrorSig,
       setLastPermanentErrorSignature: (signature) => { this.lastPermanentErrorSig = signature; },
       emit: (event, payload) => this.emit(event, payload),
@@ -968,6 +972,7 @@ export class MutationQueue extends EventEmitter {
     clientTxId = transactionId,
     correlationId?: string,
   ): void {
+    if (this.disposed) return;
     const previous = this.replicationLagTimeouts.get(transactionId);
     if (previous) clearTimeout(previous);
     this.replicationLagErrors.delete(transactionId);
@@ -1182,6 +1187,7 @@ export class MutationQueue extends EventEmitter {
    * {@link drainPending} resumes the work when the owner decides to drain.
    */
   setConnectionState(state: 'connected' | 'disconnected'): void {
+    if (this.disposed) return;
     if (state === 'connected') {
       if (this.commitOfflineGraceTimer !== null) {
         clearTimeout(this.commitOfflineGraceTimer);
@@ -1400,13 +1406,15 @@ export class MutationQueue extends EventEmitter {
   }
 
   private scheduleProcessing(immediate = false): void {
+    if (this.disposed) return;
     scheduleProcessingExternal(this.processingSchedulerContext, immediate);
   }
 
   private async processBatch(): Promise<void> {
+    if (this.disposed) return;
     if (this.modelProcessingPromise) {
       await this.modelProcessingPromise;
-      if (this.executionQueue.length > 0) await this.processBatch();
+      if (!this.disposed && this.executionQueue.length > 0) await this.processBatch();
       return;
     }
     const processing = processBatch(this.batchProcessingContext);
@@ -1500,9 +1508,19 @@ export class MutationQueue extends EventEmitter {
   // Schedule the retry-and-reconciliation wait for a transaction's confirming
   // delta; see {@link DeltaConfirmationTracker} in `./deltaConfirmation.js`.
   private scheduleDeltaConfirmationTimeout(tx: QueuedMutation, timeoutMs: number): void {
+    if (this.disposed) return;
     this.deltaConfirmation.scheduleDeltaConfirmationTimeout(tx, timeoutMs);
   }
 
+  private scheduleRetry(callback: () => void, delayMs: number): void {
+    if (this.disposed) return;
+    const timer = setTimeout(() => {
+      this.retryTimers.delete(timer);
+      if (!this.disposed) callback();
+    }, delayMs);
+    this.retryTimers.add(timer);
+  }
+
   /**
    * Resolves once the given transaction is confirmed and rejects if it fails.
    * The confirming delta's timeout is handled by
@@ -1566,6 +1584,7 @@ export class MutationQueue extends EventEmitter {
   }
 
   private async processCommitLane(): Promise<void> {
+    if (this.disposed) return;
     await processCommitLane(this.commitLaneContext);
   }
 
@@ -1854,6 +1873,9 @@ export class MutationQueue extends EventEmitter {
    * clears all timers and stored transactions, and removes event listeners.
    */
   dispose(): void {
+    if (this.disposed) return;
+    this.disposed = true;
+
     // Cancel all active optimistic updates
     for (const [, optimistic] of this.localMutationPort.updates) {
       this.emit('optimistic:rollback', {
@@ -1888,6 +1910,8 @@ export class MutationQueue extends EventEmitter {
       clearTimeout(this.commitRetryTimer);
       this.commitRetryTimer = null;
     }
+    for (const timer of this.retryTimers) clearTimeout(timer);
+    this.retryTimers.clear();
 
     // Clear store
     this.store.clear();

package/src/local/transactions/mutations/deltaConfirmation.ts

@@ -49,6 +49,7 @@ export class DeltaConfirmationTracker {
 
   // Track retry attempts per transaction for exponential backoff
   private deltaConfirmationRetries = new Map<string, number>();
+  private disposed = false;
 
   private readonly runtime: RuntimeContext;
 
@@ -162,6 +163,7 @@ export class DeltaConfirmationTracker {
   // server has already confirmed. A rollback happens only on an explicit server
   // rejection, never on a timeout.
   scheduleDeltaConfirmationTimeout(tx: QueuedMutation, timeoutMs: number): void {
+    if (this.disposed) return;
     // Cancel any existing timeout for this transaction
     this.cancelDeltaConfirmationTimeout(tx.id);
 
@@ -289,6 +291,7 @@ export class DeltaConfirmationTracker {
    * would keep the process alive and fire callbacks against a cleared store.
    */
   dispose(): void {
+    this.disposed = true;
     for (const timeoutHandle of this.deltaConfirmationTimeouts.values()) {
       clearTimeout(timeoutHandle);
     }

package/src/local/transactions/mutations/failureHandling.ts

@@ -19,6 +19,7 @@ export interface FailureHandlingContext {
     error?: Error,
   ) => Promise<void>;
   readonly enqueue: (transaction: QueuedMutation) => void;
+  readonly scheduleRetry: (callback: () => void, delayMs: number) => void;
   readonly getLastPermanentErrorSignature: () => string | undefined;
   readonly setLastPermanentErrorSignature: (signature: string) => void;
   readonly emit: (event: string, payload: object) => boolean;
@@ -102,7 +103,7 @@ export async function handleFailure(
     );
 
     ctx.store.updateStatus(transaction.id, 'pending');
-    setTimeout(() => {
+    ctx.scheduleRetry(() => {
       // The queue may have shut down or the tx may have been settled
       // (e.g. delta-confirmed) while we backed off.
       if (ctx.store.get(transaction.id)?.status !== 'pending') return;

package/src/presence/index.ts

@@ -4,6 +4,14 @@ import {
   type PresenceProjectionEvents,
   type PresenceView,
 } from '@abloatai/transaction/presence';
+import type { PresenceTarget } from '@abloatai/transaction/presence';
+import {
+  startReadActivity,
+  type ReadActivityLifetime,
+  type ReadActivityTransport,
+} from './readActivity.js';
+
+type PresenceTransport = PresenceProjectionEvents & ReadActivityTransport;
 
 /** Reactive-client presence backed by the client's existing live connection. */
 export interface ReactivePresence extends PresenceView {
@@ -13,7 +21,8 @@ export interface ReactivePresence extends PresenceView {
 
 /** Lifecycle hooks kept inside the humans composition boundary. */
 export interface AttachablePresence extends ReactivePresence {
-  attach(transport: PresenceProjectionEvents): void;
+  attach(transport: PresenceTransport): void;
+  startRead(target: PresenceTarget): () => void;
   dispose(): void;
 }
 
@@ -31,18 +40,21 @@ export function presenceOfClient(client: object): ReactivePresence {
 }
 
 export function createPresence(
-  transport: PresenceProjectionEvents | null = null,
+  transport: PresenceTransport | null = null,
 ): AttachablePresence {
   let projection: PresenceProjection | null = null;
+  let attachedTransport: PresenceTransport | null = null;
   const listeners = new Set<() => void>();
+  const reads = new Set<ReadActivityLifetime>();
   let unsubscribe: (() => void) | null = null;
 
   const notify = (): void => {
     for (const listener of listeners) listener();
   };
 
-  const attach = (events: PresenceProjectionEvents): void => {
+  const attach = (events: PresenceTransport): void => {
     if (projection !== null) return;
+    attachedTransport = events;
     projection = createPresenceProjection(events);
     unsubscribe = projection.subscribe(notify);
     notify();
@@ -58,14 +70,31 @@ export function createPresence(
       return () => { listeners.delete(listener); };
     },
     attach,
+    startRead(target) {
+      if (attachedTransport === null) {
+        throw new Error('presence is not attached to a duplex transport');
+      }
+      const lifetime = startReadActivity(
+        attachedTransport,
+        target,
+        () => { reads.delete(lifetime); },
+      );
+      reads.add(lifetime);
+      return () => {
+        lifetime.stop();
+      };
+    },
     forModel(model, recordId) {
       return projection?.forModel(model, recordId) ?? [];
     },
     dispose() {
+      for (const read of reads) read.dispose();
+      reads.clear();
       unsubscribe?.();
       unsubscribe = null;
       projection?.dispose();
       projection = null;
+      attachedTransport = null;
       listeners.clear();
     },
   };

package/src/presence/readActivity.ts

@@ -0,0 +1,149 @@
+import type {
+  PresenceCommand,
+  PresenceTarget,
+} from '@abloatai/transaction/presence';
+import { LEASE_TTL_MS } from '@abloatai/transaction/wire';
+
+/** The connection slice needed to keep one session-owned read alive. */
+export interface ReadActivityTransport {
+  isConnected(): boolean;
+  sendPresenceCommand(command: PresenceCommand): void;
+  subscribe(event: 'connected', listener: () => void): () => void;
+}
+
+export interface ReadActivityLifetime {
+  /** End the read and remove it from the server, reconnecting briefly if needed. */
+  stop(): void;
+  /** Tear down local resources when the owning client itself is disposed. */
+  dispose(): void;
+}
+
+const READ_TTL_MS = LEASE_TTL_MS;
+const READ_REFRESH_MS = READ_TTL_MS / 3;
+let fallbackActivitySequence = 0;
+const noop = (): void => undefined;
+
+function readActivityId(): string {
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+    return `read:${crypto.randomUUID()}`;
+  }
+  fallbackActivitySequence += 1;
+  return `read:${Date.now().toString(36)}:${fallbackActivitySequence.toString(36)}`;
+}
+
+function unref(timer: ReturnType<typeof setTimeout>): void {
+  const candidate: unknown = timer;
+  if (
+    typeof candidate === 'object' &&
+    candidate !== null &&
+    'unref' in candidate &&
+    typeof candidate.unref === 'function'
+  ) {
+    (candidate as { unref(): void }).unref();
+  }
+}
+
+/**
+ * Own the lease mechanics for one declared read. React only starts and stops
+ * this lifetime; command ids, refreshes, reconnect recovery, and offline
+ * cleanup remain inside the presence subsystem.
+ */
+export function startReadActivity(
+  transport: ReadActivityTransport,
+  target: PresenceTarget,
+  onFinished: () => void = noop,
+): ReadActivityLifetime {
+  const activityId = readActivityId();
+  let active = true;
+  let disposed = false;
+  let removeOnConnect: (() => void) | null = null;
+  let removalExpiry: ReturnType<typeof setTimeout> | null = null;
+  let finished = false;
+
+  const finish = (): void => {
+    if (finished) return;
+    finished = true;
+    onFinished();
+  };
+
+  const send = (command: PresenceCommand): boolean => {
+    if (!transport.isConnected()) return false;
+    try {
+      transport.sendPresenceCommand(command);
+      return true;
+    } catch (error) {
+      // The socket can close between the state check and the synchronous send.
+      // Reconnect handling retries; a failure while still connected is real.
+      if (transport.isConnected()) throw error;
+      return false;
+    }
+  };
+
+  const upsert = (): void => {
+    if (!active || disposed) return;
+    send({ type: 'read.upsert', activityId, target, ttlMs: READ_TTL_MS });
+  };
+
+  const unsubscribeConnected = transport.subscribe('connected', upsert);
+  upsert();
+
+  const refreshTimer = setInterval(() => {
+    if (!active || disposed) return;
+    send({ type: 'read.refresh', activityId, ttlMs: READ_TTL_MS });
+  }, READ_REFRESH_MS);
+  unref(refreshTimer);
+
+  const clearResources = (): void => {
+    unsubscribeConnected();
+    clearInterval(refreshTimer);
+    removeOnConnect?.();
+    removeOnConnect = null;
+    if (removalExpiry !== null) clearTimeout(removalExpiry);
+    removalExpiry = null;
+  };
+
+  const stop = (): void => {
+    if (!active || disposed) return;
+    active = false;
+    unsubscribeConnected();
+    clearInterval(refreshTimer);
+
+    const remove = (): void => {
+      if (disposed) return;
+      if (!send({ type: 'read.remove', activityId })) return;
+      removeOnConnect?.();
+      removeOnConnect = null;
+      if (removalExpiry !== null) clearTimeout(removalExpiry);
+      removalExpiry = null;
+      finish();
+    };
+
+    if (transport.isConnected()) {
+      remove();
+      return;
+    }
+
+    // If the component leaves offline, remove on the next reconnect so the
+    // resumed logical session cannot briefly show a departed viewer. Once the
+    // lease expires server-side, there is nothing left to remove.
+    removeOnConnect = transport.subscribe('connected', remove);
+    removalExpiry = setTimeout(() => {
+      removeOnConnect?.();
+      removeOnConnect = null;
+      removalExpiry = null;
+      finish();
+    }, READ_TTL_MS);
+    unref(removalExpiry);
+  };
+
+  return {
+    stop,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      active = false;
+      clearResources();
+      finish();
+    },
+  };
+}

package/src/react/AbloProvider.tsx

@@ -22,24 +22,8 @@ import { useSyncStatus } from './useSyncStatus.js';
 import { DefaultFallback } from './DefaultFallback.js';
 import { presenceOfClient } from '../presence/index.js';
 
-/**
- * Ablo umbrella provider — owns the sync engine, multiplayer, and
- * the full lifecycle (Strict-Mode-safe singleton, `beforeunload`,
- * session-expiry handling, post-bootstrap hooks).
- *
- * Design goals:
- *
- *   - **One component, one import.** Consumers write the provider
- *     once at the root; nothing else needs to plumb the engine.
- *   - **Multiplayer is default.** React consumers share the client's scoped
- *     groups, presence stream, and model surface without another join step.
- *   - **Declarative props for app glue.** `preventUnsavedChanges`,
- *     `onSessionExpired`, `postBootstrap`, `resolveUsers` — each
- *     absorbs a class of integration code that previously lived in
- *     userland.
- *   - **Singleton safety.** The engine lives in a ref and rotates
- *     only when `userId` / account scope / `url` change. React
- *     Strict Mode double-mount does not leak a second WebSocket.
+/** Reactive binding over an application-owned client. Starts readiness,
+ * forwards errors and gates bootstrap; the application owns client disposal.
  */
 
 // ── Props ────────────────────────────────────────────────────────────
@@ -182,7 +166,7 @@ export function AbloProvider<R extends SchemaRecord = SchemaRecord>(
 
   // 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<string | null>(null);
+  const [resolvedScope, setResolvedScope] = useState<{ engine: typeof engine; account: string | null } | null>(null);
 
   // ── Error emitter (provider-instance scoped) ─────────────────────
   const errorEmitterRef = useRef<ReturnType<typeof createErrorEmitter> | null>(null);
@@ -240,9 +224,10 @@ export function AbloProvider<R extends SchemaRecord = SchemaRecord>(
       .ready()
       .then(() => {
         if (stale) return;
-        setResolvedAccountScope(
-          (engine._store as SyncStoreContract & { orgId?: string }).orgId ?? null,
-        );
+        setResolvedScope({
+          engine,
+          account: (engine._store as SyncStoreContract & { orgId?: string }).orgId ?? null,
+        });
       })
       .catch((err) => {
         if (stale) return;
@@ -280,7 +265,7 @@ export function AbloProvider<R extends SchemaRecord = SchemaRecord>(
   // then, which drives the initial fallback below.
   const syncValue = useMemo(() => {
     const currentAccountScope =
-      resolvedAccountScope ??
+      (resolvedScope?.engine === engine ? resolvedScope.account : null) ??
       (engine._store as SyncStoreContract & { orgId?: string }).orgId;
     if (!currentAccountScope) return null;
     return {
@@ -288,7 +273,7 @@ export function AbloProvider<R extends SchemaRecord = SchemaRecord>(
       organizationId: currentAccountScope,
       schema,
     };
-  }, [engine, resolvedAccountScope, schema]);
+  }, [engine, resolvedScope, schema]);
 
   // ── Internal context (currentUserId + error subscription) ────────
 
@@ -301,44 +286,20 @@ export function AbloProvider<R extends SchemaRecord = SchemaRecord>(
 
   // ── 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 (
-      <AbloInternalContext.Provider value={internalValue}>
-        {initialFallback}
-      </AbloInternalContext.Provider>
-    );
-  }
 
   return (
     <AbloInternalContext.Provider value={internalValue}>
       <SyncContext.Provider value={syncValue}>
         {passthrough ? (
           children
-        ) : (
+        ) : syncValue ? (
           <BootstrapGate key={engineKey} fallback={fallback}>
             {children}
           </BootstrapGate>
-        )}
+        ) : fallback}
       </SyncContext.Provider>
     </AbloInternalContext.Provider>
   );
@@ -352,8 +313,7 @@ export function AbloProvider<R extends SchemaRecord = SchemaRecord>(
  * 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({

package/src/react/createAbloReact.ts

@@ -29,6 +29,7 @@ import {
 } from './AbloProvider.js';
 import {
   useAbloImpl,
+  useAbloClientImpl,
   type AbloSelector,
   type ModelClientSelector,
   type UseAbloHydratedModelResult,
@@ -38,6 +39,11 @@ import {
 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 {
+  usePresenceImpl,
+  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> {
@@ -60,6 +66,11 @@ export interface AbloReactBinding<S extends SchemaRecord> {
       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[];
 }
 
 /**
@@ -112,5 +123,18 @@ export function createAbloReact<S extends SchemaRecord>(
     return useAbloImpl<S, T, C>(bound, modelOrSelect, id, options);
   }
 
-  return { AbloProvider: BoundAbloProvider, useAblo: useBoundAblo };
+  function useBoundPresence<T, C>(
+    modelOrSelect: ModelOperations<T, C> | PresenceModelSelector<S, T, C>,
+    recordId: string,
+  ): readonly PresenceSession[] {
+    const bound = useContext(BoundClientContext);
+    const engine = useAbloClientImpl(bound);
+    return usePresenceImpl(engine, modelOrSelect, recordId);
+  }
+
+  return {
+    AbloProvider: BoundAbloProvider,
+    useAblo: useBoundAblo,
+    usePresence: useBoundPresence,
+  };
 }

package/src/react/useAblo.ts

@@ -144,7 +144,7 @@ function snapshotValue<T>(value: T): T {
  * // 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']>();
@@ -223,12 +223,7 @@ export function useAbloImpl<
   id?: string,
   options?: UseAbloModelOptions<T>,
 ): Ablo<R> | null | UseAbloModelResult<T> | T | undefined {
-  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: Ablo<R> | null =
-    boundClient ?? (ctx?.engine ? rebindEngine<R>(ctx.engine) : null);
+  const engine = useAbloClientImpl(boundClient);
   const initial = options?.initial;
   const isSelectorOnly = typeof modelOrSelect === 'function' && id === undefined;
   const modelClient: ModelOperations<T, C> | undefined =
@@ -242,12 +237,9 @@ export function useAbloImpl<
 
   // 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) return;
@@ -278,3 +270,16 @@ export function useAbloImpl<
   if (modelOrSelect) return modelResult;
   return engine;
 }
+
+/** @internal Resolve the bound or legacy provider client through one rebind seam. */
+export function useAbloClientImpl<R extends SchemaRecord>(
+  boundClient: Ablo<R> | null,
+): Ablo<R> | null {
+  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: Ablo<R> | null =
+    boundClient ?? (ctx?.engine ? rebindEngine<R>(ctx.engine) : null);
+  return engine;
+}