@abloatai/ablo 0.5.1 → 0.6.0

package/docs/mcp.md

@@ -1,7 +1,7 @@
 # Model Context Protocol
 
-Ablo Sync ships an MCP server at `/api/mcp`. Connect any MCP-compatible AI
-assistant — Claude Code, Cursor, Windsurf — and your sync resources become
+Ablo ships an MCP server at `/api/mcp`. Connect any MCP-compatible AI
+assistant — Claude Code, Cursor, Windsurf — and your sync models become
 typed, callable tools.
 
 ## Install
@@ -14,38 +14,23 @@ Pick your client:
 
 ## How it works
 
-Each resource you declare becomes one or more MCP tools:
+Each model you declare becomes one or more MCP tools:
 
-| Resource method | MCP tool name | What it does |
+| Model method | MCP tool name | What it does |
 |---|---|---|
-| `retrieve` | `<resource>.retrieve` | Returns the row + a stamp. |
-| `list` | `<resource>.list` | Cursor-paginated discovery. |
-| `update` | `<resource>.update` | Write, requires the prior stamp. |
-| `<model>.intent` | `intent.create` | Claim a row before writing, then auto-release on update. |
+| `retrieve` | `<model>.retrieve` | Returns the row + a stamp. |
+| `list` | `<model>.list` | Cursor-paginated discovery. |
+| `update` | `<model>.update` | Write, requires the prior stamp. |
+| `<model>.claim` | `claim.create` | Claim a row before writing, then release when held work finishes. |
 
 The assistant gets typed JSON schemas, real argument types, and typed
 rejections when it writes stale state. No invention, no hallucinated IDs.
 
 ## Auth
 
-The MCP transport requires a capability token. Create one scoped to the
-assistant's session:
-
-```ts
-const capability = await ablo.capabilities.create({
-  participantKind: 'agent',
-  participantId: 'agent:claude-code',
-  // Strings derive from the schema's `identityRoles` templates
-  // (see integration-guide.md §1).
-  syncGroups: ['org:acme'],
-  operations: ['tasks.retrieve', 'tasks.update'],
-  label: 'claude-code dev session',
-  lease: '8h',
-});
-```
-
-Pass `capability.token` into the MCP client's auth header configuration.
-See your client's setup guide for the exact mechanism.
+The MCP transport uses a scoped bearer token issued by your server. Pass that
+token into the MCP client's auth header configuration. See your client's setup
+guide for the exact mechanism.
 
 ## Limits
 

package/docs/quickstart.md

@@ -21,7 +21,7 @@ export ABLO_API_KEY=sk_test_...
 ```
 
 `ABLO_API_KEY` is for trusted server runtimes. Browser apps should use the React
-provider with a scoped capability/session route, not a bundled API key.
+provider with a scoped session route, not a bundled API key.
 
 ## 3. Declare a Schema
 
@@ -44,7 +44,7 @@ export const ablo = Ablo({
 ```
 
 Customer apps should always pass `schema`. Treat it like Prisma's schema file:
-it is the source of truth for typed model resources, realtime subscriptions,
+it is the source of truth for typed model clients, realtime subscriptions,
 agent writes, and Data Source requests.
 
 ## 4. Create and Update
@@ -81,71 +81,65 @@ ABLO_API_KEY=sk_test_... npx tsx quickstart.ts
 ## 6. AI Activity on Existing State
 
 When AI or background work will touch an existing row for more than a quick
-write, coordinate through `ablo.<model>.intent(id)`. It returns a handle
-synchronously — read `.current` to see who's working on the row, `claim()` to
-claim it, `update()` to write under the claim (which auto-releases).
+write, coordinate through the flat model verbs: `ablo.<model>.claim(id, ...)` to
+claim the row (returns the row), `ablo.<model>.claimState(id)` to read who's working
+on it (synchronous; never blocks), and the normal `ablo.<model>.update(id, ...)`
+to write. Normal reads still work while the claim is held; server reads can opt
+into `ifClaimed: 'wait'` or `ifClaimed: 'fail'` when they should not read through
+active work. The callback form releases the claim when the callback returns or
+throws.
 
 ```ts
-const report = ablo.weatherReports.intent('weather_stockholm');
-
-// If another participant holds it, wait for them to finish.
-if (report.current) await report.whenFree();
-
-// Claim it so other participants yield while we work.
-await report.claim({ action: 'checking_weather', field: 'forecast', ttl: '2m' });
-
-// Your existing weather tool or agent call. While this runs, other clients see
-// that weather_stockholm is being checked.
-const row = ablo.weatherReports.retrieve('weather_stockholm');
-const weather = await weatherAgent.getWeather(row.location);
-
-await report.update({
-  status: 'ready',
-  forecast: weather.summary,
-});
+// Claim the row so other participants serialize behind us while we work.
+await ablo.weatherReports.claim(
+  'weather_stockholm',
+  async (report) => {
+    // Your existing weather tool or agent call. While this runs, other clients
+    // see that weather_stockholm is being checked.
+    const weather = await weatherAgent.getWeather(report.location);
+
+    await ablo.weatherReports.update(report.id, {
+      status: 'ready',
+      forecast: weather.summary,
+    });
+  },
+  { action: 'checking_weather', ttl: '2m' },
+);
 ```
 
-Ablo does not fetch the weather. It keeps the activity visible while the work
-runs, rejects `report.update(...)` with `AbloStaleContextError` if the row
-changed under you, and releases the intent automatically once the write lands.
+Ablo does not fetch the weather. The claim is **advisory**: if another
+participant already holds the row, `claim` waits for them to finish and re-reads
+before handing back the row. While you hold the claim, `update(id, ...)` is
+stale-guarded and rejects with `AbloStaleContextError` if the row changed under
+you. The claim releases automatically once the callback returns or throws.
 
-## 7. Multiplayer and Busy Work
+## 7. Multiplayer and Claimed Work
 
 There is no separate multiplayer mode. Use the same schema client for human UI,
 server actions, and agents; Ablo fans out confirmed writes and keeps active
-intents visible on the same resource.
+claims visible on the same model row.
 
-Intents tell you when another human or agent is active on the same target. For
-schema clients, wait on the intent stream and then write through the model.
+`claimState(id)` tells you when another human or agent is active on the same row.
+For schema clients, `claim(id, work)` waits fairly, re-reads, and then lets you
+write through the model.
 
 ```ts
-const busy = ablo.intents.list({
-  resource: 'weatherReports',
-  id: 'weather_stockholm',
-});
-
-if (busy.length > 0) {
-  await ablo.intents.waitFor(
-    { resource: 'weatherReports', id: 'weather_stockholm' },
-    { timeout: 30_000 },
-  );
+const active = ablo.weatherReports.claimState('weather_stockholm');
+if (active) {
+  console.log(`${active.heldBy} is ${active.action}`);
 }
 
-await ablo.weatherReports.update('weather_stockholm', { status: 'ready' });
+await ablo.weatherReports.claim('weather_stockholm', async (report) => {
+  await ablo.weatherReports.update(report.id, { status: 'ready' });
+});
 ```
 
-`ifBusy` controls what happens when another human or agent is already working
-on the same target:
-
-- `return` returns immediately with active intents.
-- `wait` waits for the intent stream to clear.
-- `fail` throws `AbloBusyError` with the active intents attached.
+Use `{ wait: false }` on `claim` when work should be skipped instead of queued
+behind an active holder.
 
 ## 8. Next Steps
 
-Keep using the schema client for app and agent writes. Reach for the advanced
-schema-less agent wrapper only when a worker intentionally cannot import the
-app schema.
+Keep using the schema client for app and agent writes.
 
 - [Integration Guide](./integration-guide.md) explains the full app, React, Data Source, multiplayer, and agent path.
 - [Guarantees](./guarantees.md) explains what confirmed writes and stale checks mean.

package/docs/react.md

@@ -14,21 +14,71 @@ The React bindings ship with the main package — no extra install.
 import { useAblo } from '@abloatai/ablo/react';
 ```
 
-## useAblo — model resource
+## AbloProvider
+
+Mount it once near the root of your tree. It owns the connection, the local
+pool, and the engine lifecycle; everything below it reads with `useAblo`.
+
+```tsx
+'use client';
+
+import { AbloProvider } from '@abloatai/ablo/react';
+import { schema } from '@/ablo.schema';
+
+export function Providers({
+  children,
+  user, // resolved server-side from YOUR auth
+}: {
+  children: React.ReactNode;
+  user: { id: string; teamIds: string[] };
+}) {
+  return (
+    <AbloProvider
+      schema={schema}
+      userId={user.id}
+      teamIds={user.teamIds}
+      fallback={<AppSkeleton />}
+    >
+      {children}
+    </AbloProvider>
+  );
+}
+```
+
+`schema` is the only required prop. The rest are situational:
+
+| Prop                | Default                | Purpose                                                                                                   |
+| ------------------- | ---------------------- | --------------------------------------------------------------------------------------------------------- |
+| `schema`            | —                      | **Required.** From `defineSchema()`. Determines the typed hook surface.                                   |
+| `userId`            | resolved from auth     | App participant id for app-owned fields and your `identityRoles.extract`. Not the security boundary.      |
+| `teamIds`           | resolved from auth     | Team ids expanded into team sync groups via `identityRoles`.                                               |
+| `syncGroups`        | full allowed set       | **Narrows** the subscription to a subset of what auth allows (e.g. `['deck:abc123']`). Never widens it.   |
+| `url`               | hosted endpoint        | WebSocket URL of the sync server (`wss://…`). Hosted apps omit it.                                         |
+| `apiKey`            | session/cookie         | Bootstrap auth. Browser apps **omit this** — the key stays server-side. See Identity below.               |
+| `fallback`          | neutral spinner        | Rendered during the *first* bootstrap only. Pass a branded skeleton, `null`, or `'passthrough'`.          |
+| `bootstrapMode`     | `'full'`               | `'full'` pulls the org's baseline before ready; `'none'` skips the baseline and processes live deltas only.|
+| `persistence`       | `'volatile'`           | `'indexeddb'` opts into an offline queue + reload-surviving cache.                                         |
+| `onSessionExpired`  | —                      | Fired after the engine has already purged on a rejected session — use for redirect-to-sign-in.            |
+| `onError`           | —                      | Engine / WebSocket / `postBootstrap` errors. Wire to Sentry / Datadog.                                    |
+
+Where `userId` / `teamIds` / `syncGroups` come from, and why the API key never
+reaches the browser, is the whole of
+[Identity & Sync Groups](./identity.md) — read that if it isn't obvious how org
+/ team / user map to what a participant can see.
+
+## useAblo — model client
 
 ```tsx
 'use client';
 
 import { useAblo } from '@abloatai/ablo/react';
 
-export function TaskView({ task: serverTask }: { task: { id: string; title: string } }) {
-  const task = useAblo((ablo) => ablo.tasks.retrieve(serverTask.id)) ?? serverTask;
-  const intents = useAblo((ablo) =>
-    ablo.intents.list({ resource: 'tasks', id: serverTask.id }),
-  ) ?? [];
-  const busy = intents.length > 0;
+export function ReportView({ report: serverReport }: { report: { id: string; location: string } }) {
+  const report = useAblo((ablo) => ablo.weatherReports.retrieve(serverReport.id)) ?? serverReport;
+  const active = useAblo((ablo) => ablo.weatherReports.claimState(serverReport.id));
+  const claimed = Boolean(active);
 
-  return <article>{task.title}</article>;
+  return <article>{report.location}</article>;
 }
 ```
 
@@ -37,9 +87,9 @@ The hook:
 1. Reads through the same `ablo.<model>` methods as the rest of the SDK.
 2. Tracks the model fields read by the selector and re-renders when confirmed
    deltas arrive.
-3. Lets Server Component data stay outside the hook: use `?? serverTask` when a
+3. Lets Server Component data stay outside the hook: use `?? serverReport` when a
    parent already loaded the row.
-4. Works for coordination state too, such as `ablo.intents.list(...)`.
+4. Works for coordination state too, such as `ablo.weatherReports.claimState(id)`.
 
 Use the zero-argument form only when you need the full client for callbacks,
 effects, or writes:
@@ -50,15 +100,15 @@ const abloClient = useAblo();
 
 Prefer selector reads like `useAblo((ablo) => ablo.<model>.retrieve(id))`.
 String model names are kept on older hooks for compatibility, but first examples
-should use the same model-resource shape as the rest of the SDK.
+should use the same model-client shape as the rest of the SDK.
 
-For collections, keep the selector on the model resource too:
+For collections, keep the selector on the model client too:
 
 ```tsx
-const tasks = useAblo((ablo) =>
-  ablo.tasks.list({
+const reports = useAblo((ablo) =>
+  ablo.weatherReports.list({
     where: { projectId },
-    filter: (task) => task.status !== 'done',
+    filter: (report) => report.status !== 'ready',
     scope: 'live',
   }),
 );
@@ -67,7 +117,7 @@ const tasks = useAblo((ablo) =>
 ## Server Load
 
 ```tsx
-const [task] = await ablo.tasks.load({ where: { id } });
+const [report] = await ablo.weatherReports.load({ where: { id } });
 ```
 
 Use `load` in Server Components when the row may not be in the local pool yet.
@@ -79,8 +129,8 @@ For Server Actions and route handlers, call the SDK directly:
 ```ts
 import { ablo } from '@/lib/ablo';
 
-const snap = ablo.snapshot({ tasks: id });
-await ablo.tasks.update(id, patch, {
+const snap = ablo.snapshot({ weatherReports: id });
+await ablo.weatherReports.update(id, patch, {
   readAt: snap.stamp,
   onStale: 'reject',
   wait: 'confirmed',
@@ -88,17 +138,17 @@ await ablo.tasks.update(id, patch, {
 ```
 
 For client event handlers, get the provider-owned client and call the same
-model resource:
+model client:
 
 ```tsx
 const ablo = useAblo();
 
-async function markDone() {
+async function markReady() {
   if (!ablo) return;
-  const snap = ablo.snapshot({ tasks: id });
-  await ablo.tasks.update(
+  const snap = ablo.snapshot({ weatherReports: id });
+  await ablo.weatherReports.update(
     id,
-    { status: 'done' },
+    { status: 'ready' },
     { readAt: snap.stamp, onStale: 'reject', wait: 'confirmed' },
   );
 }

package/docs/roadmap.md

@@ -4,8 +4,7 @@ What is shipped, what is next, and what we will not build.
 
 ## Shipped
 
-- **Resources, intents, commits** — the core API.
-- **Capability tokens** — Biscuit-signed, scoped, attenuable, hot-revocable.
+- **Models, claims, commits** — the core API.
 - **Audit log** — hash-chained per principal, with `delegationChainRoot`.
 - **MCP transport** — HTTP server at `/api/mcp`.
 - **TypeScript SDK** — `@abloatai/ablo`, with React bindings.
@@ -13,13 +12,12 @@ What is shipped, what is next, and what we will not build.
 
 ## In flight
 
-- **Real-time presence** — see who else is viewing/editing a resource.
+- **Real-time presence** — see who else is viewing/editing a model.
 - **Cross-instance fan-out via Redis** — pub/sub deltas at scale.
-- **Hot capability revocation UI** — in the dashboard, today via API only.
 
 ## On deck
 
-- **Schema migrations** — declarative resource schema changes.
+- **Schema migrations** — declarative model schema changes.
 - **Field-level subscriptions** — subscribe to one path, not the whole row.
 - **Bulk import/export** — CSV/JSON round-trip with chain verification.
 
@@ -31,11 +29,11 @@ What is shipped, what is next, and what we will not build.
 
 ## We will not build
 
-- **A general-purpose Postgres wrapper** — Ablo Sync is for state with
+- **A general-purpose Postgres wrapper** — Ablo is for state with
   concurrency semantics, not for storing every table.
 - **Server-side compute** — no triggers, no stored procedures. Compute
   belongs in your application code.
-- **A document database UI** — your data lives in Ablo Sync; the UI is your
+- **A document database UI** — your data lives in Ablo; the UI is your
   product, not ours.
 
 ## How priorities shift

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.6.0",
   "description": "State control API for AI agents and collaborative apps.",
   "license": "Apache-2.0",
   "type": "module",

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 {};