@abloatai/humans 0.64.0 → 0.64.1

package/dist/react/useMutators.d.ts

@@ -1,7 +1,7 @@
 import type { Schema } from '@abloatai/transaction/schema/schema';
 import type { MutatorDefs } from '../local/mutators/defineMutators.js';
 import type { UndoScope } from '../local/mutators/UndoManager.js';
-import type { ResolveSchema } from '@abloatai/transaction/types/global';
+import type { ResolveSchema, RequireRegisteredSchema } from '@abloatai/transaction/types/global';
 /**
  * Turns a mutator tree built with `defineMutators` into callable invokers. The
  * returned object mirrors that tree one-to-one, but each leaf becomes an
@@ -37,9 +37,9 @@ export type InvokerFor<F> = F extends (options: infer O) => Promise<infer R> ? O
 /** Mutator invokers (explicit schema arg). */
 export declare function useMutators<S extends Schema, M extends MutatorDefs<S>>(schema: S, mutators: M, options?: useMutators.Options<S>): useMutators.Result<M>;
 /** Mutator invokers via the `Register` module augmentation. Schema comes
- * from the `SyncProvider`'s context; the mutator tree is typed against
+ * from the `AbloProvider` store context; the mutator tree is typed against
  * `ResolveSchema` at the call site. */
-export declare function useMutators<M extends ResolveSchema extends Schema ? MutatorDefs<ResolveSchema> : MutatorDefs<Schema>>(mutators: M, options?: useMutators.Options<ResolveSchema extends Schema ? ResolveSchema : Schema>): useMutators.Result<M>;
+export declare function useMutators<M extends ResolveSchema extends Schema ? MutatorDefs<ResolveSchema> : MutatorDefs<Schema>>(mutators: RequireRegisteredSchema<M>, options?: useMutators.Options<ResolveSchema extends Schema ? ResolveSchema : Schema>): useMutators.Result<M>;
 /** Optional annotations for custom mutation bindings. */
 export declare namespace useMutators {
     type Result<M> = {

package/dist/react/useMutators.js

@@ -2,11 +2,11 @@
 import { useMemo } from 'react';
 import { createTransaction } from '../local/mutators/Transaction.js';
 import { createRecordingMutation } from '../local/mutators/RecordingMutation.js';
-import { useSyncContext } from './context.js';
+import { useAbloStoreContext } from './context.js';
 import { AbloValidationError } from '@abloatai/transaction/errors';
 import { getContext } from '../local/context.js';
 export function useMutators(schemaOrMutators, mutatorsOrOptions, maybeOptions) {
-    const { store, organizationId, schema: ctxSchema } = useSyncContext();
+    const { store, organizationId, schema: ctxSchema } = useAbloStoreContext();
     // Disambiguate: explicit-schema path has the schema object in first slot;
     // the global-resolved path has the mutator tree there. A schema object
     // has a `.models` property; a mutator tree doesn't.
@@ -19,7 +19,7 @@ export function useMutators(schemaOrMutators, mutatorsOrOptions, maybeOptions) {
     if (!schema) {
         throw new AbloValidationError('useMutators: no schema available. Pass the schema as the first arg, ' +
             'or build the <AbloProvider> above with `Ablo({ schema })` so the ' +
-            'zero-arg overload can read it from context.', { code: 'mutators_schema_missing' });
+            'schema-free overload can read it from context.', { code: 'mutators_schema_missing' });
     }
     const { undoScope } = options ?? {};
     return useMemo(() => {

package/dist/react/usePresence.d.ts

@@ -2,18 +2,18 @@ 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;
+import type { ResolveModels as DefaultModels } from '@abloatai/transaction/types/global';
 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 {};
+export declare function usePresence<T, C>(modelClient: ModelOperations<T, C>, recordId: string, options?: usePresence.Options): readonly PresenceSession[];
+export declare function usePresence<R extends SchemaRecord = DefaultModels, T = Record<string, unknown>, C = unknown>(select: PresenceModelSelector<R, T, C>, recordId: string, options?: usePresence.Options): readonly PresenceSession[];
+export declare namespace usePresence {
+    interface Bound<S extends SchemaRecord> {
+        <T, C>(model: ModelOperations<T, C> | PresenceModelSelector<S, T, C>, recordId: string, options?: Options): readonly PresenceSession[];
+    }
+    type Options = import('@abloatai/transaction/presence').PresenceQueryOptions;
+}

package/dist/react/usePresence.js

@@ -2,14 +2,10 @@
 import { useCallback, useEffect } from 'react';
 import { AbloValidationError } from '@abloatai/transaction/errors';
 import { getModelClientMeta, } from '../local/client/createModelOperations.js';
-import { useAbloClient } from './useAblo.js';
+import { useAbloClient } from './useAbloClient.js';
 import { useReactive } from './useReactive.js';
-export function usePresence(modelOrSelect, recordId) {
+export function usePresence(modelOrSelect, recordId, options) {
     const engine = useAbloClient();
-    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' });
     }
@@ -23,7 +19,7 @@ export function usePresenceImpl(engine, modelOrSelect, recordId) {
         throw new AbloValidationError('usePresence requires a model from the reactive Ablo client.', { code: 'invalid_request', param: 'modelClient' });
     }
     const subscribe = useCallback((notify) => presence?.subscribe(notify) ?? (() => undefined), [presence]);
-    const sessions = useReactive(() => presence?.get(recordId) ?? [], { subscribe });
+    const sessions = useReactive(() => presence?.get(recordId, options) ?? [], { subscribe });
     useEffect(() => presence?.read(recordId), [presence, recordId]);
     return sessions;
 }

package/dist/react/useUndoScope.d.ts

@@ -1,10 +1,10 @@
 import type { Schema } from '@abloatai/transaction/schema/schema';
 import { type UndoScope, type UndoScopeOptions } from '../local/mutators/UndoManager.js';
-import type { ResolveSchema } from '@abloatai/transaction/types/global';
+import type { ResolveSchema, RequireRegisteredSchema } from '@abloatai/transaction/types/global';
 /** Per-surface undo/redo (explicit schema arg). */
 export declare function useUndoScope<S extends Schema>(schema: S, name: string, options?: UndoScopeOptions): useUndoScope.Result<S>;
 /** Per-surface undo/redo via the `Register` module augmentation. */
-export declare function useUndoScope(name: string, options?: UndoScopeOptions): useUndoScope.Result<ResolveSchema extends Schema ? ResolveSchema : Schema>;
+export declare function useUndoScope(name: RequireRegisteredSchema<string>, options?: UndoScopeOptions): useUndoScope.Result<ResolveSchema extends Schema ? ResolveSchema : Schema>;
 /** The state returned by an undo scope; inferred for ordinary hook calls. */
 export declare namespace useUndoScope {
     interface Result<S extends Schema> {

package/dist/react/useUndoScope.js

@@ -1,7 +1,7 @@
 'use client';
 import { useEffect, useMemo, useState } from 'react';
 import { UndoManager, } from '../local/mutators/UndoManager.js';
-import { useSyncContext } from './context.js';
+import { useAbloStoreContext } from './context.js';
 import { AbloValidationError } from '@abloatai/transaction/errors';
 /**
  * Provides per-surface undo and redo for mutator invocations. Each named scope
@@ -21,7 +21,7 @@ import { AbloValidationError } from '@abloatai/transaction/errors';
  * useHotkey('mod+z', () => { if (canUndo) void undo(); });
  */
 // Module-level weak registry: `SyncStoreContract` → `UndoManager`.
-// A single app wiring through one SyncProvider shares one manager across
+// A single AbloProvider shares one manager across
 // every useUndoScope call, so scopes with the same name are identity-equal.
 // The hook implementation already operates on the runtime-wide `Schema` type;
 // its overloads restore the caller's precise schema type at the public boundary,
@@ -37,7 +37,7 @@ function getManager(key, factory) {
     return m;
 }
 export function useUndoScope(schemaOrName, nameOrOptions, maybeOptions) {
-    const { store, organizationId, schema: ctxSchema } = useSyncContext();
+    const { store, organizationId, schema: ctxSchema } = useAbloStoreContext();
     const isExplicit = typeof schemaOrName !== 'string';
     const schema = isExplicit ? (schemaOrName) : ctxSchema;
     const name = isExplicit ? nameOrOptions : schemaOrName;
@@ -48,7 +48,7 @@ export function useUndoScope(schemaOrName, nameOrOptions, maybeOptions) {
             'zero-arg overload can read it from context.', { code: 'undo_scope_schema_missing' });
     }
     const scope = useMemo(() => {
-        // Store is the identity for the manager — one per SyncProvider.
+        // Store is the identity for the manager — one per AbloProvider.
         const manager = getManager(store, () => new UndoManager(schema, store, organizationId));
         return manager.getScope(name, options);
         // eslint-disable-next-line react-hooks/exhaustive-deps

package/dist/react.d.ts

@@ -2,6 +2,8 @@
 export { AbloProvider } from './react/AbloProvider.js';
 export { createAbloReact } from './react/createAbloReact.js';
 export { useAblo } from './react/useAblo.js';
+export { useAbloClient } from './react/useAbloClient.js';
+export { useMutationFailure } from './react/useMutationFailure.js';
 export { usePresence } from './react/usePresence.js';
 export { useMutators } from './react/useMutators.js';
 export { useUndoScope } from './react/useUndoScope.js';

package/dist/react.js

@@ -2,6 +2,8 @@
 export { AbloProvider } from './react/AbloProvider.js';
 export { createAbloReact } from './react/createAbloReact.js';
 export { useAblo } from './react/useAblo.js';
+export { useAbloClient } from './react/useAbloClient.js';
+export { useMutationFailure } from './react/useMutationFailure.js';
 export { usePresence } from './react/usePresence.js';
 export { useMutators } from './react/useMutators.js';
 export { useUndoScope } from './react/useUndoScope.js';

package/dist/reactRuntime.d.ts

@@ -1,4 +1,4 @@
 export { AbloInternalContext, type AbloInternalContextValue, } from './react/internalContext.js';
-export { useSyncContext, type SyncReactContext, } from './react/context.js';
+export { useAbloStoreContext, type AbloStoreContextValue, } from './react/context.js';
 export type { SyncStoreContract } from './local/storeContract.js';
 export type { QueuedMutation } from './local/transactions/mutations/MutationQueue.js';

package/dist/reactRuntime.js

@@ -1,2 +1,2 @@
 export { AbloInternalContext, } from './react/internalContext.js';
-export { useSyncContext, } from './react/context.js';
+export { useAbloStoreContext, } from './react/context.js';

package/package.json

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

package/src/Ablo.ts

@@ -267,6 +267,7 @@ export namespace Ablo {
   /** Payload delivered by the core client's onMutationFailure subscription. */
   export type MutationFailure = Parameters<Parameters<AbloClient<SchemaRecord>['onMutationFailure']>[0]>[0];
   /** Current client lifecycle, also selected through React's useAblo. */
+  export type Store = import('./local/storeContract.js').SyncStoreContract;
   export type Status = import('./local/client/status.js').ClientStatus;
 
   // ── Factory options ────────────────────────────────────────────────
@@ -320,6 +321,7 @@ export namespace Ablo {
    * different schemas.
    */
   export type ResolveSchema = _Global.ResolveSchema;
+  export type ResolveClaimMeta = _Global.ResolveClaimMeta;
   /**
    * `ResolveSchema` guaranteed to satisfy the `Schema` bound. `ResolveSchema`
    * falls back to a loose `{ models }` shape when nothing is registered, which

package/src/client.ts

@@ -256,7 +256,7 @@ interface AbloCore<S extends SchemaRecord> {
 
   /**
    * The internal store. It implements {@link SyncStoreContract} — pass it to
-   * `SyncContext.Provider` so the SDK's `useModel` / `useModels` / `useMutations`
+   * `AbloStoreContext.Provider` so the SDK's React data hooks
    * hooks can reach it.
    */
   readonly _store: SyncStoreContract;

package/src/index.ts

@@ -39,3 +39,5 @@ export {
 export type {
   CommitLatencySample,
 } from './local/transactions/mutations/commitLatency.js';
+
+export { getAbloStore } from './local/storeAccess.js';

package/src/local/client/createModelOperations.ts

@@ -143,7 +143,7 @@ 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 { PresenceSession, PresenceQueryOptions } from '@abloatai/transaction/presence';
 import type {
   CollaborationEventContext,
   ModelEventEnvelope,
@@ -165,7 +165,7 @@ export interface ModelClientMeta {
   readonly key: string;
   readonly typename: string;
   readonly presence?: {
-    get(recordId: string): readonly PresenceSession[];
+    get(recordId: string, options?: PresenceQueryOptions): readonly PresenceSession[];
     subscribe(listener: () => void): () => void;
     read(recordId: string): () => void;
   };
@@ -192,7 +192,7 @@ type EntityHalf = Pick<ModelTarget, 'model' | 'id'>;
 // while reading as though they differed.
 export interface ModelCollaboration {
   /** Session projections already held by this client's one presence store. */
-  presence(model: string, recordId?: string): readonly PresenceSession[];
+  presence(model: string, recordId?: string, options?: PresenceQueryOptions): readonly PresenceSession[];
   /** Subscribe once to the connection-owned presence projection. */
   onPresenceChange(listener: () => void): () => void;
   /** Start one session-owned read activity and return its cleanup. */
@@ -1784,7 +1784,7 @@ export function createModelOperations<T, C>(
     ...(collaboration
       ? {
           presence: {
-            get: (recordId: string) => collaboration.presence(registeredModelName, recordId),
+            get: (recordId, options) => collaboration.presence(registeredModelName, recordId, options),
             subscribe: (listener: () => void) => collaboration.onPresenceChange(listener),
             read: (recordId: string) => {
               const scope = { [schemaKey]: recordId };

package/src/local/client/reactiveEngine.ts

@@ -576,7 +576,7 @@ export function buildReactiveEngine<const S extends SchemaRecord>(
       modelRegistry,
       hydration,
       {
-        presence: (model, recordId) => presenceStream.forModel(model, recordId),
+        presence: (model, recordId, options) => presenceStream.forModel(model, recordId, options),
         onPresenceChange: (listener) => presenceStream.onChange(listener),
         startReadPresence: (target) => presenceStream.startRead(target),
         modelEventTarget: (recordId) => {
@@ -857,11 +857,11 @@ export function buildReactiveEngine<const S extends SchemaRecord>(
 
     // ── Internal accessors for framework integration ─────────────────
     // These expose internal components for consumers that need direct
-    // access (e.g., SyncEngineProvider wiring SyncContext, collaboration
+    // access (e.g., AbloProvider wiring its store context, collaboration
     // events accessing the WebSocket handle, demand loaders accessing
     // the pool). Prefixed with _ to signal "internal but stable."
 
-    /** The BaseSyncedStore — implements SyncStoreContract for SyncContext.Provider. */
+    /** The BaseSyncedStore — implements SyncStoreContract for AbloStoreContext.Provider. */
     get _store() { return store; },
 
     /** The InstanceCache — for demand loaders that need pool.createFromData(). */

package/src/local/mutators/defineMutators.ts

@@ -1,76 +1,28 @@
-/**
- * Declares a tree of named custom mutators grouped by model key. Each mutator is
- * a plain async function that receives `{ tx, args }` and composes any number of
- * `tx.mutations.*` and `tx.read.*` calls to carry out a named operation, such as
- * `sections.createWithBlocks`.
- *
- * The function is purely a place for types to anchor and returns its input
- * unchanged; the runtime that dispatches a mutator lives elsewhere — the
- * transaction object it receives and the React hook that invokes it. Because
- * `defineMutators(schema, { ... })` returns the exact object you wrote,
- * `typeof mutators` carries every mutator's precise `args` and result types
- * through to wherever they are invoked.
- */
-
+/** Define typed named operations. Pass the schema explicitly across package boundaries. */
 import type { Schema } from '@abloatai/transaction/schema/schema';
 import type { Transaction } from './Transaction.js';
-import type { ResolveSchema } from '@abloatai/transaction/types/global';
+import type { ResolveSchema, RequireRegisteredSchema } from '@abloatai/transaction/types/global';
 
-/**
- * `ResolveSchema` narrowed to satisfy the `Schema` bound — mirrors
- * {@link Ablo.RegisteredSchema}. When nothing is registered, `ResolveSchema`
- * is a loose `{ models }` shape that doesn't extend `Schema`, so we fall back
- * to `Schema` to keep the mutator tree typed rather than collapsing.
- */
 type RegisteredSchema = ResolveSchema extends Schema ? ResolveSchema : Schema;
 
-/**
- * The signature of a single custom mutator. The engine supplies `tx`; you control
- * `args`, in whatever shape you like, and the resolved return value. `TArgs` and
- * `TResult` are bounded by `unknown` rather than `any`, so a mixed tree of
- * mutators can be typed together without falling back to `any`.
- */
 export type MutatorFn<S extends Schema, TArgs, TResult = void> = (
   options: { tx: Transaction<S>; args: TArgs },
 ) => Promise<TResult>;
 
-/**
- * The shape {@link defineMutators} accepts: an optional record per model key
- * whose values are named mutator functions. The `unknown` bounds keep the public
- * boundary type-safe without `any`; when you write your mutators inline,
- * TypeScript still infers the concrete `args` and result of each function, so the
- * `unknown` here is only a ceiling, not what you end up working with.
- */
 export type MutatorDefs<S extends Schema> = {
   [K in keyof S['models']]?: Record<string, MutatorFn<S, never, unknown>>;
 };
 
-/**
- * Returns the mutators object unchanged while constraining its shape against the
- * schema. The `S` generic pins the model keys, and the `M` generic is inferred as
- * a `const`, so each mutator's literal signature survives. There is no runtime
- * work here; the function exists purely as a place for type inference to anchor.
- */
 export function defineMutators<
   S extends Schema,
   const M extends MutatorDefs<S>,
 >(_schema: S, mutators: M): M;
-/**
- * Register-anchored overload: omit the schema value and the tree is typed
- * against `ResolveSchema` (this app's registered schema). Shared product code
- * used across apps that bind different schemas should use this form — it moves
- * with each app's `Register` instead of pinning one concrete schema, so the
- * mutator tree stays assignable at every consumer (which reads the same
- * `Register`). See docs/plans/per-product-schema-projections.md.
- */
 export function defineMutators<const M extends MutatorDefs<RegisteredSchema>>(
-  mutators: M,
+  mutators: RequireRegisteredSchema<M>,
 ): M;
 export function defineMutators(
   schemaOrMutators: Schema | MutatorDefs<Schema>,
   maybeMutators?: MutatorDefs<Schema>,
 ): MutatorDefs<Schema> {
-  // The schema argument is a type anchor only — never read at runtime. With one
-  // argument the mutator tree is in the first slot; with two it's in the second.
   return (maybeMutators ?? schemaOrMutators) as MutatorDefs<Schema>;
 }

package/src/local/storeAccess.ts

@@ -0,0 +1,10 @@
+import type { AbloClient } from '../client.js';
+import type { SchemaRecord } from '@abloatai/transaction/schema/schema';
+import type { SyncStoreContract } from './storeContract.js';
+
+/** Access the supported local store contract for custom framework adapters,
+ * demand loading, scope management and custom undo infrastructure.
+ */
+export function getAbloStore<S extends SchemaRecord>(client: AbloClient<S>): SyncStoreContract {
+  return client._store;
+}

package/src/presence/index.ts

@@ -4,6 +4,7 @@ import {
   type PresenceProjection,
   type PresenceProjectionEvents,
   type PresenceView,
+  type PresenceQueryOptions,
 } from '@abloatai/transaction/presence';
 import type { PresenceTarget } from '@abloatai/transaction/presence';
 import {
@@ -16,7 +17,7 @@ type PresenceTransport = PresenceProjectionEvents & ReadActivityTransport;
 
 /** Reactive-client presence backed by the client's existing live connection. */
 export interface ReactivePresence extends PresenceView {
-  forModel(model: string, recordId?: string): ReturnType<PresenceProjection['forModel']>;
+  forModel(model: string, recordId?: string, options?: PresenceQueryOptions): ReturnType<PresenceProjection['forModel']>;
   onChange(listener: () => void): () => void;
 }
 
@@ -87,9 +88,9 @@ export function createPresence(
         lifetime.stop();
       };
     },
-    forModel(model, recordId) {
+    forModel(model, recordId, options) {
       version.get();
-      return projection?.forModel(model, recordId) ?? [];
+      return projection?.forModel(model, recordId, options) ?? [];
     },
     dispose() {
       for (const read of reads) read.dispose();

package/src/react/AbloProvider.tsx

@@ -11,7 +11,7 @@ import {
 } from 'react';
 import type { Schema, SchemaRecord } from '@abloatai/transaction/schema/schema';
 import type { AbloClient as Ablo } from '../client.js';
-import { SyncContext, type SyncStoreContract } from './context.js';
+import { AbloStoreContext, type SyncStoreContract } from './context.js';
 import { AbloInternalContext, type AbloInternalContextValue } from './internalContext.js';
 import { AbloValidationError } from '@abloatai/transaction/errors';
 import { useAblo } from './useAblo.js';
@@ -100,7 +100,7 @@ export function AbloProvider<R extends SchemaRecord = SchemaRecord>(
   //      onSessionExpired. Credential cleanup lives in the CLIENT, so direct
   //      consumers and React consumers have the same security boundary.
   //   2. Drive `ready()` (idempotent) so bootstrap starts on mount, then read the
-  //      resolved org scope for SyncContext.
+  //      resolved org scope for the Ablo store context.
   // It does NOT dispose the client (consumer-owned) and does NOT touch auth.
   useEffect(() => {
     let stale = false;
@@ -158,12 +158,12 @@ export function AbloProvider<R extends SchemaRecord = SchemaRecord>(
     return () => { window.removeEventListener('beforeunload', handler); };
   }, [engine, preventUnsavedChanges]);
 
-  // ── SyncContext value (for useQuery/useOne/useMutate hooks) ──────
+  // ── Store context value (for Ablo data hooks) ────────────────────
   //
   // The engine is always present (it's the `client` prop), but its org scope is
-  // unknown until `ready()` resolves identity — so `syncValue` is null until
+  // unknown until `ready()` resolves identity — so the store context is null until
   // then, which drives the initial fallback below.
-  const syncValue = useMemo(() => {
+  const storeContextValue = useMemo(() => {
     const currentAccountScope =
       (resolvedScope?.engine === engine ? resolvedScope.account : null) ??
       (engine._store as SyncStoreContract & { orgId?: string }).orgId;
@@ -189,15 +189,15 @@ export function AbloProvider<R extends SchemaRecord = SchemaRecord>(
 
   return (
     <AbloInternalContext.Provider value={internalValue}>
-      <SyncContext.Provider value={syncValue}>
+      <AbloStoreContext.Provider value={storeContextValue}>
         {passthrough ? (
           children
-        ) : syncValue ? (
+        ) : storeContextValue ? (
           <BootstrapGate key={engineKey} fallback={fallback}>
             {children}
           </BootstrapGate>
         ) : fallback}
-      </SyncContext.Provider>
+      </AbloStoreContext.Provider>
     </AbloInternalContext.Provider>
   );
 }

package/src/react/context.ts

@@ -1,6 +1,6 @@
 'use client';
 
-import { createContext, createElement, useContext, type ReactNode } from 'react';
+import { createContext, useContext } from 'react';
 import type { Schema } from '@abloatai/transaction/schema/schema';
 import type { SyncStoreContract } from '../local/storeContract.js';
 import { AbloValidationError } from '@abloatai/transaction/errors';
@@ -13,77 +13,26 @@ export type {
   LocalMutation,
 } from '../local/storeContract.js';
 
-export interface SyncReactContext {
+export interface AbloStoreContextValue {
   store: SyncStoreContract;
   /** The organization id used as the default scope for reads and writes. */
   organizationId: string;
-  /**
-   * An optional schema. When provided, hooks that take a model by name (such as
-   * `useQuery('items')`) read that model's metadata from this schema, so
-   * callers don't pass a schema at every call site. When omitted, those hooks
-   * require the schema as an argument instead.
-   *
-   * The field is loosely typed here because a single runtime context value is
-   * shared by every hook. Precise per-model types come from your `Register`
-   * module augmentation
-   * (`declare module '@abloatai/ablo' { interface Register { Schema: typeof schema } }`),
-   * not from this reference.
-   */
+  /** Runtime schema used by ambient mutator overloads. */
   schema?: Schema;
 }
 
-export const SyncContext = createContext<SyncReactContext | null>(null);
+export const AbloStoreContext = createContext<AbloStoreContextValue | null>(null);
 
 /**
- * Reads the sync store context from inside a provider subtree, throwing a clear
- * error when no provider is mounted above. `<AbloProvider>` supplies this
- * context by rendering the internal {@link SyncProvider}; you wire
- * `<AbloProvider client={ablo}>` rather than touching this directly.
+ * Reads the store scope owned by `<AbloProvider>`, throwing a clear error when
+ * no provider is mounted above it.
  */
-export function useSyncContext(): SyncReactContext {
-  const ctx = useContext(SyncContext);
+export function useAbloStoreContext(): AbloStoreContextValue {
+  const ctx = useContext(AbloStoreContext);
   if (!ctx) {
-    throw new AbloValidationError('Sync hooks must be used within an <AbloProvider>.', {
-      code: 'sync_context_missing_provider',
+    throw new AbloValidationError('Ablo hooks must be used within an <AbloProvider>.', {
+      code: 'ablo_context_missing_provider',
     });
   }
   return ctx;
 }
-
-/**
- * Props for SyncProvider.
- */
-export interface SyncProviderProps {
-  /** The sync store, which must implement {@link SyncStoreContract}. */
-  store: SyncStoreContract;
-  /** The organization id used as the default scope for reads and writes. */
-  organizationId: string;
-  /**
-   * An optional schema. Provide it to enable hooks that take a model by name
-   * (such as `useQuery('items')`); the model types also narrow through your
-   * `Register` augmentation. Omit it to pass the schema to those hooks directly
-   * instead.
-   */
-  schema?: Schema;
-  children?: ReactNode;
-}
-
-/**
- * A low-level provider that places a built sync store on React context so the
- * data hooks can reach it. This is an internal building block: it is not part
- * of the package's public entry point. Reach for `<AbloProvider>` instead,
- * which builds the store from your `Ablo({ schema, apiKey })` client and
- * renders this provider underneath.
- */
-export function SyncProvider({
-  store,
-  organizationId,
-  schema,
-  children,
-}: SyncProviderProps) {
-  return createElement(
-    SyncContext.Provider,
-    { value: { store, organizationId, schema } },
-    children
-  );
-}

package/src/react/createAbloReact.ts

@@ -1,47 +1,23 @@
 'use client';
 
-/**
- * Capture schema inference once while reusing module-level React functions.
- * This helper creates no components, hooks, contexts or client instances.
- *
- * Define the app binding at module scope:
- * `export const { AbloProvider, useAblo, usePresence } = createAbloReact(schema)`.
- */
-
 import type { ReactElement } from 'react';
+import { useAbloClient } from './useAbloClient.js';
+import { useMutationFailure } from './useMutationFailure.js';
 import { AbloProvider } from './AbloProvider.js';
-import {
-  useAblo,
-  type AbloSelector,
-  type ModelClientSelector,
-} from './useAblo.js';
+import { useAblo } from './useAblo.js';
 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 { usePresence, type PresenceModelSelector } from './usePresence.js';
-import type { PresenceSession } from '@abloatai/transaction/presence';
+import { usePresence } from './usePresence.js';
 
-/** What a binding returns: the provider and the hook, with `S` fixed. */
+/** Shared provider and hooks specialized to one schema. */
 export interface AbloReactBinding<S extends SchemaRecord> {
-  /** `AbloProvider` with its `client` prop typed `Ablo<S>` — same component,
-   *  no per-app generics. */
   AbloProvider: (props: AbloProvider.Props<S>) => ReactElement;
-  /** `useAblo` with the schema bound — the same overloads as the global
-   *  hook, minus the type arguments. */
-  useAblo: {
-    (): Ablo<S> | null;
-    <T>(select: AbloSelector<S, T>): T | undefined;
-    <T, C>(
-      modelClientOrSelect: ModelOperations<T, C> | ModelClientSelector<S, T, C>,
-      id: string,
-      options?: useAblo.Options<T>,
-    ): useAblo.Result<T>;
-  };
+  useAblo: useAblo.Bound<S>;
+  /** Writable client for actions; useAblo(selector) supplies render snapshots. */
+  useAbloClient: () => Ablo<S> | null;
+  useMutationFailure: typeof useMutationFailure;
   /** 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[];
+  usePresence: usePresence.Bound<S>;
 }
 
 /** Bind the existing React functions to one schema's types. */
@@ -50,10 +26,6 @@ export function createAbloReact<S extends SchemaRecord>(
 ): AbloReactBinding<S> {
   void schema;
 
-  // TypeScript cannot partially specialize the generic overloads, so this
-  // assertion binds their schema parameter. Positive and negative consumer
-  // type tests verify the specialization; no runtime value changes.
-  // Specialize types only. Every binding uses the same module-level functions,
-  // so calling this helper again cannot change component identity or reset state.
-  return { AbloProvider, useAblo, usePresence } as AbloReactBinding<S>;
+  // Specialize the shared functions without creating new contexts or identities.
+  return { AbloProvider, useAblo, useAbloClient, useMutationFailure, usePresence } as AbloReactBinding<S>;
 }