@abloatai/ablo 0.35.0 → 0.37.0

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
- * `@abloatai/ablo/react/suspense` subpath 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/DefaultFallback.d.ts

@@ -1,24 +0,0 @@
-/**
- * Neutral loading placeholder — the default value of `<AbloProvider>`'s
- * `fallback` prop. Rendered during the first bootstrap pass when the
- * consumer hasn't supplied their own skeleton.
- *
- * Design goals:
- *   - Zero design-system dependency. Inline styles only; no CSS file,
- *     no UI-lib imports, no Tailwind assumptions.
- *   - Theme-adaptive. Uses `currentColor` for the ring so the spinner
- *     inherits the text color from whichever ancestor defines it —
- *     works in light + dark contexts without a prop.
- *   - Self-centering. Flex-centered in a full-parent container so the
- *     common case (provider at the layout root) renders a spinner in
- *     the middle of the viewport. Consumers who need different
- *     positioning compose their own fallback and pass it explicitly.
- *   - Minimal bundle footprint. The whole component + keyframe is ~50
- *     bytes gzipped.
- *
- * Consumers wanting a branded loader should pass `fallback={<YourSkeleton />}`
- * on `<AbloProvider>`. Consumers wanting NO visual during bootstrap
- * pass `fallback={null}`. Consumers who want to skip the gate entirely
- * pass `fallback="passthrough"`.
- */
-export declare function DefaultFallback(): import("react").JSX.Element;

package/dist/react/DefaultFallback.js

@@ -1,43 +0,0 @@
-'use client';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * Neutral loading placeholder — the default value of `<AbloProvider>`'s
- * `fallback` prop. Rendered during the first bootstrap pass when the
- * consumer hasn't supplied their own skeleton.
- *
- * Design goals:
- *   - Zero design-system dependency. Inline styles only; no CSS file,
- *     no UI-lib imports, no Tailwind assumptions.
- *   - Theme-adaptive. Uses `currentColor` for the ring so the spinner
- *     inherits the text color from whichever ancestor defines it —
- *     works in light + dark contexts without a prop.
- *   - Self-centering. Flex-centered in a full-parent container so the
- *     common case (provider at the layout root) renders a spinner in
- *     the middle of the viewport. Consumers who need different
- *     positioning compose their own fallback and pass it explicitly.
- *   - Minimal bundle footprint. The whole component + keyframe is ~50
- *     bytes gzipped.
- *
- * Consumers wanting a branded loader should pass `fallback={<YourSkeleton />}`
- * on `<AbloProvider>`. Consumers wanting NO visual during bootstrap
- * pass `fallback={null}`. Consumers who want to skip the gate entirely
- * pass `fallback="passthrough"`.
- */
-export function DefaultFallback() {
-    return (_jsxs("div", { role: "status", "aria-live": "polite", "aria-label": "Loading", style: {
-            display: 'flex',
-            alignItems: 'center',
-            justifyContent: 'center',
-            width: '100%',
-            minHeight: '100vh',
-            color: 'currentColor',
-        }, children: [_jsx("div", { style: {
-                    width: 24,
-                    height: 24,
-                    border: '2px solid currentColor',
-                    borderTopColor: 'transparent',
-                    borderRadius: '50%',
-                    opacity: 0.6,
-                    animation: 'ablo-default-fallback-spin 0.8s linear infinite',
-                } }), _jsx("style", { children: `@keyframes ablo-default-fallback-spin { to { transform: rotate(360deg); } }` })] }));
-}

package/dist/react/context.d.ts

@@ -1,55 +0,0 @@
-import { type ReactNode } from 'react';
-import type { Schema } from '../transaction/schema/schema.js';
-import type { SyncStoreContract } from '../core/storeContract.js';
-export type { SyncStoreContract, LocalMutation } from '../core/storeContract.js';
-export interface SyncReactContext {
-    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('tasks')`) 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.
-     */
-    schema?: Schema;
-}
-export declare const SyncContext: import("react").Context<SyncReactContext | 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.
- */
-export declare function useSyncContext(): SyncReactContext;
-/**
- * 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('tasks')`); 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 declare function SyncProvider({ store, organizationId, schema, children, }: SyncProviderProps): import("react").FunctionComponentElement<import("react").ProviderProps<SyncReactContext | null>>;

package/dist/react/context.js

@@ -1,29 +0,0 @@
-'use client';
-import { createContext, createElement, useContext } from 'react';
-import { AbloValidationError } from '../transaction/errors.js';
-export const SyncContext = createContext(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.
- */
-export function useSyncContext() {
-    const ctx = useContext(SyncContext);
-    if (!ctx) {
-        throw new AbloValidationError('Sync hooks must be used within an <AbloProvider>.', {
-            code: 'sync_context_missing_provider',
-        });
-    }
-    return ctx;
-}
-/**
- * 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, }) {
-    return createElement(SyncContext.Provider, { value: { store, organizationId, schema } }, children);
-}

package/dist/react/index.d.ts

@@ -1,61 +0,0 @@
-/**
- * React bindings for `@abloatai/ablo`.
- *
- * # Provider
- *
- * Build a client once — at module scope or with `useMemo` — and wrap your tree:
- *
- *   const ablo = Ablo({ schema, apiKey })
- *   <AbloProvider client={ablo} fallback={<Skeleton/>}>
- *
- * `client` is the only required prop; you construct it, and the provider is the
- * thin reactive binding around it. The provider owns the sync-engine and
- * multiplayer lifecycle. Its `fallback` gates children until the first sync
- * bootstrap completes — pass `fallback="passthrough"` to render children
- * immediately. `userId` is optional and informational.
- *
- * {@link ClientSideSuspense} adds a nested gate inside an already-ready
- * provider. Reach for it only when a heavy subtree, such as a canvas, needs its
- * own gate while the rest of the app renders right away; the provider-level
- * `fallback` is the usual path.
- *
- * # Data hooks
- *
- *   useAblo((ablo) => ablo.tasks.local.retrieve(id))  — subscribe to a local snapshot (the main read API)
- *   useAblo()                              — the typed client, for callbacks and effects:
- *                                            synchronous local reads (`ablo.<model>.local.retrieve`/`local.list`),
- *                                            async server reads (`retrieve`/`list`),
- *                                            and writes (`create`/`update`/`delete`)
- *   useMutators(defs, opts?)               — define custom mutators
- *   useUndoScope(name)                     — per-surface undo and redo
- *
- * # Status and errors
- *
- *   useSyncStatus()       — a discriminated-union snapshot of the sync lifecycle
- *   useErrorListener(cb)  — an imperative error callback, for telemetry or toasts
- *   useCurrentUserId()    — the provider's `userId` prop
- *
- * # Multiplayer
- *
- * Multiplayer is always available, because `<AbloProvider>` always constructs a
- * client:
- *
- *   useAblo((ablo) => ablo.<model>.claim.state(...))  — reactive coordination reads
- *   useJoin({ scope })                                — join a scope to get its peers and claims
- */
-export type { DefaultSyncShape, ResolveSchema, ResolveUserMeta, ResolveClaimMeta, ResolveModelKey, } from '../transaction/types/global.js';
-export { AbloProvider, useJoin, usePeers, useSync, useSyncStore, type AbloProviderProps, type ParticipantScope, type ParticipantStatus, type UseJoinOptions, type UseJoinReturn, } from './AbloProvider.js';
-export { ClientSideSuspense, type ClientSideSuspenseProps, } from './ClientSideSuspense.js';
-export { DefaultFallback } from './DefaultFallback.js';
-export type { SyncStoreContract } from './context.js';
-export { useSyncStatus, type SyncStatusSnapshot, } from './useSyncStatus.js';
-export { useErrorListener } from './useErrorListener.js';
-export { useMutationFailureListener, type MutationFailurePayload, } from './useMutationFailureListener.js';
-export { useCurrentUserId } from './useCurrentUserId.js';
-export { useReactive } from './useReactive.js';
-export type { MutateActions } from '../mutators/mutateActions.js';
-export type { ReaderActions, ReaderFindOptions } from '../mutators/readerActions.js';
-export { useMutators, type MutatorInvokers, type InvokerFor, type UseMutatorsOptions, } from './useMutators.js';
-export { useUndoScope, type UseUndoScopeResult } from './useUndoScope.js';
-export { useAblo, type UseAbloHydratedModelResult, type UseAbloModelOptions, type UseAbloModelResult, } from './useAblo.js';
-export { ModelScope } from '../transaction/types/index.js';

package/dist/react/index.js

@@ -1,66 +0,0 @@
-/**
- * React bindings for `@abloatai/ablo`.
- *
- * # Provider
- *
- * Build a client once — at module scope or with `useMemo` — and wrap your tree:
- *
- *   const ablo = Ablo({ schema, apiKey })
- *   <AbloProvider client={ablo} fallback={<Skeleton/>}>
- *
- * `client` is the only required prop; you construct it, and the provider is the
- * thin reactive binding around it. The provider owns the sync-engine and
- * multiplayer lifecycle. Its `fallback` gates children until the first sync
- * bootstrap completes — pass `fallback="passthrough"` to render children
- * immediately. `userId` is optional and informational.
- *
- * {@link ClientSideSuspense} adds a nested gate inside an already-ready
- * provider. Reach for it only when a heavy subtree, such as a canvas, needs its
- * own gate while the rest of the app renders right away; the provider-level
- * `fallback` is the usual path.
- *
- * # Data hooks
- *
- *   useAblo((ablo) => ablo.tasks.local.retrieve(id))  — subscribe to a local snapshot (the main read API)
- *   useAblo()                              — the typed client, for callbacks and effects:
- *                                            synchronous local reads (`ablo.<model>.local.retrieve`/`local.list`),
- *                                            async server reads (`retrieve`/`list`),
- *                                            and writes (`create`/`update`/`delete`)
- *   useMutators(defs, opts?)               — define custom mutators
- *   useUndoScope(name)                     — per-surface undo and redo
- *
- * # Status and errors
- *
- *   useSyncStatus()       — a discriminated-union snapshot of the sync lifecycle
- *   useErrorListener(cb)  — an imperative error callback, for telemetry or toasts
- *   useCurrentUserId()    — the provider's `userId` prop
- *
- * # Multiplayer
- *
- * Multiplayer is always available, because `<AbloProvider>` always constructs a
- * client:
- *
- *   useAblo((ablo) => ablo.<model>.claim.state(...))  — reactive coordination reads
- *   useJoin({ scope })                                — join a scope to get its peers and claims
- */
-// ── Umbrella provider + lifecycle hooks ────────────────────────────
-export { AbloProvider, useJoin, usePeers, useSync, useSyncStore, } from './AbloProvider.js';
-export { ClientSideSuspense, } from './ClientSideSuspense.js';
-export { DefaultFallback } from './DefaultFallback.js';
-// ── Status + errors + identity ─────────────────────────────────────
-export { useSyncStatus, } from './useSyncStatus.js';
-export { useErrorListener } from './useErrorListener.js';
-export { useMutationFailureListener, } from './useMutationFailureListener.js';
-export { useCurrentUserId } from './useCurrentUserId.js';
-// ── Primitive for building custom reactive hooks ──────────────────
-//
-// Consumers building bespoke hooks on top of the SDK should call
-// `useReactive(() => compute())` instead of reaching for React's
-// lower-level `useSyncExternalStore`. Hides the cached-snapshot
-// contract and handles default structural equality for arrays.
-export { useReactive } from './useReactive.js';
-export { useMutators, } from './useMutators.js';
-export { useUndoScope } from './useUndoScope.js';
-export { useAblo, } from './useAblo.js';
-// ── ModelScope re-export ───────────────────────────────────────────
-export { ModelScope } from '../transaction/types/index.js';

package/dist/react/internalContext.d.ts

@@ -1,33 +0,0 @@
-import type { Ablo } from '../client/Ablo.js';
-import type { SchemaRecord } from '../transaction/schema/schema.js';
-/**
- * The context that `<AbloProvider>` populates for its own hooks. It is kept
- * separate from the data-hook context, which carries the store and schema,
- * because these fields belong to the provider rather than to the store. Read
- * them through the typed hooks such as `useCurrentUserId` and
- * `useErrorListener` rather than reaching into this context directly.
- */
-export interface AbloInternalContextValue {
-    /**
-     * The application user id, when your app passed one to `<AbloProvider>`. Sync
-     * identity is derived on the server from the API key, so this is `null`
-     * unless you set it, and it is not required for sync to work.
-     */
-    currentUserId: string | null;
-    /** Subscribe to provider-level errors: engine errors, bootstrap failures, and session issues. */
-    subscribeError: (listener: (error: Error) => void) => () => void;
-    /** Emit an error to every subscribed listener. The provider calls this for you. */
-    emitError: (error: Error) => void;
-    /**
-     * The typed `Ablo` client for this provider, or `null` until the first sync
-     * bootstrap resolves. It is held here so `useSync()` can return it without
-     * reaching into the store; the client and the store are sibling objects, and
-     * neither is derived from the other.
-     *
-     * It is typed loosely as `Ablo<SchemaRecord>` because generics do not flow
-     * through React context. `useSync<R>()` restores the precise type through its
-     * own generic; the runtime value is the fully typed client.
-     */
-    engine: Ablo<SchemaRecord> | null;
-}
-export declare const AbloInternalContext: import("react").Context<AbloInternalContextValue | null>;

package/dist/react/internalContext.js

@@ -1,3 +0,0 @@
-'use client';
-import { createContext } from 'react';
-export const AbloInternalContext = createContext(null);

package/dist/react/useAblo.d.ts

@@ -1,75 +0,0 @@
-import type { Ablo, AbloReads, ModelClaim } from '../client/Ablo.js';
-import type { ModelOperations } from '../client/createModelProxy.js';
-import type { SchemaRecord } from '../transaction/schema/schema.js';
-import type { ResolveSchema } from '../transaction/types/global.js';
-/**
- * The app's resolved schema-record type. It reads your `Register` module
- * augmentation when you declare one and falls back to the loose
- * {@link SchemaRecord} otherwise, so `useAblo()` returns a fully typed client
- * without you passing `<(typeof schema)['models']>` at every call site.
- */
-type DefaultModels = ResolveSchema extends {
-    models: infer M;
-} ? M extends SchemaRecord ? M : SchemaRecord : SchemaRecord;
-type ModelClientSelector<R extends SchemaRecord, T, C> = (ablo: AbloReads<R>) => ModelOperations<T, C>;
-type AbloSelector<R extends SchemaRecord, T> = (ablo: AbloReads<R>) => T;
-export interface UseAbloModelOptions<T> {
-    /**
-     * An initial row, usually from a server component or a route loader. The hook
-     * returns it until sync delivers a newer row for the same id.
-     */
-    readonly initial?: T;
-}
-export interface UseAbloModelResult<T> {
-    /** The current row for the id, or `initial` until the row has synced. */
-    readonly data: T | undefined;
-    /** The work claims currently held on this row by any participant. */
-    readonly claims: readonly ModelClaim[];
-    /** True while another participant holds a claim — handy for disabling UI. */
-    readonly claimed: boolean;
-}
-export type UseAbloHydratedModelResult<T> = Omit<UseAbloModelResult<T>, 'data'> & {
-    readonly data: T;
-};
-/**
- * Reads Ablo from inside an `<AbloProvider>` subtree. Called with no arguments
- * it returns the typed client for use in callbacks and effects; called with a
- * selector it subscribes the component to a reactive read — such as one
- * `ablo.<model>` row — and re-renders when that read changes.
- *
- * You can call it with no type arguments once you declare the `Register` module
- * augmentation (`declare module '@abloatai/ablo' { interface Register {
- * Schema: typeof schema } }`); the default type then resolves through your
- * schema's models, so call sites stay clean:
- *
- * ```ts
- * // With the Register augmentation (recommended):
- * const ablo = useAblo();
- * if (!ablo) return <Loading />;
- * const doc = await ablo.documents.retrieve({ id }); // async server read
- *
- * // Reactive selector (a synchronous local snapshot). The selector's reads
- * // are typed as snapshot rows — data fields + computeds, no relation
- * // accessors — matching what the hook actually returns:
- * const doc = useAblo((ablo) => ablo.documents.local.retrieve(id)) ?? serverDoc;
- * const active = useAblo((ablo) => ablo.documents.claim.state({ id }));
- *
- * // Without the augmentation, pass the schema as a type argument:
- * const ablo = useAblo<(typeof schema)['models']>();
- * ```
- *
- * The no-argument form returns `null` while the engine is still bootstrapping.
- * Branch on `null` and render a loading state — or gate on `useSyncStatus()`
- * reaching `'connected'` — before calling model methods.
- */
-export declare function useAblo<R extends SchemaRecord = DefaultModels>(): Ablo<R> | null;
-export declare function useAblo<R extends SchemaRecord = DefaultModels, T = unknown>(select: AbloSelector<R, T>): T | undefined;
-export declare function useAblo<T, C>(modelClient: ModelOperations<T, C>, id: string, options: UseAbloModelOptions<T> & {
-    readonly initial: T;
-}): UseAbloHydratedModelResult<T>;
-export declare function useAblo<R extends SchemaRecord = DefaultModels, T = Record<string, unknown>, C = unknown>(select: ModelClientSelector<R, T, C>, id: string, options: UseAbloModelOptions<T> & {
-    readonly initial: T;
-}): UseAbloHydratedModelResult<T>;
-export declare function useAblo<T, C>(modelClient: ModelOperations<T, C>, id: string, options?: UseAbloModelOptions<T>): UseAbloModelResult<T>;
-export declare function useAblo<R extends SchemaRecord = DefaultModels, T = Record<string, unknown>, C = unknown>(select: ModelClientSelector<R, T, C>, id: string, options?: UseAbloModelOptions<T>): UseAbloModelResult<T>;
-export {};

package/dist/react/useAblo.js

@@ -1,102 +0,0 @@
-'use client';
-import { useContext, useEffect, useState } from 'react';
-import { AbloInternalContext } from './internalContext.js';
-import { getModelClientMeta } from '../client/createModelProxy.js';
-import { Model } from '../Model.js';
-import { useReactive } from './useReactive.js';
-const EMPTY_CLAIMS = Object.freeze([]);
-/**
- * Restore the caller's schema generics on the context-held engine. React
- * context erases generics (see `AbloInternalContextValue.engine`), so this is
- * the one deliberate rebind point: the runtime value is the fully typed
- * client, and `R` is the compile-time view the calling hook declared.
- */
-function rebindEngine(engine) {
-    return engine;
-}
-/**
- * The same rebind viewed through the reactive-read surface — the identical
- * runtime object, with model reads typed as snapshot rows, because everything
- * a selector returns is converted through `snapshotValue` before the hook
- * hands it back.
- */
-function reactiveReads(engine) {
-    return rebindEngine(engine);
-}
-function readModelResult(engine, modelClient, id, initial) {
-    if (!modelClient || id === undefined) {
-        return { data: initial, claims: EMPTY_CLAIMS, claimed: false };
-    }
-    const data = snapshotValue(modelClient.local.retrieve(id) ?? initial);
-    const meta = getModelClientMeta(modelClient);
-    const claims = meta && engine
-        ? engine.claims.list({ model: meta.key, id })
-        : EMPTY_CLAIMS;
-    return { data, claims, claimed: claims.length > 0 };
-}
-/**
- * Projects a reactive read into the value that `useReactive` caches and
- * returns.
- *
- * For a `Model`, this reads the row's fields through `toReactiveSnapshot`
- * rather than returning the instance itself. Property access is what subscribes
- * the reaction to those fields, so the read has to happen inside this tracked
- * function; returning the live instance without reading its fields would leave
- * the component blind to later edits. The fresh object it produces also lets
- * `useReactive`'s equality check detect an in-place update.
- */
-function snapshotValue(value) {
-    if (value instanceof Model) {
-        return value.toReactiveSnapshot();
-    }
-    if (Array.isArray(value)) {
-        return value.map((item) => snapshotValue(item));
-    }
-    return value;
-}
-export function useAblo(modelOrSelect, id, options) {
-    const ctx = useContext(AbloInternalContext);
-    const engine = ctx?.engine ?? null;
-    const initial = options?.initial;
-    const isSelectorOnly = typeof modelOrSelect === 'function' && id === undefined;
-    const modelClient = typeof modelOrSelect === 'function' && id !== undefined
-        ? engine
-            ? modelOrSelect(reactiveReads(engine))
-            : undefined
-        : typeof modelOrSelect === 'function'
-            ? undefined
-            : modelOrSelect;
-    // 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.
-    const [claimVersion, setClaimVersion] = useState(0);
-    useEffect(() => {
-        if (!engine || id === undefined)
-            return;
-        return engine.claims.onChange(() => { setClaimVersion((version) => version + 1); });
-    }, [engine, id]);
-    const selected = useReactive(() => {
-        if (!engine || !isSelectorOnly || typeof modelOrSelect !== 'function') {
-            return undefined;
-        }
-        // The selector runs against the real engine — reads inside it return the
-        // pool's model instances. `snapshotValue` then converts the RESULT to
-        // plain snapshot rows, which is what the selector's `AbloReads`
-        // parameter type already promised.
-        return snapshotValue(modelOrSelect(reactiveReads(engine)));
-    });
-    const modelResult = useReactive(() => {
-        void claimVersion;
-        return readModelResult(engine, modelClient, id, initial);
-    });
-    if (isSelectorOnly)
-        return selected;
-    if (modelOrSelect)
-        return modelResult;
-    return engine === null ? null : rebindEngine(engine);
-}

package/dist/react/useCurrentUserId.d.ts

@@ -1,22 +0,0 @@
-/**
- * Returns the application user id passed to the nearest `<AbloProvider>`, or
- * `null` when your app did not provide one.
- *
- * Sync identity is resolved on the server from the API key or session, so this
- * value is not required for sync to connect. It is here for your app's own
- * fields — an assignee id, a presence label, a permission check — where the
- * current user matters to your data rather than to the sync layer. Reach for it
- * in leaf components that need the id, for example to fill in a mutation
- * payload.
- *
- * @example
- * function TaskRow({ id }) {
- *   const userId = useCurrentUserId();
- *   const ablo = useAblo();
- *   if (!userId) return null;
- *   return <button onClick={() => ablo?.tasks.update({ id, data: { assigneeId: userId } })}>
- *     Assign to me
- *   </button>;
- * }
- */
-export declare function useCurrentUserId(): string | null;

package/dist/react/useCurrentUserId.js

@@ -1,34 +0,0 @@
-'use client';
-import { useContext } from 'react';
-import { AbloInternalContext } from './internalContext.js';
-import { AbloValidationError } from '../transaction/errors.js';
-/**
- * Returns the application user id passed to the nearest `<AbloProvider>`, or
- * `null` when your app did not provide one.
- *
- * Sync identity is resolved on the server from the API key or session, so this
- * value is not required for sync to connect. It is here for your app's own
- * fields — an assignee id, a presence label, a permission check — where the
- * current user matters to your data rather than to the sync layer. Reach for it
- * in leaf components that need the id, for example to fill in a mutation
- * payload.
- *
- * @example
- * function TaskRow({ id }) {
- *   const userId = useCurrentUserId();
- *   const ablo = useAblo();
- *   if (!userId) return null;
- *   return <button onClick={() => ablo?.tasks.update({ id, data: { assigneeId: userId } })}>
- *     Assign to me
- *   </button>;
- * }
- */
-export function useCurrentUserId() {
-    const ctx = useContext(AbloInternalContext);
-    if (!ctx) {
-        throw new AbloValidationError('useCurrentUserId: no <AbloProvider> mounted above this component. ' +
-            'Wrap your tree with <AbloProvider ...> from ' +
-            '@abloatai/ablo/react.', { code: 'no_ablo_provider' });
-    }
-    return ctx.currentUserId;
-}

package/dist/react/useErrorListener.d.ts

@@ -1,20 +0,0 @@
-/**
- * Registers a callback that runs whenever the provider surfaces an error. This
- * covers engine errors such as bootstrap failures and mutation rejections,
- * WebSocket errors, and uncaught exceptions thrown inside `postBootstrap`
- * hooks.
- *
- * Use it for side effects that should not cause a re-render — telemetry,
- * logging, or a toast. The callback is held in a ref, so a re-render does not
- * resubscribe.
- *
- * @example
- * function ErrorToaster() {
- *   useErrorListener((err) => {
- *     toast.error(err.message);
- *     Sentry.captureException(err);
- *   });
- *   return null;
- * }
- */
-export declare function useErrorListener(listener: (error: Error) => void): void;