@abloatai/ablo 0.5.1 → 0.6.0

package/dist/mutators/mutateActions.d.ts

@@ -0,0 +1,44 @@
+import type { Schema, InferModel, InferCreate } from '../schema/schema.js';
+import type { SyncStoreContract } from '../react/context.js';
+/**
+ * `create` / `update` / `delete` are overloaded: pass one row or an array
+ * (Drizzle/Prisma `values(rowOrRows)` shape). Every entry in an array call
+ * lands in the same synchronous tick (`Promise.all`), so the microtask
+ * coalescer in `TransactionQueue` collapses N pushes into one wire commit.
+ *
+ * This module is the React-free core of CRUD staging. The transaction system
+ * (`Transaction` / `RecordingTransaction`) and `BaseSyncedStore` build on it;
+ * there is no React hook here (the legacy `useMutate` hook was removed —
+ * callers use `ablo.<model>.create/update/delete`).
+ */
+type UpdatePatch<S extends Schema, K extends keyof S['models'] & string> = {
+    id: string;
+} & Partial<InferModel<S, K>>;
+export interface MutateActions<S extends Schema, K extends keyof S['models'] & string> {
+    /**
+     * Create one entity, or an array of entities in a single tick. ID,
+     * createdAt, updatedAt, organizationId default automatically per row.
+     */
+    create(data: InferCreate<S, K>): Promise<InferModel<S, K>>;
+    create(data: InferCreate<S, K>[]): Promise<InferModel<S, K>[]>;
+    /**
+     * Update one row, or an array of rows in a single tick. Each patch is
+     * `{ id, ...changes }` — missing ids throw. Schema-generated models are
+     * MobX-observable, so direct assignment fires reactivity.
+     */
+    update(patch: UpdatePatch<S, K>): Promise<InferModel<S, K>>;
+    update(patches: UpdatePatch<S, K>[]): Promise<InferModel<S, K>[]>;
+    /**
+     * Delete one row by id, or an array of ids in a single tick. Missing ids
+     * are silently ignored.
+     */
+    delete(id: string): Promise<void>;
+    delete(ids: string[]): Promise<void>;
+    /** Soft-archive by ID. */
+    archive: (id: string) => Promise<void>;
+    /** Restore an archived entity by ID. */
+    unarchive: (id: string) => Promise<void>;
+}
+/** Pure factory — builds CRUD actions over a store for one model. React-free. */
+export declare function createMutateActions<S extends Schema, K extends keyof S['models'] & string>(schema: S, modelKey: K, store: SyncStoreContract, organizationId: string): MutateActions<S, K>;
+export {};

package/dist/{react/useMutate.js → mutators/mutateActions.js}

@@ -1,12 +1,6 @@
-'use client';
-import { useMemo } from 'react';
 import { Model, modelAsRow } from '../Model.js';
 import { AbloValidationError } from '../errors.js';
-import { useSyncContext } from './context.js';
-/**
- * Pure factory — testable without React. The hook just wraps this in
- * useMemo with the React context.
- */
+/** Pure factory — builds CRUD actions over a store for one model. React-free. */
 export function createMutateActions(schema, modelKey, store, organizationId) {
     const modelDef = schema.models[modelKey];
     const typename = modelDef?.typename ?? modelKey;
@@ -25,7 +19,7 @@ export function createMutateActions(schema, modelKey, store, organizationId) {
         };
         const model = store.pool.createFromData(fullData);
         if (!model) {
-            throw new AbloValidationError(`useMutate: failed to create ${typename} — no constructor in registry`, { code: 'mutate_create_unknown_model' });
+            throw new AbloValidationError(`createMutateActions: failed to create ${typename} — no constructor in registry`, { code: 'mutate_create_unknown_model' });
         }
         return model;
     };
@@ -34,14 +28,13 @@ export function createMutateActions(schema, modelKey, store, organizationId) {
         const { id, ...changes } = patch;
         const model = store.pool.get(id);
         if (!model) {
-            throw new AbloValidationError(`useMutate: ${typename} with id "${id}" not found in pool`, { code: 'mutate_update_entity_not_found' });
+            throw new AbloValidationError(`createMutateActions: ${typename} with id "${id}" not found in pool`, { code: 'mutate_update_entity_not_found' });
         }
-        // Schema-derived patch keys are validated at the call-site type
-        // signature (`UpdatePatch<S, K>`); writes here are dynamic-class
-        // field assignments. `Reflect.set` is the typed bridge — Model
-        // doesn't carry an index signature for arbitrary string keys, but
-        // the dynamic field installation in `createDynamicModelClass`
-        // guarantees these keys resolve at runtime.
+        // Schema-derived patch keys are validated at the call-site type signature
+        // (`UpdatePatch<S, K>`); writes here are dynamic-class field assignments.
+        // `Reflect.set` is the typed bridge — Model carries no index signature, but
+        // the dynamic field installation in `createDynamicModelClass` guarantees
+        // these keys resolve at runtime.
         for (const [fieldName, value] of Object.entries(changes)) {
             Reflect.set(model, fieldName, value);
         }
@@ -49,9 +42,9 @@ export function createMutateActions(schema, modelKey, store, organizationId) {
         return model;
     };
     return {
-        // Overloaded — runtime check on `Array.isArray` decides shape. Both
-        // branches stage via `Promise.all` so the microtask coalescer in
-        // `TransactionQueue` collapses N pushes into one wire commit.
+        // Overloaded — runtime `Array.isArray` decides shape. Both branches stage
+        // via `Promise.all` so the microtask coalescer collapses N pushes into one
+        // wire commit.
         create: (async (data) => {
             const now = new Date();
             if (Array.isArray(data)) {
@@ -110,13 +103,3 @@ export function createMutateActions(schema, modelKey, store, organizationId) {
         },
     };
 }
-export function useMutate(schemaOrKey, maybeKey) {
-    const { store, organizationId, schema: ctxSchema } = useSyncContext();
-    const resolvedSchema = typeof schemaOrKey === 'string' ? ctxSchema : schemaOrKey;
-    const resolvedKey = typeof schemaOrKey === 'string' ? schemaOrKey : maybeKey;
-    if (!resolvedSchema) {
-        throw new AbloValidationError('useMutate: no schema available. Pass the schema as the first arg ' +
-            'or wire SyncProvider with a `schema` prop when using the zero-arg overload.', { code: 'mutate_schema_missing' });
-    }
-    return useMemo(() => createMutateActions(resolvedSchema, resolvedKey, store, organizationId), [store, organizationId, resolvedSchema, resolvedKey]);
-}

package/dist/mutators/readerActions.d.ts

@@ -0,0 +1,32 @@
+import type { Schema, InferModel } from '../schema/schema.js';
+import type { SyncStoreContract } from '../react/context.js';
+/**
+ * React-free imperative reads over a store: one-off `retrieve`/`list`/`count`
+ * snapshots that do NOT subscribe to changes. Used by the transaction system
+ * and `BaseSyncedStore`. For reactive reads in components use
+ * `useAblo((ablo) => ablo.<model>.retrieve(id) / .list(opts))`.
+ */
+export interface ReaderFindOptions<T> {
+    /** Equality filter — uses FK index when the field is registered. */
+    where?: Partial<T>;
+    /** Predicate applied AFTER `where` filtering. */
+    filter?: (entity: T) => boolean;
+    /** Sort field. */
+    orderBy?: keyof T & string;
+    /** Sort direction. Default: 'asc'. */
+    order?: 'asc' | 'desc';
+    /** Max results. */
+    limit?: number;
+    /** Skip N results. */
+    offset?: number;
+}
+export interface ReaderActions<S extends Schema, K extends keyof S['models'] & string> {
+    /** Get a single entity by id. Returns undefined if not in pool. */
+    retrieve: (id: string) => InferModel<S, K> | undefined;
+    /** Read a collection with optional filters. Snapshot — not reactive. */
+    list: (options?: ReaderFindOptions<InferModel<S, K>>) => InferModel<S, K>[];
+    /** Count entities matching the options. */
+    count: (options?: ReaderFindOptions<InferModel<S, K>>) => number;
+}
+/** Pure factory — builds imperative read actions over a store for one model. */
+export declare function createReaderActions<S extends Schema, K extends keyof S['models'] & string>(schema: S, modelKey: K, store: SyncStoreContract): ReaderActions<S, K>;

package/dist/{react/useReader.js → mutators/readerActions.js}

@@ -1,15 +1,9 @@
-'use client';
-import { useMemo } from 'react';
-import { useSyncContext } from './context.js';
-import { AbloValidationError } from '../errors.js';
-/**
- * Pure factory — testable without React. `useReader` wraps this in useMemo.
- */
+/** Pure factory — builds imperative read actions over a store for one model. */
 export function createReaderActions(schema, modelKey, store) {
     const modelDef = schema.models[modelKey];
     const typename = modelDef?.typename ?? modelKey;
     function read(options) {
-        // FK index fast path: single-field `where` on a registered FK index → O(1) lookup.
+        // FK index fast path: single-field `where` on a registered FK index → O(1).
         let candidates;
         const whereEntries = options?.where ? Object.entries(options.where) : [];
         const singleWhere = whereEntries.length === 1 ? whereEntries[0] : undefined;
@@ -61,13 +55,3 @@ export function createReaderActions(schema, modelKey, store) {
         count: (options) => read(options).length,
     };
 }
-export function useReader(schemaOrKey, maybeKey) {
-    const { store, schema: ctxSchema } = useSyncContext();
-    const resolvedSchema = typeof schemaOrKey === 'string' ? ctxSchema : schemaOrKey;
-    const resolvedKey = typeof schemaOrKey === 'string' ? schemaOrKey : maybeKey;
-    if (!resolvedSchema) {
-        throw new AbloValidationError('useReader: no schema available. Pass the schema as the first arg ' +
-            'or wire SyncProvider with a `schema` prop when using the zero-arg overload.', { code: 'reader_schema_missing' });
-    }
-    return useMemo(() => createReaderActions(resolvedSchema, resolvedKey, store), [store, resolvedSchema, resolvedKey]);
-}

package/dist/query/types.d.ts

@@ -135,7 +135,7 @@ export interface QueryBatchResult {
      */
     results: unknown[];
     /**
-     * Server watermark observed after the batch ran. Public resource reads
+     * Server watermark observed after the batch ran. Public model reads
      * expose this as `stamp` and callers thread it into `commits.create({
      * readAt })` to reject stale writes.
      */

package/dist/react/AbloProvider.d.ts

@@ -212,7 +212,7 @@ export declare function useParticipant(opts: UseParticipantOptions): UseParticip
 /**
  * Returns the raw `SyncEngine` proxy. Typically you want the typed
  * hooks (`useQuery`, `useOne`, `useMutate`) — this is for rare cases
- * where you need direct access (e.g., `sync.tasks.subscribe(cb)`).
+ * where you need direct access (e.g., `sync.tasks.onChange(cb)`).
  *
  * The generic parameter narrows the return type to your schema's
  * model record so call sites get typed `sync.tasks.findMany()` /

package/dist/react/AbloProvider.js

@@ -326,10 +326,10 @@ export function useParticipant(opts) {
         }
         setPeers(participant.presence.others);
         setClaims(participant.intents.others);
-        const unsubPresence = participant.presence.subscribe(() => {
+        const unsubPresence = participant.presence.onChange(() => {
             setPeers(participant.presence.others);
         });
-        const unsubIntents = participant.intents.subscribe(() => {
+        const unsubIntents = participant.intents.onChange(() => {
             setClaims(participant.intents.others);
         });
         return () => {
@@ -347,7 +347,7 @@ export function useParticipant(opts) {
 /**
  * Returns the raw `SyncEngine` proxy. Typically you want the typed
  * hooks (`useQuery`, `useOne`, `useMutate`) — this is for rare cases
- * where you need direct access (e.g., `sync.tasks.subscribe(cb)`).
+ * where you need direct access (e.g., `sync.tasks.onChange(cb)`).
  *
  * The generic parameter narrows the return type to your schema's
  * model record so call sites get typed `sync.tasks.findMany()` /

package/dist/react/context.d.ts

@@ -85,14 +85,14 @@ export interface SyncReactContext {
      * The stored reference is untyped here (`Schema` with default
      * parameters) because the React context is a single runtime value
      * shared by every hook. The compile-time types flow from the
-     * consumer's `declare global { interface AbloSync { Schema: ... } }`
+     * consumer's `declare module '@abloatai/ablo' { interface Register { Schema: ... } }`
      * augmentation — see `src/types/global.ts`.
      */
     schema?: Schema;
     /**
      * Optional presence source. When set, `usePresence()` returns this
      * value cast to the consumer's `ResolvePresence` type (declared via
-     * `interface AbloSync { Presence: ... }`). The SDK doesn't own a
+     * `interface Register { Presence: ... }`). The SDK doesn't own a
      * presence wire format — consumers plug whatever backs their cursors,
      * status, or activity state (a MobX store, a Zustand slice, a custom
      * subscription). The typed-global gives it a call-site-ergonomic
@@ -104,7 +104,7 @@ export interface SyncReactContext {
      * plug a function that turns an intent claim into a handle they
      * control (WebSocket send, optimistic local update, whatever).
      * `useIntent(name)` returns a typed invoker for the named intent
-     * from `interface AbloSync { Intents: ... }`.
+     * from `interface Register { Intents: ... }`.
      */
     beginIntent?: (intentName: string, claim: unknown) => unknown;
 }
@@ -125,7 +125,7 @@ export interface SyncProviderProps {
     /**
      * Optional schema. Wire this when you want compatibility string-keyed hooks
      * (`useQuery('tasks')`) — the schema type also narrows via the
-     * consumer's global `AbloSync` declaration. Omit to keep hooks on
+     * consumer's `Register` registration. Omit to keep hooks on
      * their legacy `(schema, modelKey, …)` signatures.
      */
     schema?: Schema;

package/dist/react/index.d.ts

@@ -15,8 +15,8 @@
  * Data hooks:
  *   useAblo((ablo) => ablo.tasks.retrieve(id)) — primary React read API
  *   useAblo()                                  — typed client for callbacks/effects
- *   useQuery/useOne/useReader/useMutate        — compatibility helpers for older
- *                                                string-keyed integrations
+ *                                                (reads: ablo.<model>.retrieve/list;
+ *                                                 writes: ablo.<model>.create/update/delete)
  *   useMutators(defs, opts?)                   — Zero-style custom mutators
  *   useUndoScope(name)                         — per-surface undo/redo
  *
@@ -53,9 +53,8 @@ export { useErrorListener } from './useErrorListener.js';
 export { useMutationFailureListener, type MutationFailurePayload, } from './useMutationFailureListener.js';
 export { useCurrentUserId } from './useCurrentUserId.js';
 export { useReactive } from './useReactive.js';
-export { useQuery, useOne, type QueryOptions } from './useQuery.js';
-export { useMutate, type MutateActions } from './useMutate.js';
-export { useReader, type ReaderActions, type ReaderFindOptions } from './useReader.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';

package/dist/react/index.js

@@ -15,8 +15,8 @@
  * Data hooks:
  *   useAblo((ablo) => ablo.tasks.retrieve(id)) — primary React read API
  *   useAblo()                                  — typed client for callbacks/effects
- *   useQuery/useOne/useReader/useMutate        — compatibility helpers for older
- *                                                string-keyed integrations
+ *                                                (reads: ablo.<model>.retrieve/list;
+ *                                                 writes: ablo.<model>.create/update/delete)
  *   useMutators(defs, opts?)                   — Zero-style custom mutators
  *   useUndoScope(name)                         — per-surface undo/redo
  *
@@ -59,14 +59,10 @@ export { useCurrentUserId } from './useCurrentUserId.js';
 // lower-level `useSyncExternalStore`. Hides the cached-snapshot
 // contract and handles default structural equality for arrays.
 export { useReactive } from './useReactive.js';
-// ── Data hooks ─────────────────────────────────────────────────────
-export { useQuery, useOne } from './useQuery.js';
-export { useMutate } from './useMutate.js';
-export { useReader } from './useReader.js';
 export { useMutators, } from './useMutators.js';
 export { useUndoScope } from './useUndoScope.js';
 export { useAblo, } from './useAblo.js';
-// ── Presence + intent (typed via AbloSync global augmentation) ─────
+// ── Presence + intent (typed via Register module augmentation) ─────
 export { usePresence } from './usePresence.js';
 export { useIntent } from './useIntent.js';
 // ── ModelScope re-export ───────────────────────────────────────────

package/dist/react/useAblo.d.ts

@@ -1,10 +1,10 @@
-import type { Ablo, ResourceIntent } from '../client/Ablo.js';
+import type { Ablo, 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';
 /**
  * Resolved schema-record type for the consumer's app. Reads the
- * `AbloSync` global augmentation if declared, falls back to the
+ * `Register` module augmentation if declared, falls back to the
  * loose `SchemaRecord` if not. This lets `useAblo()` produce a
  * fully typed engine handle without the consumer having to pass
  * `<(typeof schema)['models']>` at every call site.
@@ -12,12 +12,12 @@ import type { ResolveSchema } from '../types/global.js';
 type DefaultModels = ResolveSchema extends {
     models: infer M;
 } ? M extends SchemaRecord ? M : SchemaRecord : SchemaRecord;
-type ModelResourceSelector<R extends SchemaRecord, T, C> = (ablo: Ablo<R>) => ModelOperations<T, C>;
+type ModelClientSelector<R extends SchemaRecord, T, C> = (ablo: Ablo<R>) => ModelOperations<T, C>;
 type AbloSelector<R extends SchemaRecord, T> = (ablo: Ablo<R>) => T;
 export interface UseAbloModelOptions<T> {
     /**
      * Initial row, usually from a Server Component or loader. The hook returns it
-     * until the model resource has a newer row in the local pool.
+     * until the model client has a newer row in the local pool.
      */
     readonly initial?: T;
 }
@@ -25,9 +25,9 @@ export interface UseAbloModelResult<T> {
     /** Current row for the id, or `initial` until the row has hydrated. */
     readonly data: T | undefined;
     /** Active work claims on this model row. */
-    readonly intents: readonly ResourceIntent[];
+    readonly claims: readonly ModelClaim[];
     /** Convenience flag for disabling UI while another participant is active. */
-    readonly busy: boolean;
+    readonly claimed: boolean;
 }
 export type UseAbloHydratedModelResult<T> = Omit<UseAbloModelResult<T>, 'data'> & {
     readonly data: T;
@@ -36,20 +36,20 @@ export type UseAbloHydratedModelResult<T> = Omit<UseAbloModelResult<T>, 'data'>
  * useAblo — access the typed engine instance, or subscribe to a specific
  * `ablo.<model>` row from inside an `<AbloProvider>` subtree.
  *
- * Zero-arg when the consumer declares the `AbloSync` global
- * augmentation (`declare global { interface AbloSync { Schema:
+ * Zero-arg when the consumer declares the `Register` global
+ * augmentation (`declare module '@abloatai/ablo' { interface Register { Schema:
  * typeof schema } }`). The default generic resolves through
  * `ResolveSchema['models']` so call sites stay clean:
  *
  * ```ts
- * // With AbloSync augmentation (recommended):
+ * // With Register augmentation (recommended):
  * const ablo = useAblo();
  * if (!ablo) return <Loading />;
  * const docs = await ablo.documents.load({ where: { id } });
  *
  * // Reactive selector:
  * const doc = useAblo((ablo) => ablo.documents.retrieve(id)) ?? serverDoc;
- * const intents = useAblo((ablo) => ablo.intents.list({ resource: 'documents', id }));
+ * const active = useAblo((ablo) => ablo.documents.claimState(id));
  *
  * // Without augmentation, pass the schema generic:
  * const ablo = useAblo<(typeof schema)['models']>();
@@ -61,12 +61,12 @@ export type UseAbloHydratedModelResult<T> = Omit<UseAbloModelResult<T>, 'data'>
  */
 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>(resource: ModelOperations<T, C>, id: string, options: UseAbloModelOptions<T> & {
+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: ModelResourceSelector<R, T, C>, id: string, options: UseAbloModelOptions<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>(resource: 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: ModelResourceSelector<R, T, C>, id: string, options?: UseAbloModelOptions<T>): UseAbloModelResult<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,20 +1,20 @@
 'use client';
 import { useContext, useEffect, useState } from 'react';
 import { AbloInternalContext } from './internalContext.js';
-import { getModelResourceMeta } from '../client/createModelProxy.js';
+import { getModelClientMeta } from '../client/createModelProxy.js';
 import { Model, modelAsRow } from '../Model.js';
 import { useReactive } from './useReactive.js';
-const EMPTY_INTENTS = Object.freeze([]);
-function readModelResult(engine, resource, id, initial) {
-    if (!resource || id === undefined) {
-        return { data: initial, intents: EMPTY_INTENTS, busy: false };
+const EMPTY_CLAIMS = Object.freeze([]);
+function readModelResult(engine, modelClient, id, initial) {
+    if (!modelClient || id === undefined) {
+        return { data: initial, claims: EMPTY_CLAIMS, claimed: false };
     }
-    const data = snapshotValue(resource.retrieve(id) ?? initial);
-    const meta = getModelResourceMeta(resource);
-    const intents = meta && engine
-        ? engine.intents.list({ resource: meta.key, id })
-        : EMPTY_INTENTS;
-    return { data, intents, busy: intents.length > 0 };
+    const data = snapshotValue(modelClient.retrieve(id) ?? initial);
+    const meta = getModelClientMeta(modelClient);
+    const claims = meta && engine
+        ? engine.intents.list({ model: meta.key, id })
+        : EMPTY_CLAIMS;
+    return { data, claims, claimed: claims.length > 0 };
 }
 function snapshotValue(value) {
     if (value instanceof Model) {
@@ -25,39 +25,39 @@ function snapshotValue(value) {
     }
     return value;
 }
-export function useAblo(resourceOrSelect, id, options) {
+export function useAblo(modelOrSelect, id, options) {
     const ctx = useContext(AbloInternalContext);
     const engine = ctx?.engine ?? null;
     const initial = options?.initial;
-    const hasSelection = resourceOrSelect !== undefined;
-    const isSelectorOnly = typeof resourceOrSelect === 'function' && id === undefined;
-    const resource = typeof resourceOrSelect === 'function' && id !== undefined
+    const hasSelection = modelOrSelect !== undefined;
+    const isSelectorOnly = typeof modelOrSelect === 'function' && id === undefined;
+    const modelClient = typeof modelOrSelect === 'function' && id !== undefined
         ? engine
-            ? resourceOrSelect(engine)
+            ? modelOrSelect(engine)
             : undefined
-        : typeof resourceOrSelect === 'function'
+        : typeof modelOrSelect === 'function'
             ? undefined
-            : resourceOrSelect;
-    const [intentVersion, setIntentVersion] = useState(0);
+            : modelOrSelect;
+    const [claimVersion, setClaimVersion] = useState(0);
     useEffect(() => {
         if (!engine || !hasSelection)
             return;
-        return engine.intents.subscribe(() => setIntentVersion((version) => version + 1));
+        return engine.intents.onChange(() => setClaimVersion((version) => version + 1));
     }, [engine, hasSelection]);
     const selected = useReactive(() => {
-        void intentVersion;
-        if (!engine || !isSelectorOnly || typeof resourceOrSelect !== 'function') {
+        void claimVersion;
+        if (!engine || !isSelectorOnly || typeof modelOrSelect !== 'function') {
             return undefined;
         }
-        return snapshotValue(resourceOrSelect(engine));
+        return snapshotValue(modelOrSelect(engine));
     });
     const modelResult = useReactive(() => {
-        void intentVersion;
-        return readModelResult(engine, resource, id, initial);
+        void claimVersion;
+        return readModelResult(engine, modelClient, id, initial);
     });
     if (isSelectorOnly)
         return selected;
-    if (resourceOrSelect)
+    if (modelOrSelect)
         return modelResult;
     return engine;
 }

package/dist/react/useIntent.d.ts

@@ -5,8 +5,8 @@ import type { ResolveIntents } from '../types/global.js';
  * The consumer declares their intent vocabulary in the global:
  *
  * ```ts
- * declare global {
- *   interface AbloSync {
+ * declare module '@abloatai/ablo' {
+ *   interface Register {
  *     Intents: {
  *       editLayer: { slideId: string; layerId: string };
  *       generateWithAI: { entityId: string; tool: string };

package/dist/react/useIntent.js

@@ -8,8 +8,8 @@ import { AbloValidationError } from '../errors.js';
  * The consumer declares their intent vocabulary in the global:
  *
  * ```ts
- * declare global {
- *   interface AbloSync {
+ * declare module '@abloatai/ablo' {
+ *   interface Register {
  *     Intents: {
  *       editLayer: { slideId: string; layerId: string };
  *       generateWithAI: { entityId: string; tool: string };

package/dist/react/useMutators.d.ts

@@ -50,7 +50,7 @@ export interface UseMutatorsOptions<S extends Schema> {
 }
 /** Mutator invokers (explicit schema arg). */
 export declare function useMutators<S extends Schema, M extends MutatorDefs<S>>(schema: S, mutators: M, options?: UseMutatorsOptions<S>): MutatorInvokers<M>;
-/** Mutator invokers via the `AbloSync` global augmentation. Schema comes
+/** Mutator invokers via the `Register` module augmentation. Schema comes
  * from the `SyncProvider`'s context; the mutator tree is typed against
  * `ResolveSchema` at the call site. */
 export declare function useMutators<M extends ResolveSchema extends Schema ? MutatorDefs<ResolveSchema> : MutatorDefs<Schema>>(mutators: M, options?: UseMutatorsOptions<ResolveSchema extends Schema ? ResolveSchema : Schema>): MutatorInvokers<M>;

package/dist/react/usePresence.d.ts

@@ -2,7 +2,7 @@ import type { ResolvePresence } from '../types/global.js';
 /**
  * Read the consumer-supplied presence state with `ResolvePresence`d
  * typing — the shape the consumer declared in
- * `declare global { interface AbloSync { Presence: ... } }`.
+ * `declare module '@abloatai/ablo' { interface Register { Presence: ... } }`.
  *
  * The SDK doesn't own a presence wire format. Consumers plug whatever
  * backs their cursors, status, or activity (a MobX store, a custom
@@ -11,8 +11,8 @@ import type { ResolvePresence } from '../types/global.js';
  *
  * ```ts
  * // apps/your-app/src/ablo-sync.d.ts
- * declare global {
- *   interface AbloSync {
+ * declare module '@abloatai/ablo' {
+ *   interface Register {
  *     Presence: { cursor: { x: number; y: number } | null; status: 'away' | 'online' };
  *   }
  * }

package/dist/react/usePresence.js

@@ -3,7 +3,7 @@ import { useSyncContext } from './context.js';
 /**
  * Read the consumer-supplied presence state with `ResolvePresence`d
  * typing — the shape the consumer declared in
- * `declare global { interface AbloSync { Presence: ... } }`.
+ * `declare module '@abloatai/ablo' { interface Register { Presence: ... } }`.
  *
  * The SDK doesn't own a presence wire format. Consumers plug whatever
  * backs their cursors, status, or activity (a MobX store, a custom
@@ -12,8 +12,8 @@ import { useSyncContext } from './context.js';
  *
  * ```ts
  * // apps/your-app/src/ablo-sync.d.ts
- * declare global {
- *   interface AbloSync {
+ * declare module '@abloatai/ablo' {
+ *   interface Register {
  *     Presence: { cursor: { x: number; y: number } | null; status: 'away' | 'online' };
  *   }
  * }
@@ -35,7 +35,7 @@ export function usePresence() {
     // The runtime value is whatever the consumer passed to `SyncProvider`.
     // The type assertion reflects the consumer's declared global, which
     // the hook can't verify at runtime — but the consumer controls both
-    // ends (the global declaration and the provider prop) so this is a
+    // ends (the registration and the provider prop) so this is a
     // single-source-of-truth contract, not blind trust.
     return ctx.presence;
 }

package/dist/react/useUndoScope.d.ts

@@ -32,5 +32,5 @@ export interface UseUndoScopeResult<S extends Schema> {
 }
 /** Per-surface undo/redo (explicit schema arg). */
 export declare function useUndoScope<S extends Schema>(schema: S, name: string, options?: UndoScopeOptions): UseUndoScopeResult<S>;
-/** Per-surface undo/redo via the `AbloSync` global augmentation. */
+/** Per-surface undo/redo via the `Register` module augmentation. */
 export declare function useUndoScope(name: string, options?: UndoScopeOptions): UseUndoScopeResult<ResolveSchema extends Schema ? ResolveSchema : Schema>;