@abloatai/ablo 0.5.1 → 0.7.0

package/llms.txt

@@ -11,34 +11,26 @@ import Ablo from '@abloatai/ablo';
 import { defineSchema, model, z } from '@abloatai/ablo/schema';
 
 const schema = defineSchema({
-  tasks: model({
+  weatherReports: model({
     id: z.string(),
-    title: z.string(),
-    status: z.enum(['todo', 'doing', 'done']),
-    summary: z.string().optional(),
+    location: z.string(),
+    status: z.enum(['pending', 'ready']),
+    forecast: z.string().optional(),
   }),
 });
 
 const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY });
 
-const [task] = await ablo.tasks.load({ where: { id: 'task_123' } });
-if (!task) throw new Error('Task not found');
-
-const intents = ablo.intents.list({ resource: 'tasks', id: 'task_123' });
-if (intents.length > 0) {
-  await ablo.intents.waitFor({ resource: 'tasks', id: 'task_123' }, { timeout: 30_000 });
-}
-
-const snap = ablo.snapshot({ tasks: 'task_123' });
-const updated = await ablo.tasks.update(
-  'task_123',
-  { status: 'done', summary: await summarize(task) },
-  {
-    readAt: snap.stamp,
-    onStale: 'reject',
-    wait: 'confirmed',
-  },
-);
+const [report] = await ablo.weatherReports.load({ where: { id: 'report_stockholm' } });
+if (!report) throw new Error('Row not found');
+
+const updated = await ablo.weatherReports.claim('report_stockholm', async (report) => {
+  return ablo.weatherReports.update(
+    report.id,
+    { status: 'ready', forecast: await getForecast(report) },
+    { wait: 'confirmed' },
+  );
+});
 ```
 
 That is the normal app path: declare models in a schema, then use `ablo.<model>.load(...)`, `ablo.<model>.retrieve(...)`, `ablo.<model>.create(...)`, `ablo.<model>.update(...)`, and `ablo.<model>.delete(...)`.
@@ -54,7 +46,7 @@ defaults to `'live'`, with `'archived'` and `'all'` for lifecycle-aware reads.
 Advanced schema-less agents exist for workers that cannot import the app schema,
 but do not teach that path first.
 
-React reads should use selector `useAblo`: `useAblo((ablo) => ablo.tasks.retrieve(id))`.
+React reads should use selector `useAblo`: `useAblo((ablo) => ablo.weatherReports.retrieve(id))`.
 Use zero-argument `useAblo()` only when a component needs the client for an
 event handler or effect. Treat `useQuery`, `useOne`, `useReader`, and
 `useMutate` as compatibility hooks for older string-keyed integrations, not the
@@ -64,36 +56,39 @@ first integration path.
 
 Multiplayer is not a separate mode. When human UI, server actions, and agents use
 the same schema client and write through `ablo.<model>`, Ablo coordinates the
-shared resource stream: confirmed deltas fan out to subscribers, active intents
-are visible, and stale writes can be rejected with `readAt`.
+shared model stream: confirmed deltas fan out to subscribers, active claims are
+visible through `claimState(id)`, and stale writes can be rejected with `readAt`.
 
 If an app writes directly to its own database outside Ablo, that write bypasses
 coordination until the app reports it through Data Source events.
 
 ## Nouns
 
-- `Model resource` is the typed `ablo.<model>` object generated from schema.
-- `Intent` declares active work on a resource so humans and agents can coordinate.
+- `Model client` is the typed `ablo.<model>` object generated from schema.
+- `Claim` holds a model row while slow work runs; `claimState(id)` observes it.
 - `Commit` is the durable protocol write behind `ablo.<model>.update(...)`.
 - `Receipt` confirms the commit.
-- `Capability` scopes what an agent may do. `agent.run(...)` handles the common case.
-- `Task` is one agent run, with audit and cost attribution.
 
-## Busy Behavior
+## Claimed Behavior
 
-Reads never silently block. Pass `ifBusy: 'return'` to receive active intents, `ifBusy: 'fail'` to throw `AbloBusyError`, or `ifBusy: 'wait'` to wait until the active intent clears.
+Reads never silently block. Schema reads stay open while a row is claimed.
+Server reads through `ablo.model(name)` can pass `ifClaimed: 'return'` to
+receive active claims, `ifClaimed: 'fail'` to throw `AbloClaimedError`, or
+`ifClaimed: 'wait'` to wait until the active claim clears.
 
-Schema clients wait from the realtime intent stream. Schema-less HTTP callers must provide an explicit `busyPollInterval` when using `ifBusy: 'wait'`; Ablo does not hide a hard-coded polling loop.
+Schema clients wait from the realtime claim stream. Schema-less HTTP callers must provide an explicit `claimedPollInterval` when using `ifClaimed: 'wait'`; Ablo does not hide a hard-coded polling loop.
 
-Use `busyTimeout` only as a maximum wait, not as the coordination mechanism.
+Use `claimedTimeout` only as a maximum wait, not as the coordination mechanism.
 
 ## Guarantees
 
 `wait: 'confirmed'` means the server accepted the write. Schema model writes are optimistic by default; server rejection rolls back local state. Use `snapshot(...)` plus `readAt` and `onStale: 'reject'` to prevent lost updates.
 
-Intents are coordination signals, not database locks. Capabilities and tasks are real protocol primitives, but most users let the SDK manage them through schema-backed writes or advanced `agent.run(...)`.
+Claims coordinate writers; they do not block readers. Most users should stay on
+schema-backed reads/writes and `claim(...)`; do not teach manual protocol
+bookkeeping in the happy path.
 
-All SDK errors extend `AbloError`. Important classes: `AbloBusyError`, `AbloStaleContextError`, `AbloAuthenticationError`, `AbloPermissionError`, `AbloRateLimitError`, `AbloIdempotencyError`, `AbloConnectionError`, `AbloValidationError`, and `AbloServerError`.
+All SDK errors extend `AbloError`. Important classes: `AbloClaimedError`, `AbloStaleContextError`, `AbloAuthenticationError`, `AbloPermissionError`, `AbloRateLimitError`, `AbloIdempotencyError`, `AbloConnectionError`, `AbloValidationError`, and `AbloServerError`.
 
 ## Schema Scope
 
@@ -114,7 +109,7 @@ import { dataSource } from '@abloatai/ablo';
 ## Sandboxes
 
 Public `/sandbox` is a deterministic visual demo. It should teach shared state,
-intents, stale-write rejection, receipts, and deltas, but it does not use a real
+claims, stale-write rejection, receipts, and deltas, but it does not use a real
 API key. It also exposes a Claude Code / Codex handoff prompt. Prefer that shape
 when an agent is asked to "make Ablo work" in an existing app.
 
@@ -124,16 +119,16 @@ sandbox like Stripe test mode: it has an isolated sync group prefix and mints
 Resetting a sandbox creates a clean future stream without touching live data.
 Use `sk_live_*` only for production.
 
-For coding agents, the sandbox success path is: pick one shared resource,
+For coding agents, the sandbox success path is: pick one shared model,
 declare schema, create the Ablo client, replace one direct mutation with a typed
 `ablo.<model>.update(...)`, use selector `useAblo` for live reads, and add a
-two-writer stale/intent smoke test.
+two-writer stale/claim smoke test.
 
 ## Public Surface
 
 Import from these public paths only:
 
-- `@abloatai/ablo` — `Ablo`, errors, typed model resources, intents, `dataSource`, and advanced protocol resources.
+- `@abloatai/ablo` — `Ablo`, errors, typed model clients, claims, `dataSource`, and advanced protocol models.
 - `@abloatai/ablo/schema` — schema DSL.
 - `@abloatai/ablo/react` — React provider and hooks.
 - `@abloatai/ablo/testing` — test harnesses and mocks.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/ablo",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "State control API for AI agents and collaborative apps.",
   "license": "Apache-2.0",
   "type": "module",
@@ -20,6 +20,11 @@
       "import": "./dist/schema/index.js",
       "default": "./dist/schema/index.js"
     },
+    "./coordination": {
+      "types": "./dist/coordination/index.d.ts",
+      "import": "./dist/coordination/index.js",
+      "default": "./dist/coordination/index.js"
+    },
     "./react": {
       "types": "./dist/react/index.d.ts",
       "import": "./dist/react/index.js",
@@ -71,6 +76,8 @@
     "build": "npm run clean && tsc -p tsconfig.build.json",
     "pack:check": "npm_config_cache=${TMPDIR:-/tmp}/ablo-npm-cache npm pack --dry-run",
     "lint:imports": "node scripts/check-js-extensions.mjs",
+    "generate:errors": "tsx scripts/generate-error-docs.mts",
+    "lint:errors": "tsx scripts/check-error-docs.mts",
     "lint:pkg": "publint",
     "prepublishOnly": "npm run build && npm run lint:pkg",
     "test": "jest",

package/dist/react/useMutate.d.ts

@@ -1,83 +0,0 @@
-import type { Schema, InferModel, InferCreate } from '../schema/schema.js';
-import type { ResolveSchema } from '../types/global.js';
-import type { SyncStoreContract } from './context.js';
-type GlobalMutateKey = ResolveSchema extends {
-    models: infer M;
-} ? keyof M & string : string;
-type GlobalMutateActions<K extends string> = ResolveSchema extends Schema ? K extends keyof ResolveSchema['models'] & string ? MutateActions<ResolveSchema, K> : MutateActions<Schema, string> : MutateActions<Schema, string>;
-/**
- * Compatibility mutation hook. Returns CRUD methods for a single model type.
- *
- * Prefer `useAblo()` and call `ablo.<model>.create/update/delete` inside
- * callbacks for new integrations. This hook remains for older string-keyed code.
- *
- * @example
- * import { schema } from '@ablo/schema';
- * import { useMutate } from '@abloatai/ablo/react';
- *
- * const tasks = useMutate(schema, 'tasks');
- *
- * // Create — fields are type-checked against the schema's Zod shape
- * await tasks.create({ title: 'Fix bug', status: 'todo', projectId });
- *
- * // Update — id + partial changes, no need to hold a model instance
- * await tasks.update({ id: task.id, status: 'done', completedAt: new Date() });
- *
- * // Delete / archive / unarchive — by id
- * await tasks.delete(task.id);
- * await tasks.archive(task.id);
- *
- * Mirrors the Zero pattern: `zero.mutate.task.update({ id, status: 'done' })`.
- */
-/**
- * `create` / `update` / `delete` are overloaded: pass one row or an
- * array. Drizzle and Prisma use the same shape (`db.insert(table).values(rowOrRows)`).
- * Avoids the `*Many` suffix while keeping the semantics: every entry in
- * an array call lands in the same synchronous tick (Promise.all under
- * the hood), so the microtask coalescer in `TransactionQueue` collapses
- * N pushes into one wire commit with one `batchIndex` — structurally
- * identical to Zero's mutator-boundary commit.
- */
-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 — testable without React. The hook just wraps this in
- * useMemo with the React context.
- */
-export declare function createMutateActions<S extends Schema, K extends keyof S['models'] & string>(schema: S, modelKey: K, store: SyncStoreContract, organizationId: string): MutateActions<S, K>;
-/** @deprecated Prefer `useAblo()` plus `ablo.<model>.create/update/delete`. */
-export declare function useMutate<S extends Schema, K extends keyof S['models'] & string>(schema: S, modelKey: K): MutateActions<S, K>;
-/** Typed CRUD via the `AbloSync` global augmentation. The schema is
- * resolved from the `SyncProvider`'s context — consumer doesn't pass it
- * at the call site.
- *
- * @deprecated Prefer `useAblo()` plus `ablo.<model>.create/update/delete`.
- */
-export declare function useMutate<K extends GlobalMutateKey>(modelKey: K): GlobalMutateActions<K>;
-export {};

package/dist/react/useQuery.d.ts

@@ -1,123 +0,0 @@
-import type { ModelScope } from '../types/index.js';
-import type { Schema } from '../schema/schema.js';
-import type { InferModel } from '../schema/schema.js';
-import type { ResolveSchema } from '../types/global.js';
-/** Narrow model-key union for the zero-arg overload. */
-type GlobalModelKey = ResolveSchema extends {
-    models: infer M;
-} ? keyof M & string : string;
-/** Typed entity shape for a given model key. Falls back to a loose shape
- * when the resolved schema doesn't extend the full `Schema` contract
- * (i.e., no global augmentation present). */
-type GlobalEntity<K extends string> = ResolveSchema extends Schema ? K extends keyof ResolveSchema['models'] ? InferModel<ResolveSchema, K> : Record<string, unknown> : Record<string, unknown>;
-/**
- * Compatibility query hook for entity collections.
- *
- * Prefer selector reads for new integrations:
- *
- * ```ts
- * const tasks = useAblo((ablo) =>
- *   ablo.tasks.list({ where: { status: 'todo' } }),
- * );
- * ```
- *
- * This hook remains for older string-keyed integrations.
- *
- * **Typed overload:**
- * ```ts
- * import { schema } from '@/sync/schema';
- * const chats = useQuery(schema, 'chats', { where: { userId } });
- * // chats is fully typed: Chat[] with displayTitle, icon, color, etc.
- * ```
- *
- * **Untyped overload (legacy):**
- * ```ts
- * const chats = useQuery('Chat');
- * // chats is Record<string, unknown>[]
- * ```
- */
-export interface QueryOptions<T = Record<string, unknown>> {
-    /** Declarative field-level filter. Shallow match: all specified fields must match. */
-    where?: Partial<T>;
-    /** Arbitrary predicate function for complex logic. Applied AFTER where. */
-    filter?: (entity: T) => boolean;
-    /** Sort field name. */
-    orderBy?: keyof T & string;
-    /** Sort direction. Default: 'asc'. */
-    order?: 'asc' | 'desc';
-    /** Max results. */
-    limit?: number;
-    /** Skip N results (pagination). */
-    offset?: number;
-    /** Filter by model scope (live, archived, all). Default: live. */
-    scope?: ModelScope;
-}
-/**
- * Typed query (explicit schema arg).
- *
- * @deprecated Prefer `useAblo((ablo) => ablo.<model>.list(options))` for new
- * integrations. This overload remains for compatibility with older
- * string-keyed React code.
- *
- * ```ts
- * const tasks = useQuery(schema, 'tasks', { where: { status: 'todo' } });
- * // tasks: Task[] — fully typed from Zod shape + computed getters
- * ```
- */
-export declare function useQuery<S extends Schema, K extends keyof S['models'] & string>(schema: S, modelKey: K, options?: QueryOptions<InferModel<S, K>>): InferModel<S, K>[];
-/**
- * Typed query (global-augmented): pass just the model key. Resolves
- * the schema from the `AbloSync` global augmentation the consumer
- * declared in a `.d.ts`. No `schema` arg at the call site — this is
- * the Liveblocks-style ergonomic path.
- *
- * @deprecated Prefer `useAblo((ablo) => ablo.<model>.list(options))` for new
- * integrations. This overload remains for compatibility with older
- * string-keyed React code.
- *
- * ```ts
- * // apps/your-app/src/ablo-sync.d.ts
- * declare global { interface AbloSync { Schema: typeof schema } }
- *
- * // any component
- * const tasks = useQuery('tasks', { where: { status: 'todo' } });
- * // tasks: Task[] — typed via the declared global
- * ```
- *
- * When no global augmentation exists, `GlobalEntity` falls back to
- * `Record<string, unknown>` — same ergonomics as the legacy untyped
- * overload, with the key still validated against the resolved schema's
- * model keys when that schema is declared.
- */
-export declare function useQuery<K extends GlobalModelKey>(modelKey: K, options?: QueryOptions<GlobalEntity<K>>): GlobalEntity<K>[];
-/** @deprecated Prefer selector reads through `useAblo`. */
-export declare function useQuery<T = Record<string, unknown>>(typename: string, options?: QueryOptions<T>): T[];
-/**
- * Compatibility single-entity lookup. Prefer selector reads:
- *
- * ```ts
- * const task = useAblo((ablo) => ablo.tasks.retrieve(taskId));
- * ```
- *
- * ```ts
- * // Typed
- * const task = useOne(schema, 'tasks', taskId);
- *
- * // Untyped (legacy)
- * const task = useOne(taskId);
- * ```
- */
-/** @deprecated Prefer `useAblo((ablo) => ablo.<model>.retrieve(id))`. */
-export declare function useOne<S extends Schema, K extends keyof S['models'] & string>(schema: S, modelKey: K, id?: string): InferModel<S, K> | undefined;
-/** Typed single-entity lookup via the `AbloSync` global augmentation.
- *
- * @deprecated Prefer `useAblo((ablo) => ablo.<model>.retrieve(id))`.
- *
- * The pool `.get(id)` call doesn't actually need the typename at runtime
- * — the return is already keyed by id globally — so the model key serves
- * as a compile-time narrowing hint for consumers who want the specific
- * entity type at the call site. */
-export declare function useOne<K extends GlobalModelKey>(modelKey: K, id?: string): GlobalEntity<K> | undefined;
-/** @deprecated Prefer `useAblo((ablo) => ablo.<model>.retrieve(id))`. */
-export declare function useOne<T = Record<string, unknown>>(id?: string): T | undefined;
-export {};

package/dist/react/useQuery.js

@@ -1,145 +0,0 @@
-'use client';
-import { useMemo, useEffect, useRef, useCallback } from 'react';
-import { useSyncContext } from './context.js';
-import { useReactive } from './useReactive.js';
-// ── Stable key helper ───────────────────────────────────────────────
-/**
- * Produce a stable string key for QueryOptions so useMemo only recreates
- * the view when the logical query changes.
- *
- * - `where` is serialized via JSON.stringify (deterministic for simple values).
- * - `filter` is a function — we track its reference identity.
- * - Primitives (orderBy, order, limit, offset, scope) are included directly.
- */
-function useStableKey(options) {
-    // We use a ref to track the previous filter reference. When it changes
-    // the key changes and the view is recreated.
-    const filterRef = useRef(undefined);
-    // Bump a generation counter when the filter reference changes
-    const genRef = useRef(0);
-    if (options?.filter !== filterRef.current) {
-        filterRef.current = options?.filter;
-        genRef.current++;
-    }
-    return useMemo(() => {
-        if (!options)
-            return '';
-        const parts = [];
-        if (options.where)
-            parts.push('w:' + JSON.stringify(options.where));
-        if (options.filter)
-            parts.push('f:' + genRef.current);
-        if (options.orderBy)
-            parts.push('ob:' + String(options.orderBy));
-        if (options.order)
-            parts.push('o:' + options.order);
-        if (options.limit !== undefined)
-            parts.push('l:' + options.limit);
-        if (options.offset !== undefined)
-            parts.push('off:' + options.offset);
-        if (options.scope)
-            parts.push('s:' + options.scope);
-        return parts.join('|');
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        options?.where ? JSON.stringify(options.where) : '',
-        genRef.current,
-        options?.orderBy,
-        options?.order,
-        options?.limit,
-        options?.offset,
-        options?.scope,
-    ]);
-}
-// ── Implementation ──────────────────────────────────────────────────
-export function useQuery(schemaOrTypename, modelKeyOrOptions, maybeOptions) {
-    const ctx = useSyncContext();
-    const { store } = ctx;
-    let typename;
-    let options;
-    if (typeof schemaOrTypename === 'string') {
-        // First arg is a string. Could be either the new zero-arg typed
-        // overload (a schema model key, resolved via `ctx.schema`) or the
-        // legacy untyped overload (a raw typename like 'Chat'). When a
-        // schema is present on the context and the string maps to a known
-        // model key, we look up the real typename from the schema's
-        // `ModelDef.typename`. Otherwise we treat the string as a typename
-        // directly — preserving the legacy behavior for any non-opting
-        // consumer. Both paths converge on the same runtime lookup.
-        const key = schemaOrTypename;
-        const ctxSchema = ctx.schema;
-        const modelDef = ctxSchema
-            ? ctxSchema.models[key]
-            : undefined;
-        typename = modelDef?.typename ?? key;
-        options = modelKeyOrOptions;
-    }
-    else {
-        // Explicit schema path: useQuery(schema, 'chats', options?)
-        const schema = schemaOrTypename;
-        const modelKey = modelKeyOrOptions;
-        const modelDef = schema.models[modelKey];
-        typename = modelDef?.typename ?? modelKey;
-        options = maybeOptions;
-    }
-    const optionsKey = useStableKey(options);
-    // The QueryView is generic-erased to `Record<string, unknown>`, but
-    // the caller's filter is typed in `T`. Wrap rather than cast: the
-    // view passes a Record at runtime and the wrapper narrows to T —
-    // single typed boundary, no `as unknown as` chain.
-    const userFilter = options?.filter;
-    const viewOptions = options
-        ? {
-            where: options.where,
-            filter: userFilter
-                ? (entity) => userFilter(entity)
-                : undefined,
-            orderBy: options.orderBy,
-            order: options.order,
-            limit: options.limit,
-            offset: options.offset,
-            scope: options.scope,
-        }
-        : undefined;
-    const view = useMemo(() => store.pool.createView(typename, viewOptions), 
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [store.pool, typename, optionsKey]);
-    useEffect(() => () => view.dispose(), [view]);
-    // Self-subscribing — consumers never wrap their component in
-    // `observer`. `useReactive` tracks the observables read inside the
-    // compute function (`view.results`), recomputes on change, and
-    // returns a stable slice so downstream `.sort()` / `.reverse()`
-    // calls don't trip MobX error 37. The default structural equality
-    // check prevents re-renders when nothing actually moved.
-    //
-    // The compute closure MUST be stable when `view` is stable. Without
-    // useCallback([view]), each render passes a fresh arrow to
-    // useReactive, which then can't distinguish "swapped to a new
-    // QueryView" from "same view, new render" — the wrong call would
-    // either re-subscribe every render (waste) or never re-subscribe
-    // when view actually swaps (stale snapshot bug returning a previous
-    // view's results forever).
-    const compute = useCallback(() => view.results.slice(), [view]);
-    return useReactive(compute);
-}
-export function useOne(schemaOrIdOrKey, modelKeyOrId, maybeId) {
-    const { store } = useSyncContext();
-    if (schemaOrIdOrKey === undefined) {
-        return undefined;
-    }
-    if (typeof schemaOrIdOrKey === 'string') {
-        // Either `useOne(id)` (legacy, one arg) or `useOne(modelKey, id)` (global).
-        // Disambiguate by whether a second arg was passed — both paths
-        // converge on the same runtime pool lookup because entity IDs are
-        // globally unique across model types.
-        if (modelKeyOrId !== undefined) {
-            return store.pool.get(modelKeyOrId);
-        }
-        return store.pool.get(schemaOrIdOrKey);
-    }
-    // Explicit schema path: useOne(schema, 'tasks', id)
-    if (!maybeId)
-        return undefined;
-    return store.pool.get(maybeId);
-}

package/dist/react/useReader.d.ts

@@ -1,69 +0,0 @@
-import type { Schema, InferModel } from '../schema/schema.js';
-import type { ResolveSchema } from '../types/global.js';
-import type { SyncStoreContract } from './context.js';
-type GlobalReaderKey = ResolveSchema extends {
-    models: infer M;
-} ? keyof M & string : string;
-type GlobalReaderActions<K extends string> = ResolveSchema extends Schema ? K extends keyof ResolveSchema['models'] & string ? ReaderActions<ResolveSchema, K> : ReaderActions<Schema, string> : ReaderActions<Schema, string>;
-/**
- * Compatibility schema-typed imperative reader. Returns functions for one-off lookups
- * without subscribing the component to collection changes.
- *
- * Prefer `useAblo()` and call `ablo.<model>.retrieve/list` inside callbacks and
- * effects in new integrations. This hook remains for older string-keyed code.
- *
- * Use this inside event handlers, mutation callbacks, or effects where you
- * need a current snapshot of the pool but don't want to trigger re-renders
- * on every entity change.
- *
- * For reactive reads, use selector reads through
- * `useAblo((ablo) => ablo.<model>.retrieve(id))`.
- *
- * @example
- * import { schema } from '@ablo/schema';
- * import { useReader } from '@abloatai/ablo/react';
- *
- * function useTaskMutations() {
- *   const read = useReader(schema, 'tasks');
- *
- *   return {
- *     create: async (data) => {
- *       // Imperative read — uses FK index when available (O(1))
- *       const existing = read.findMany({ where: { projectId: data.projectId } });
- *       const order = existing.reduce((m, t) => Math.max(m, t.order ?? 0), 0) + 1;
- *       // ...
- *     },
- *   };
- * }
- */
-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 — testable without React. `useReader` wraps this in useMemo.
- */
-export declare function createReaderActions<S extends Schema, K extends keyof S['models'] & string>(schema: S, modelKey: K, store: SyncStoreContract): ReaderActions<S, K>;
-/** @deprecated Prefer `useAblo()` plus `ablo.<model>.retrieve/list` in callbacks/effects. */
-export declare function useReader<S extends Schema, K extends keyof S['models'] & string>(schema: S, modelKey: K): ReaderActions<S, K>;
-/** @deprecated Prefer `useAblo()` plus `ablo.<model>.retrieve/list` in callbacks/effects. */
-export declare function useReader<K extends GlobalReaderKey>(modelKey: K): GlobalReaderActions<K>;
-export {};