@abloatai/humans 0.63.1 → 0.64.1

package/src/react/useMutators.ts

@@ -9,8 +9,8 @@ import type {
 import { createTransaction } from '../local/mutators/Transaction.js';
 import { createRecordingMutation } from '../local/mutators/RecordingMutation.js';
 import type { UndoScope } from '../local/mutators/UndoManager.js';
-import type { ResolveSchema } from '@abloatai/transaction/types/global';
-import { useSyncContext } from './context.js';
+import type { ResolveSchema, RequireRegisteredSchema } from '@abloatai/transaction/types/global';
+import { useAbloStoreContext } from './context.js';
 import { AbloValidationError } from '@abloatai/transaction/errors';
 import { getContext } from '../local/context.js';
 
@@ -26,7 +26,7 @@ import { getContext } from '../local/context.js';
  * If a mutator throws, the error propagates to the caller and any writes it
  * already dispatched stay in place — there is no automatic rollback. Wrap the
  * call in your own try/catch and issue compensating writes when you need to
- * undo a partial change, or pass an `undoScope` (see {@link UseMutatorsOptions})
+ * undo a partial change, or pass an `undoScope` (see {@link useMutators.Options})
  * to record inverses for undo and redo.
  */
 
@@ -50,45 +50,29 @@ export type InvokerFor<F> = F extends (options: infer O) => Promise<infer R>
  * The hook's return shape: same tree as the input `MutatorDefs`, every leaf
  * rewritten to its invoker form.
  */
-export type MutatorInvokers<M> = {
-  [K in keyof M]: {
-    [N in keyof M[K]]: InvokerFor<M[K][N]>;
-  };
-};
-
-/**
- * Options passed to `useMutators`. When `undoScope` is set, every mutator
- * invocation is wrapped in a `RecordingMutation` and its inverses are
- * pushed to the scope as one undo entry.
- */
-export interface UseMutatorsOptions<S extends Schema> {
-  /** Target undo scope for recording inverses. Omit to disable recording. */
-  undoScope?: UndoScope<S>;
-}
-
 /** Mutator invokers (explicit schema arg). */
 export function useMutators<S extends Schema, M extends MutatorDefs<S>>(
   schema: S,
   mutators: M,
-  options?: UseMutatorsOptions<S>,
-): MutatorInvokers<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 function useMutators<
   M extends ResolveSchema extends Schema ? MutatorDefs<ResolveSchema> : MutatorDefs<Schema>,
 >(
-  mutators: M,
-  options?: UseMutatorsOptions<ResolveSchema extends Schema ? ResolveSchema : Schema>,
-): MutatorInvokers<M>;
+  mutators: RequireRegisteredSchema<M>,
+  options?: useMutators.Options<ResolveSchema extends Schema ? ResolveSchema : Schema>,
+): useMutators.Result<M>;
 
 export function useMutators(
   schemaOrMutators: Schema | MutatorDefs<Schema>,
-  mutatorsOrOptions?: MutatorDefs<Schema> | UseMutatorsOptions<Schema>,
-  maybeOptions?: UseMutatorsOptions<Schema>,
-): MutatorInvokers<MutatorDefs<Schema>> {
-  const { store, organizationId, schema: ctxSchema } = useSyncContext();
+  mutatorsOrOptions?: MutatorDefs<Schema> | useMutators.Options<Schema>,
+  maybeOptions?: useMutators.Options<Schema>,
+): useMutators.Result<MutatorDefs<Schema>> {
+  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
@@ -101,21 +85,21 @@ export function useMutators(
   const schema = isExplicit ? (schemaOrMutators as Schema) : ctxSchema;
   const mutators = (isExplicit ? mutatorsOrOptions : schemaOrMutators) as MutatorDefs<Schema>;
   const options = (isExplicit ? maybeOptions : mutatorsOrOptions) as
-    | UseMutatorsOptions<Schema>
+    | useMutators.Options<Schema>
     | undefined;
 
   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.',
+        'schema-free overload can read it from context.',
       { code: 'mutators_schema_missing' },
     );
   }
 
   const { undoScope } = options ?? {};
 
-  return useMemo<MutatorInvokers<MutatorDefs<Schema>>>(() => {
+  return useMemo<useMutators.Result<MutatorDefs<Schema>>>(() => {
     const out: Record<string, Record<string, (args: unknown) => Promise<unknown>>> = {};
 
     for (const modelKey of Object.keys(mutators)) {
@@ -182,3 +166,23 @@ export function useMutators(
     return out;
   }, [schema, mutators, store, organizationId, undoScope]);
 }
+
+/** Optional annotations for custom mutation bindings. */
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace useMutators {
+  export type Result<M> = {
+    [K in keyof M]: {
+      [N in keyof M[K]]: InvokerFor<M[K][N]>;
+    };
+  };
+
+  /**
+   * Options passed to `useMutators`. When `undoScope` is set, every mutator
+   * invocation is wrapped in a `RecordingMutation` and its inverses are
+   * pushed to the scope as one undo entry.
+   */
+  export interface Options<S extends Schema> {
+    /** Target undo scope for recording inverses. Omit to disable recording. */
+    undoScope?: UndoScope<S>;
+  }
+}

package/src/react/usePresence.ts

@@ -1,6 +1,6 @@
 'use client';
 
-import { useEffect, useState } from 'react';
+import { useCallback, useEffect } from 'react';
 import type { PresenceSession } from '@abloatai/transaction/presence';
 import { AbloValidationError } from '@abloatai/transaction/errors';
 import {
@@ -9,14 +9,9 @@ import {
 } 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';
-import { useAbloClientImpl } from './useAblo.js';
-
-type DefaultModels = ResolveSchema extends { models: infer M }
-  ? M extends SchemaRecord
-    ? M
-    : SchemaRecord
-  : SchemaRecord;
+import type { ResolveModels as DefaultModels } from '@abloatai/transaction/types/global';
+import { useAbloClient } from './useAbloClient.js';
+import { useReactive } from './useReactive.js';
 
 export type PresenceModelSelector<R extends SchemaRecord, T, C> =
   (ablo: Ablo<R>) => ModelOperations<T, C>;
@@ -29,6 +24,7 @@ export type PresenceModelSelector<R extends SchemaRecord, T, C> =
 export function usePresence<T, C>(
   modelClient: ModelOperations<T, C>,
   recordId: string,
+  options?: usePresence.Options,
 ): readonly PresenceSession[];
 export function usePresence<
   R extends SchemaRecord = DefaultModels,
@@ -37,6 +33,7 @@ export function usePresence<
 >(
   select: PresenceModelSelector<R, T, C>,
   recordId: string,
+  options?: usePresence.Options,
 ): readonly PresenceSession[];
 export function usePresence<
   R extends SchemaRecord = DefaultModels,
@@ -45,17 +42,9 @@ export function usePresence<
 >(
   modelOrSelect: ModelOperations<T, C> | PresenceModelSelector<R, T, C>,
   recordId: string,
+  options?: usePresence.Options,
 ): readonly PresenceSession[] {
-  const engine = useAbloClientImpl<R>(null);
-  return usePresenceImpl(engine, modelOrSelect, recordId);
-}
-
-/** @internal Shared by the global hook and schema-bound React factory. */
-export function usePresenceImpl<R extends SchemaRecord, T, C>(
-  engine: Ablo<R> | null,
-  modelOrSelect: ModelOperations<T, C> | PresenceModelSelector<R, T, C>,
-  recordId: string,
-): readonly PresenceSession[] {
+  const engine = useAbloClient<R>();
   if (recordId.length === 0) {
     throw new AbloValidationError(
       'usePresence requires a non-empty record id.',
@@ -75,14 +64,20 @@ export function usePresenceImpl<R extends SchemaRecord, T, C>(
     );
   }
 
-  const [, render] = useState(0);
-
-  useEffect(
-    () => presence?.subscribe(() => { render((version) => version + 1); }),
-    [presence],
-  );
-
+  const subscribe = useCallback((notify: () => void) => presence?.subscribe(notify) ?? (() => undefined), [presence]);
+  const sessions = useReactive(() => presence?.get(recordId, options) ?? [], { subscribe });
   useEffect(() => presence?.read(recordId), [presence, recordId]);
+  return sessions;
+}
+
+export namespace usePresence {
+  export interface Bound<S extends SchemaRecord> {
+    <T, C>(
+      model: ModelOperations<T, C> | PresenceModelSelector<S, T, C>,
+      recordId: string,
+      options?: Options,
+    ): readonly PresenceSession[];
+  }
 
-  return presence?.get(recordId) ?? [];
+  export type Options = import('@abloatai/transaction/presence').PresenceQueryOptions;
 }

package/src/react/useReactive.ts

@@ -0,0 +1,56 @@
+'use client';
+
+import { useEffect, useMemo, useRef, useSyncExternalStore } from 'react';
+import { reaction } from 'mobx';
+import { equalSnapshots, snapshotValue } from './snapshot.js';
+
+interface ObservationOptions<T> {
+  equals?: (a: T, b: T) => boolean;
+  subscribe?: (listener: () => void) => () => void;
+  serverSnapshot?: () => T;
+}
+
+/**
+ * Each render's computation has its own observation. A suspended render cannot
+ * replace the computation used by the committed tree's subscription. Reactions
+ * start only on subscription, so abandoned renders retain no store observers.
+ */
+export function useReactive<T>(compute: () => T, options: ObservationOptions<T> = {}): T {
+  const { equals = equalSnapshots, subscribe, serverSnapshot = compute } = options;
+  const committed = useRef<{ value: T } | null>(null);
+  const observation = useMemo(() => {
+    let cached = committed.current;
+    let server: { value: T } | null = null;
+    const failed = Symbol('selector error');
+    const read = (): T => {
+      const next = snapshotValue(compute());
+      if (cached === null || !equals(cached.value, next)) cached = { value: next };
+      return cached.value;
+    };
+    return {
+      read,
+      readServer: (): T => {
+        server ??= { value: snapshotValue(serverSnapshot()) };
+        return server.value;
+      },
+      subscribe: (notify: () => void): (() => void) => {
+        const stop = reaction(
+          () => {
+            // Notify React of selector failures; React re-reads and delivers the
+            // exception to its error boundary instead of MobX swallowing it.
+            try { return read(); } catch { return failed; }
+          },
+          () => { notify(); },
+        );
+        let stopExternal: (() => void) | undefined;
+        try { stopExternal = subscribe?.(notify); } catch (error) { stop(); throw error; }
+        return () => { stop(); stopExternal?.(); };
+      },
+    };
+  }, [compute, equals, subscribe, serverSnapshot]);
+  // read() recomputes from the actual store, including React's consistency
+  // checks between render and commit, while equal snapshots retain identity.
+  const value = useSyncExternalStore(observation.subscribe, observation.read, observation.readServer);
+  useEffect(() => { committed.current = { value }; }, [value]);
+  return value;
+}

package/src/react/useUndoScope.ts

@@ -7,8 +7,8 @@ import {
   type UndoScope,
   type UndoScopeOptions,
 } from '../local/mutators/UndoManager.js';
-import type { ResolveSchema } from '@abloatai/transaction/types/global';
-import { useSyncContext } from './context.js';
+import type { ResolveSchema, RequireRegisteredSchema } from '@abloatai/transaction/types/global';
+import { useAbloStoreContext } from './context.js';
 import { AbloValidationError } from '@abloatai/transaction/errors';
 
 /**
@@ -29,19 +29,8 @@ import { AbloValidationError } from '@abloatai/transaction/errors';
  * useHotkey('mod+z', () => { if (canUndo) void undo(); });
  */
 
-export interface UseUndoScopeResult<S extends Schema> {
-  /** Pass to `useMutators(..., { undoScope })` to enable recording. */
-  scope: UndoScope<S>;
-  undo: () => Promise<void>;
-  redo: () => Promise<void>;
-  canUndo: boolean;
-  canRedo: boolean;
-  /** Drop history. Use after sync errors / auth context changes. */
-  clear: () => void;
-}
-
 // 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,
@@ -66,20 +55,20 @@ export function useUndoScope<S extends Schema>(
   schema: S,
   name: string,
   options?: UndoScopeOptions,
-): UseUndoScopeResult<S>;
+): useUndoScope.Result<S>;
 
 /** Per-surface undo/redo via the `Register` module augmentation. */
 export function useUndoScope(
-  name: string,
+  name: RequireRegisteredSchema<string>,
   options?: UndoScopeOptions,
-): UseUndoScopeResult<ResolveSchema extends Schema ? ResolveSchema : Schema>;
+): useUndoScope.Result<ResolveSchema extends Schema ? ResolveSchema : Schema>;
 
 export function useUndoScope(
   schemaOrName: Schema | string,
   nameOrOptions?: string | UndoScopeOptions,
   maybeOptions?: UndoScopeOptions,
-): UseUndoScopeResult<Schema> {
-  const { store, organizationId, schema: ctxSchema } = useSyncContext();
+): useUndoScope.Result<Schema> {
+  const { store, organizationId, schema: ctxSchema } = useAbloStoreContext();
 
   const isExplicit = typeof schemaOrName !== 'string';
   const schema = isExplicit ? (schemaOrName) : ctxSchema;
@@ -96,7 +85,7 @@ export function useUndoScope(
   }
 
   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
@@ -141,3 +130,18 @@ export function useUndoScope(
     },
   };
 }
+
+/** The state returned by an undo scope; inferred for ordinary hook calls. */
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace useUndoScope {
+  export interface Result<S extends Schema> {
+    /** Pass to `useMutators(..., { undoScope })` to enable recording. */
+    scope: UndoScope<S>;
+    undo: () => Promise<void>;
+    redo: () => Promise<void>;
+    canUndo: boolean;
+    canRedo: boolean;
+    /** Drop history. Use after sync errors / auth context changes. */
+    clear: () => void;
+  }
+}

package/src/react.ts

@@ -1,69 +1,9 @@
-/** React bindings for the optional human-facing local-state package. */
-export { useReactive } from './useReactive.js';
-export { useCurrentUserId } from './react/useCurrentUserId.js';
-export { useErrorListener } from './react/useErrorListener.js';
-export { useSyncStatus, type SyncStatusSnapshot } from './react/useSyncStatus.js';
-export {
-  usePresence,
-  type PresenceModelSelector,
-} from './react/usePresence.js';
-export {
-  useMutationFailureListener,
-  type MutationFailurePayload,
-} from './react/useMutationFailureListener.js';
-
-export {
-  AbloProvider,
-  usePeers,
-  useSync,
-  useSyncStore,
-  type AbloProviderProps,
-  type GroupScope,
-} from './react/AbloProvider.js';
-
-export {
-  ClientSideSuspense,
-  type ClientSideSuspenseProps,
-} from './react/ClientSideSuspense.js';
-
-export { DefaultFallback } from './react/DefaultFallback.js';
-
-export {
-  createAbloReact,
-  type AbloReactBinding,
-} from './react/createAbloReact.js';
-
-export {
-  useAblo,
-  type UseAbloHydratedModelResult,
-  type UseAbloModelOptions,
-  type UseAbloModelResult,
-} from './react/useAblo.js';
-
-export {
-  useMutators,
-  type InvokerFor,
-  type MutatorInvokers,
-  type UseMutatorsOptions,
-} from './react/useMutators.js';
-
-export {
-  useUndoScope,
-  type UseUndoScopeResult,
-} from './react/useUndoScope.js';
-
-export type {
-  DefaultSyncShape,
-  ResolveSchema,
-  ResolveUserMeta,
-  ResolveClaimMeta,
-  ResolveModelKey,
-} from '@abloatai/transaction/types/global';
-
-export { ModelScope } from '@abloatai/transaction/types';
-export type { SyncStoreContract } from './react/context.js';
-export type { MutateActions } from './local/mutators/mutateActions.js';
-export type {
-  ReaderActions,
-  ReaderFindOptions,
-} from './local/mutators/readerActions.js';
+/** React owns context, subscriptions and component lifetimes over core Ablo. */
+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/src/reactRuntime.ts

@@ -3,8 +3,8 @@ export {
   type AbloInternalContextValue,
 } from './react/internalContext.js';
 export {
-  useSyncContext,
-  type SyncReactContext,
+  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/react/ClientSideSuspense.d.ts

@@ -1,36 +0,0 @@
-import { type ReactNode } from 'react';
-/**
- * Nested bootstrap gate for a subtree. `<AbloProvider>` already ships
- * its own built-in gate (via its `fallback` prop) that handles the
- * common "wait for first bootstrap" case. Use `ClientSideSuspense`
- * only when you need a SEPARATE gate inside an already-ready provider —
- * for example, rendering app chrome immediately while gating a single
- * heavy product surface on its own query resolving.
- *
- * Like the provider-level gate, this component latches open on the
- * first `connected` / `reconnecting` / `disconnected` transition and
- * stays open. Subsequent transient `connecting` states (hard reconnect
- * after offline) do NOT re-show the fallback — the app has already
- * rendered once and its own reconnect UI should take over.
- *
- * v0.3.x implementation is non-Suspense: reads `useSyncStatus()` and
- * conditionally renders. v0.3.x+ will ship a
- * the React suspense entry point where `useQuery` / `useOne`
- * actually throw Promises; this component becomes a thin wrapper around
- * React's real `<Suspense>` at that point.
- *
- * @example
- * <AbloProvider fallback={<AppSkeleton />}>
- *   <AppChrome />
- *   <ClientSideSuspense fallback={<CanvasSkeleton />}>
- *     <HeavyCanvas />
- *   </ClientSideSuspense>
- * </AbloProvider>
- */
-export interface ClientSideSuspenseProps {
-    /** What to render while the nested subtree is waiting for first bootstrap. */
-    fallback: ReactNode;
-    /** What to render once the subtree is cleared to render. */
-    children: ReactNode;
-}
-export declare function ClientSideSuspense({ fallback, children }: ClientSideSuspenseProps): import("react").JSX.Element;

package/dist/react/ClientSideSuspense.js

@@ -1,17 +0,0 @@
-'use client';
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { useEffect, useState } from 'react';
-import { useSyncStatus } from './useSyncStatus.js';
-export function ClientSideSuspense({ fallback, children }) {
-    const status = useSyncStatus();
-    const [everConnected, setEverConnected] = useState(false);
-    useEffect(() => {
-        if (status.name === 'connected' ||
-            status.name === 'reconnecting' ||
-            status.name === 'disconnected') {
-            setEverConnected(true);
-        }
-    }, [status.name]);
-    const showFallback = !everConnected && status.name === 'connecting';
-    return _jsx(_Fragment, { children: showFallback ? fallback : children });
-}

package/dist/react/useCurrentUserId.d.ts

@@ -1,2 +0,0 @@
-/** Returns the application user id supplied to the nearest AbloProvider. */
-export declare function useCurrentUserId(): string | null;

package/dist/react/useCurrentUserId.js

@@ -1,12 +0,0 @@
-'use client';
-import { useContext } from 'react';
-import { AbloInternalContext } from './internalContext.js';
-import { AbloValidationError } from '@abloatai/transaction/errors';
-/** Returns the application user id supplied to the nearest AbloProvider. */
-export function useCurrentUserId() {
-    const context = useContext(AbloInternalContext);
-    if (!context) {
-        throw new AbloValidationError('useCurrentUserId: no <AbloProvider> mounted above this component.', { code: 'no_ablo_provider' });
-    }
-    return context.currentUserId;
-}

package/dist/react/useErrorListener.d.ts

@@ -1,2 +0,0 @@
-/** Subscribe to provider-level errors without causing component re-renders. */
-export declare function useErrorListener(listener: (error: Error) => void): void;

package/dist/react/useErrorListener.js

@@ -1,14 +0,0 @@
-'use client';
-import { useContext, useEffect, useRef } from 'react';
-import { AbloInternalContext } from './internalContext.js';
-import { AbloValidationError } from '@abloatai/transaction/errors';
-/** Subscribe to provider-level errors without causing component re-renders. */
-export function useErrorListener(listener) {
-    const context = useContext(AbloInternalContext);
-    if (!context) {
-        throw new AbloValidationError('useErrorListener: no <AbloProvider> mounted above this component.', { code: 'no_ablo_provider' });
-    }
-    const listenerRef = useRef(listener);
-    listenerRef.current = listener;
-    useEffect(() => context.subscribeError((error) => { listenerRef.current(error); }), [context]);
-}

package/dist/react/useMutationFailureListener.d.ts

@@ -1,8 +0,0 @@
-import { type QueuedMutation } from '../reactRuntime.js';
-export interface MutationFailurePayload {
-    transaction: QueuedMutation;
-    error: Error;
-    permanent?: boolean;
-}
-/** Subscribe to optimistic mutation rollbacks and permanent write failures. */
-export declare function useMutationFailureListener(listener: (payload: MutationFailurePayload) => void): void;

package/dist/react/useMutationFailureListener.js

@@ -1,19 +0,0 @@
-'use client';
-import { useContext, useEffect, useRef } from 'react';
-import { AbloInternalContext, } from '../reactRuntime.js';
-import { AbloValidationError } from '@abloatai/transaction/errors';
-/** Subscribe to optimistic mutation rollbacks and permanent write failures. */
-export function useMutationFailureListener(listener) {
-    const context = useContext(AbloInternalContext);
-    if (!context) {
-        throw new AbloValidationError('useMutationFailureListener: no <AbloProvider> mounted above this component.', { code: 'no_ablo_provider' });
-    }
-    const listenerRef = useRef(listener);
-    listenerRef.current = listener;
-    useEffect(() => {
-        const engine = context.engine;
-        if (!engine)
-            return;
-        return engine.onMutationFailure((payload) => { listenerRef.current(payload); });
-    }, [context, context.engine]);
-}

package/dist/react/useSyncStatus.js

@@ -1,48 +0,0 @@
-'use client';
-import { useCallback, useContext } from 'react';
-import { SyncContext, } from './context.js';
-import { AbloInternalContext } from './internalContext.js';
-import { AbloValidationError } from '@abloatai/transaction/errors';
-import { useReactive } from '../useReactive.js';
-/** Reactively exposes the local store's connection and confirmation status. */
-export function useSyncStatus() {
-    const provider = useContext(AbloInternalContext);
-    const sync = useContext(SyncContext);
-    // Status does not require authenticated row scope. The client exists before
-    // ready() resolves, including inside passthrough children and custom fallbacks.
-    const store = provider?.engine?._store ?? sync?.store;
-    if (!store) {
-        throw new AbloValidationError('Sync hooks must be used within an <AbloProvider>.', {
-            code: 'sync_context_missing_provider',
-        });
-    }
-    const compute = useCallback(() => deriveStatus(store), [store]);
-    return useReactive(compute, sameSnapshot);
-}
-function deriveStatus(store) {
-    const { state, progress, pendingChanges, isSessionError, error } = store.syncStatus;
-    if (isSessionError)
-        return { name: 'needs-auth' };
-    if (state === 'reconnecting')
-        return { name: 'reconnecting', reason: error?.message };
-    if (state === 'offline')
-        return { name: 'disconnected', reason: 'offline' };
-    if (state === 'error')
-        return { name: 'disconnected', reason: error?.message };
-    if (store.isReady)
-        return { name: 'connected', hasUnsyncedChanges: pendingChanges > 0 };
-    if (state === 'idle' || state === 'syncing')
-        return { name: 'connecting', progress };
-    return { name: 'initial' };
-}
-function sameSnapshot(a, b) {
-    if (a.name !== b.name)
-        return false;
-    if (a.name === 'initial' || a.name === 'needs-auth')
-        return true;
-    if (a.name === 'connecting')
-        return b.name === 'connecting' && a.progress === b.progress;
-    if (a.name === 'connected')
-        return b.name === 'connected' && a.hasUnsyncedChanges === b.hasUnsyncedChanges;
-    return (b.name === 'reconnecting' || b.name === 'disconnected') && a.reason === b.reason;
-}

package/dist/useReactive.d.ts

@@ -1,6 +0,0 @@
-/**
- * Subscribe a React component to a MobX computation with a cached snapshot.
- * This is the framework-level reactive primitive owned by @abloatai/humans;
- * store/model hooks are layered above it.
- */
-export declare function useReactive<T>(compute: () => T, equals?: (a: T, b: T) => boolean): T;