@abloatai/ablo 0.36.0 → 0.37.0

package/dist/react/createAbloReact.d.ts

@@ -1,56 +0,0 @@
-/**
- * The typed react binding — the schema generic is captured ONCE, at a factory
- * call in app code, and every hook the factory returns is born typed. This is
- * the shape the reference libraries converged on independently (tRPC's
- * `createTRPCReact`, XState's `createActorContext`, react-redux's
- * `withTypes`): no module augmentation, no generic parameters at call sites,
- * and — once the legacy generic erasure retires — no casts anywhere on the
- * path from context to component.
- *
- * The app's one binding file, by convention:
- *
- * ```ts
- * // lib/ablo.ts
- * import { createAbloReact } from '@abloatai/ablo/react';
- * import { schema } from './schema';
- *
- * export const { AbloProvider, useAblo } = createAbloReact(schema);
- * ```
- *
- * Components then import `useAblo` from `lib/ablo` and never spell a type
- * argument; `useAblo()` is `Ablo<S> | null`, and a selector's `ablo`
- * parameter is the reactive-read view of the same `S`.
- */
-import { type ReactElement } from 'react';
-import { type AbloProviderProps } from './AbloProvider.js';
-import { type AbloSelector, type ModelClientSelector, type UseAbloHydratedModelResult, type UseAbloModelOptions, type UseAbloModelResult } from './useAblo.js';
-import type { Ablo } from '../client/Ablo.js';
-import type { ModelOperations } from '../client/createModelProxy.js';
-import type { Schema, SchemaRecord } from '../transaction/schema/schema.js';
-/** What a binding returns: the provider and the hook, with `S` fixed. */
-export interface AbloReactBinding<S extends SchemaRecord> {
-    /** `AbloProvider` with its `client` prop typed `Ablo<S>` — same component,
-     *  no per-app generics. */
-    AbloProvider: (props: AbloProviderProps<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>(modelClient: ModelOperations<T, C>, id: string, options: UseAbloModelOptions<T> & {
-            readonly initial: T;
-        }): UseAbloHydratedModelResult<T>;
-        <T, C>(select: ModelClientSelector<S, T, C>, id: string, options: UseAbloModelOptions<T> & {
-            readonly initial: T;
-        }): UseAbloHydratedModelResult<T>;
-        <T, C>(modelClient: ModelOperations<T, C>, id: string, options?: UseAbloModelOptions<T>): UseAbloModelResult<T>;
-        <T, C>(select: ModelClientSelector<S, T, C>, id: string, options?: UseAbloModelOptions<T>): UseAbloModelResult<T>;
-    };
-}
-/**
- * Bind the react surface to one schema. The schema value is taken for
- * inference — write `createAbloReact(schema)`, never a hand-spelled type
- * argument — and it is the seam where the binding's own typed context arrives
- * when the legacy erasure retires (docs/plans/typed-react-binding.md, step 3).
- */
-export declare function createAbloReact<S extends SchemaRecord>(schema: Schema<S>): AbloReactBinding<S>;

package/dist/react/createAbloReact.js

@@ -1,51 +0,0 @@
-'use client';
-/**
- * The typed react binding — the schema generic is captured ONCE, at a factory
- * call in app code, and every hook the factory returns is born typed. This is
- * the shape the reference libraries converged on independently (tRPC's
- * `createTRPCReact`, XState's `createActorContext`, react-redux's
- * `withTypes`): no module augmentation, no generic parameters at call sites,
- * and — once the legacy generic erasure retires — no casts anywhere on the
- * path from context to component.
- *
- * The app's one binding file, by convention:
- *
- * ```ts
- * // lib/ablo.ts
- * import { createAbloReact } from '@abloatai/ablo/react';
- * import { schema } from './schema';
- *
- * export const { AbloProvider, useAblo } = createAbloReact(schema);
- * ```
- *
- * Components then import `useAblo` from `lib/ablo` and never spell a type
- * argument; `useAblo()` is `Ablo<S> | null`, and a selector's `ablo`
- * parameter is the reactive-read view of the same `S`.
- */
-import { createContext, createElement, useContext } from 'react';
-import { AbloProvider } from './AbloProvider.js';
-import { useAbloImpl, } from './useAblo.js';
-/**
- * Bind the react surface to one schema. The schema value is taken for
- * inference — write `createAbloReact(schema)`, never a hand-spelled type
- * argument — and it is the seam where the binding's own typed context arrives
- * when the legacy erasure retires (docs/plans/typed-react-binding.md, step 3).
- */
-export function createAbloReact(schema) {
-    void schema;
-    // The binding's own context — created here, AFTER the schema generic is
-    // known, so it is typed `Ablo<S>` from birth (the XState
-    // `createActorContext` shape). A hook that reads it never rebinds and
-    // never casts; a binding hook mounted under a legacy provider (no bound
-    // provider in the tree) reads `null` here and falls through to the shared
-    // implementation's internal-context fallback.
-    const BoundClientContext = createContext(null);
-    function BoundAbloProvider(props) {
-        return createElement(BoundClientContext.Provider, { value: props.client }, createElement((AbloProvider), props));
-    }
-    function useBoundAblo(modelOrSelect, id, options) {
-        const bound = useContext(BoundClientContext);
-        return useAbloImpl(bound, modelOrSelect, id, options);
-    }
-    return { AbloProvider: BoundAbloProvider, useAblo: useBoundAblo };
-}

package/dist/react/index.d.ts

@@ -1,62 +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 { createAbloReact, type AbloReactBinding } from './createAbloReact.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,69 +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';
-// The typed binding — capture the schema generic once, in the app's one
-// binding file, and import born-typed hooks everywhere (the tRPC shape).
-export { createAbloReact } from './createAbloReact.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,82 +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;
-export type ModelClientSelector<R extends SchemaRecord, T, C> = (ablo: AbloReads<R>) => ModelOperations<T, C>;
-export 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:
- *
- * **Prefer the binding.** `createAbloReact(schema)` captures the schema once
- * in your app's binding file and returns a `useAblo` that needs none of the
- * typing arrangements below — no type argument, no `Register` declaration
- * (see `react.md`). Passing an explicit schema type argument to THIS hook is
- * deprecated in favor of that binding; it keeps working for shared packages
- * that cannot bind a concrete schema.
- *
- * ```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,120 +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 reactive-read view of a client — 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. Same
- * generic in and out, so this compiles with no schema rebinding.
- */
-function reactiveReads(engine) {
-    return 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) {
-    return useAbloImpl(null, modelOrSelect, id, options);
-}
-/**
- * @internal The one implementation behind `useAblo` and the bound hooks a
- * `createAbloReact` binding returns — written once so the reactive read path
- * cannot fork between the global hook and a factory's.
- *
- * `boundClient` is a binding's own context value — typed `Ablo<S>` at the
- * factory, so that path never rebinds and never casts. `null` means "no
- * binding provider in this tree": the global hook always passes it, and a
- * binding hook mounted under a legacy provider falls through to the erased
- * internal context, which is what keeps both mounts working while the last
- * legacy mount migrates.
- */
-export function useAbloImpl(boundClient, modelOrSelect, id, options) {
-    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 = boundClient ?? (ctx?.engine ? rebindEngine(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;
-}

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;

package/dist/react/useErrorListener.js

@@ -1,38 +0,0 @@
-'use client';
-import { useContext, useEffect, useRef } from 'react';
-import { AbloInternalContext } from './internalContext.js';
-import { AbloValidationError } from '../transaction/errors.js';
-/**
- * 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 function useErrorListener(listener) {
-    const ctx = useContext(AbloInternalContext);
-    if (!ctx) {
-        throw new AbloValidationError('useErrorListener: no <AbloProvider> mounted above this component. ' +
-            'Wrap your tree with <AbloProvider ...> from @abloatai/ablo/react.', { code: 'no_ablo_provider' });
-    }
-    // Hold the latest callback in a ref so the subscription stays stable across
-    // renders. Late-binding the listener this way lets callers pass an inline
-    // arrow without resubscribing on every render.
-    const ref = useRef(listener);
-    ref.current = listener;
-    useEffect(() => {
-        return ctx.subscribeError((err) => { ref.current(err); });
-    }, [ctx]);
-}

package/dist/react/useMutationFailureListener.d.ts

@@ -1,26 +0,0 @@
-import type { QueuedMutation } from '../transactions/mutations/MutationQueue.js';
-export interface MutationFailurePayload {
-    transaction: QueuedMutation;
-    error: Error;
-    permanent?: boolean;
-}
-/**
- * Subscribes a listener to mutation failures. The callback fires whenever the
- * transaction queue rolls back an optimistic write — both permanent rejections
- * (a validation, foreign-key, or authorization error) and rollbacks after the
- * retries are exhausted (for example, the connection drops mid-write).
- *
- * A single listener mounted near the top of your component tree can turn these
- * otherwise-silent rollbacks into toasts or banners. The callback is held in a
- * ref, so re-renders do not tear down and re-create the underlying
- * subscription.
- *
- * @example
- * function MutationFailureBoundary() {
- *   useMutationFailureListener(({ transaction, error }) => {
- *     toast.error(`Couldn't save ${transaction.modelName}: ${error.message}`);
- *   });
- *   return null;
- * }
- */
-export declare function useMutationFailureListener(listener: (payload: MutationFailurePayload) => void): void;