@abloatai/ablo 0.34.1 → 0.36.0

package/dist/react/AbloProvider.d.ts

@@ -1,7 +1,7 @@
 import { type ReactNode } from 'react';
-import type { SchemaRecord } from '../schema/schema.js';
+import type { SchemaRecord } from '../transaction/schema/schema.js';
 import { Ablo } from '../client/Ablo.js';
-import type { Claim, Peer } from '../types/streams.js';
+import type { Claim, Duration, Peer } from '../transaction/types/streams.js';
 import type { EngineParticipant, ParticipantScope, ParticipantStatus } from '../sync/participants.js';
 import { type SyncStoreContract } from './context.js';
 /**
@@ -116,6 +116,18 @@ export type { EngineParticipant, ParticipantScope, ParticipantStatus };
  */
 export interface UseJoinOptions {
     readonly scope?: ParticipantScope;
+    /**
+     * Lease TTL for the participant claim, as a compact duration (`'5m'`) or a
+     * number of seconds. The same dial and the same spelling as
+     * `ablo.<model>.join(ids, { ttl })` and every other lease in the SDK.
+     */
+    readonly ttl?: Duration;
+    /**
+     * @deprecated Use `ttl`. Removed in 0.37.0.
+     *
+     * The same rename as on `ParticipantJoinOptions`: one lease, and the seconds
+     * spelling was the one that misled, because it accepted duration strings too.
+     */
     readonly ttlSeconds?: number | string | null;
     /** Tear down + don't re-join while true. */
     readonly paused?: boolean;
@@ -125,7 +137,7 @@ export interface UseJoinOptions {
      * Default `false`: opening a scope subscribes the connection to its deltas
      * (read interest, via `update_subscription`) but does NOT claim it — a
      * viewer is not a claimant. Set `true` when the participant intends to
-     * WRITE (editing a deck, an agent staking work): the claim is sent so peers
+     * WRITE (editing a report, an agent staking work): the claim is sent so peers
      * observe it, and the scope is pinned so it stays subscribed (never warms)
      * for as long as the claim is held.
      */
@@ -137,14 +149,12 @@ export interface UseJoinOptions {
      * Default `false`: entering a scope subscribes to its FUTURE deltas only — if
      * the scope's rows aren't already loaded, the view is empty until something
      * changes. Set `true` when opening an entity that may not be loaded yet (a
-     * deep-linked deck, a never-opened sheet) so its current rows are fetched and
+     * deep-linked report, a never-opened ledger) so its current rows are fetched and
      * injected once, then kept fresh by the live tail. The fetch is single-flight
      * and runs once per group; a failure soft-fails (the live tail still flows).
      */
     readonly hydrate?: boolean;
 }
-/** @deprecated Use `ParticipantStatus`. */
-export type MeshParticipantStatus = ParticipantStatus;
 export interface UseJoinReturn {
     readonly participant: EngineParticipant | null;
     /** Everyone else on the engine's sync groups (`participant.presence.others`), bridged to React. */
@@ -188,7 +198,7 @@ export declare function useJoin(opts: UseJoinOptions): UseJoinReturn;
  * subscription on unmount).
  *
  * ```ts
- * const peers = usePeers({ slideDecks: deckId });
+ * const peers = usePeers({ reports: reportId });
  * const alone = !peers.some((p) => p.participantKind === 'user');
  * ```
  */
@@ -200,7 +210,7 @@ export declare function usePeers(scope?: ParticipantScope): readonly Peer[];
  *
  * The generic parameter narrows the return type to your schema's
  * model record so call sites get typed `sync.tasks.findMany()` /
- * `sync.slides.create(...)` without a cast at the call site:
+ * `sync.sections.create(...)` without a cast at the call site:
  *
  * ```ts
  * const sync = useSync<(typeof schema)['models']>();

package/dist/react/AbloProvider.js

@@ -5,7 +5,7 @@ import { Ablo } from '../client/Ablo.js';
 import { createParticipantClaimId, parseParticipantTtlSeconds, resolveParticipantSyncGroups, } from '../sync/participants.js';
 import { SyncContext } from './context.js';
 import { AbloInternalContext } from './internalContext.js';
-import { AbloValidationError } from '../errors.js';
+import { AbloValidationError } from '../transaction/errors.js';
 import { useSyncStatus } from './useSyncStatus.js';
 import { DefaultFallback } from './DefaultFallback.js';
 // ── Implementation ───────────────────────────────────────────────────
@@ -224,8 +224,8 @@ export function useJoin(opts) {
     const ctx = useContext(AbloInternalContext);
     const engine = ctx?.engine ?? null;
     const { paused = false } = opts;
-    // Resolve the model-form scope ({ decks: id } / refs) THROUGH the schema, so a
-    // model's declared `scope` kind is honored (typename `SlideDeck` → `deck:<id>`,
+    // Resolve the model-form scope ({ reports: id } / refs) THROUGH the schema, so a
+    // model's declared `scope` kind is honored (typename `Report` → `report:<id>`,
     // not the `type:id` string fallback). Schema appears once the engine is ready;
     // until then refs resolve by convention, then re-resolve when it arrives.
     const scopeKey = JSON.stringify(resolveParticipantSyncGroups(opts.scope, engine?.schema).sort());
@@ -298,13 +298,13 @@ export function useJoin(opts) {
         if (syncStatus.name !== 'connected')
             return;
         const ws = engine._ws;
-        if (!ws)
-            return;
         const store = engine._store;
         let cancelled = false;
         const claimId = createParticipantClaimId();
         ws.sendClaim(claimId, scopedSyncGroups, {
-            ttlSeconds: parseParticipantTtlSeconds(opts.ttlSeconds),
+            // Reading the retired spelling IS the compatibility path; it goes at 0.37.0.
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            ttlSeconds: parseParticipantTtlSeconds(opts.ttl ?? opts.ttlSeconds),
         })
             .then(() => {
             if (!cancelled)
@@ -322,7 +322,8 @@ export function useJoin(opts) {
             ws.sendRelease(claimId);
             void store.unpinScope?.(scope);
         };
-    }, [engine, paused, scopeKey, syncStatus.name, opts.ttlSeconds, opts.claim]);
+        // eslint-disable-next-line @typescript-eslint/no-deprecated -- same compatibility read as above.
+    }, [engine, paused, scopeKey, syncStatus.name, opts.ttl, opts.ttlSeconds, opts.claim]);
     // Bridge the engine's presence + claims streams into React state.
     // Plain useState + useEffect is sufficient — mid-frame tearing on a
     // peer list is harmless (users won't notice one frame of stale
@@ -370,7 +371,7 @@ export function useJoin(opts) {
  * subscription on unmount).
  *
  * ```ts
- * const peers = usePeers({ slideDecks: deckId });
+ * const peers = usePeers({ reports: reportId });
  * const alone = !peers.some((p) => p.participantKind === 'user');
  * ```
  */
@@ -408,7 +409,7 @@ export function usePeers(scope) {
  *
  * The generic parameter narrows the return type to your schema's
  * model record so call sites get typed `sync.tasks.findMany()` /
- * `sync.slides.create(...)` without a cast at the call site:
+ * `sync.sections.create(...)` without a cast at the call site:
  *
  * ```ts
  * const sync = useSync<(typeof schema)['models']>();

package/dist/react/context.d.ts

@@ -1,7 +1,7 @@
 import { type ReactNode } from 'react';
-import type { Schema } from '../schema/schema.js';
-import type { SyncStoreContract } from '../core/storeContract.js';
-export type { SyncStoreContract, LocalMutation } from '../core/storeContract.js';
+import type { Schema } from '../transaction/schema/schema.js';
+import type { SyncStoreContract } from '../storeContract.js';
+export type { SyncStoreContract, LocalMutation } from '../storeContract.js';
 export interface SyncReactContext {
     store: SyncStoreContract;
     /** The organization id used as the default scope for reads and writes. */

package/dist/react/context.js

@@ -1,6 +1,6 @@
 'use client';
 import { createContext, createElement, useContext } from 'react';
-import { AbloValidationError } from '../errors.js';
+import { AbloValidationError } from '../transaction/errors.js';
 export const SyncContext = createContext(null);
 /**
  * Reads the sync store context from inside a provider subtree, throwing a clear

package/dist/react/createAbloReact.d.ts

@@ -0,0 +1,56 @@
+/**
+ * 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

@@ -0,0 +1,51 @@
+'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

@@ -21,9 +21,9 @@
  *
  * # Data hooks
  *
- *   useAblo((ablo) => ablo.tasks.get(id))  — subscribe to a local snapshot (the main read API)
+ *   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>.get`/`getAll`),
+ *                                            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
@@ -43,8 +43,8 @@
  *   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, ResolveModelKey, } from '../types/global.js';
-export { AbloProvider, useJoin, usePeers, useSync, useSyncStore, type AbloProviderProps, type ParticipantScope, type ParticipantStatus, type UseJoinOptions, type UseJoinReturn, type MeshParticipantStatus, } from './AbloProvider.js';
+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';
@@ -52,10 +52,11 @@ 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 '../types/index.js';
+export { ModelScope } from '../transaction/types/index.js';

package/dist/react/index.js

@@ -21,9 +21,9 @@
  *
  * # Data hooks
  *
- *   useAblo((ablo) => ablo.tasks.get(id))  — subscribe to a local snapshot (the main read API)
+ *   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>.get`/`getAll`),
+ *                                            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
@@ -52,6 +52,9 @@ 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
@@ -63,4 +66,4 @@ export { useMutators, } from './useMutators.js';
 export { useUndoScope } from './useUndoScope.js';
 export { useAblo, } from './useAblo.js';
 // ── ModelScope re-export ───────────────────────────────────────────
-export { ModelScope } from '../types/index.js';
+export { ModelScope } from '../transaction/types/index.js';

package/dist/react/internalContext.d.ts

@@ -1,5 +1,5 @@
 import type { Ablo } from '../client/Ablo.js';
-import type { SchemaRecord } from '../schema/schema.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,

package/dist/react/useAblo.d.ts

@@ -1,7 +1,7 @@
 import type { Ablo, AbloReads, ModelClaim } from '../client/Ablo.js';
 import type { ModelOperations } from '../client/createModelProxy.js';
-import type { SchemaRecord } from '../schema/schema.js';
-import type { ResolveSchema } from '../types/global.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
@@ -11,8 +11,8 @@ import type { ResolveSchema } from '../types/global.js';
 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 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
@@ -42,6 +42,13 @@ export type UseAbloHydratedModelResult<T> = Omit<UseAbloModelResult<T>, 'data'>
  * 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();
@@ -51,7 +58,7 @@ export type UseAbloHydratedModelResult<T> = Omit<UseAbloModelResult<T>, 'data'>
  * // 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.get(id)) ?? serverDoc;
+ * 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:

package/dist/react/useAblo.js

@@ -15,19 +15,19 @@ 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.
+ * 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 rebindEngine(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.get(id) ?? initial);
+    const data = snapshotValue(modelClient.local.retrieve(id) ?? initial);
     const meta = getModelClientMeta(modelClient);
     const claims = meta && engine
         ? engine.claims.list({ model: meta.key, id })
@@ -55,8 +55,26 @@ function snapshotValue(value) {
     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);
-    const engine = ctx?.engine ?? null;
+    // 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
@@ -98,5 +116,5 @@ export function useAblo(modelOrSelect, id, options) {
         return selected;
     if (modelOrSelect)
         return modelResult;
-    return engine === null ? null : rebindEngine(engine);
+    return engine;
 }

package/dist/react/useCurrentUserId.js

@@ -1,7 +1,7 @@
 'use client';
 import { useContext } from 'react';
 import { AbloInternalContext } from './internalContext.js';
-import { AbloValidationError } from '../errors.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.

package/dist/react/useErrorListener.js

@@ -1,7 +1,7 @@
 'use client';
 import { useContext, useEffect, useRef } from 'react';
 import { AbloInternalContext } from './internalContext.js';
-import { AbloValidationError } from '../errors.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,

package/dist/react/useMutationFailureListener.d.ts

@@ -1,6 +1,6 @@
-import type { Transaction } from '../transactions/TransactionQueue.js';
+import type { QueuedMutation } from '../transactions/mutations/MutationQueue.js';
 export interface MutationFailurePayload {
-    transaction: Transaction;
+    transaction: QueuedMutation;
     error: Error;
     permanent?: boolean;
 }

package/dist/react/useMutationFailureListener.js

@@ -1,7 +1,7 @@
 'use client';
 import { useContext, useEffect, useRef } from 'react';
 import { AbloInternalContext } from './internalContext.js';
-import { AbloValidationError } from '../errors.js';
+import { AbloValidationError } from '../transaction/errors.js';
 /**
  * Subscribes a listener to mutation failures. The callback fires whenever the
  * transaction queue rolls back an optimistic write — both permanent rejections

package/dist/react/useMutators.d.ts

@@ -1,7 +1,7 @@
-import type { Schema } from '../schema/schema.js';
+import type { Schema } from '../transaction/schema/schema.js';
 import type { MutatorDefs } from '../mutators/defineMutators.js';
 import type { UndoScope } from '../mutators/UndoManager.js';
-import type { ResolveSchema } from '../types/global.js';
+import type { ResolveSchema } from '../transaction/types/global.js';
 /**
  * Turns a mutator tree built with `defineMutators` into callable invokers. The
  * returned object mirrors that tree one-to-one, but each leaf becomes an
@@ -41,7 +41,7 @@ export type MutatorInvokers<M> = {
 };
 /**
  * Options passed to `useMutators`. When `undoScope` is set, every mutator
- * invocation is wrapped in a `RecordingTransaction` and its inverses are
+ * invocation is wrapped in a `RecordingMutation` and its inverses are
  * pushed to the scope as one undo entry.
  */
 export interface UseMutatorsOptions<S extends Schema> {

package/dist/react/useMutators.js

@@ -1,9 +1,9 @@
 'use client';
 import { useMemo } from 'react';
 import { createTransaction } from '../mutators/Transaction.js';
-import { createRecordingTransaction } from '../mutators/RecordingTransaction.js';
+import { createRecordingMutation } from '../mutators/RecordingMutation.js';
 import { useSyncContext } from './context.js';
-import { AbloValidationError } from '../errors.js';
+import { AbloValidationError } from '../transaction/errors.js';
 import { getContext } from '../context.js';
 export function useMutators(schemaOrMutators, mutatorsOrOptions, maybeOptions) {
     const { store, organizationId, schema: ctxSchema } = useSyncContext();
@@ -48,7 +48,7 @@ export function useMutators(schemaOrMutators, mutatorsOrOptions, maybeOptions) {
                     // interleave their shared-model snapshots. See UndoScope.runRecorded.
                     if (undoScope) {
                         return undoScope.runRecorded(async () => {
-                            const recording = createRecordingTransaction(schema, store, organizationId);
+                            const recording = createRecordingMutation(schema, store, organizationId);
                             try {
                                 const result = await fn({ tx: recording.tx, args });
                                 const entry = recording.getEntry(label);

package/dist/react/useUndoScope.d.ts

@@ -1,9 +1,9 @@
-import type { Schema } from '../schema/schema.js';
+import type { Schema } from '../transaction/schema/schema.js';
 import type { UndoScope, UndoScopeOptions } from '../mutators/UndoManager.js';
-import type { ResolveSchema } from '../types/global.js';
+import type { ResolveSchema } from '../transaction/types/global.js';
 /**
  * Provides per-surface undo and redo for mutator invocations. Each named scope
- * owns an independent undo/redo stack, so different parts of your app — a deck
+ * owns an independent undo/redo stack, so different parts of your app — a main
  * editor, a sidebar form — can undo separately without stepping on each other.
  *
  * Wire the returned `scope` into `useMutators(schema, mutators, { undoScope:
@@ -12,8 +12,8 @@ import type { ResolveSchema } from '../types/global.js';
  * themselves; the manager moves the entry between the two stacks explicitly.
  *
  * @example
- * const { undo, redo, canUndo, canRedo, scope } = useUndoScope('deck-editor');
- * const mutate = useMutators(schema, deckMutators, { undoScope: scope });
+ * const { undo, redo, canUndo, canRedo, scope } = useUndoScope('report-editor');
+ * const mutate = useMutators(schema, reportMutators, { undoScope: scope });
  *
  * // Cmd+Z handler
  * useHotkey('mod+z', () => { if (canUndo) void undo(); });

package/dist/react/useUndoScope.js

@@ -2,7 +2,7 @@
 import { useEffect, useMemo, useState } from 'react';
 import { UndoManager } from '../mutators/UndoManager.js';
 import { useSyncContext } from './context.js';
-import { AbloValidationError } from '../errors.js';
+import { AbloValidationError } from '../transaction/errors.js';
 // Module-level weak registry: `SyncStoreContract` → `UndoManager`.
 // A single app wiring through one SyncProvider shares one manager across
 // every useUndoScope call, so scopes with the same name are identity-equal.