@abloatai/ablo 0.28.0 → 0.29.0

package/docs/guarantees.md

@@ -125,6 +125,27 @@ const ablo = Ablo({
 
 Node, SSR, tests, and agents use in-memory persistence ('memory') automatically.
 
+Cache persistence and outbound-write recovery are separate concerns. Most
+clients need only the default memory cache: once the server confirms a write,
+the server is durable and the idempotency key makes a retry safe. A long-running
+worker that must also recover an unacknowledged write after its own process dies
+can opt into a durable write journal:
+
+```ts
+const ablo = Ablo({
+  schema,
+  apiKey: process.env.ABLO_API_KEY,
+  durableWrites: {
+    store: workerWriteStore,
+    namespace: 'report-worker',
+  },
+});
+```
+
+The store can be backed by the worker's workflow state, SQLite, or another
+durable system. Actor identity is derived from authentication; `namespace` only
+separates workflow or deployment lanes sharing the same store.
+
 ## Storage Boundary
 
 Ablo does not need a customer database URL. When your own database is canonical,

package/docs/integration-guide.md

@@ -492,6 +492,7 @@ Keep agent writes on the same schema client surface as the app.
 | `/testing`                                | Test harnesses and deterministic mocks.                           |
 | `Data Source`                             | Keep your app database canonical.                                 |
 | `persistence: 'indexeddb'`                | Durable browser cache that survives reloads, for apps that need it. |
+| `durableWrites: { store, namespace? }`     | Recover unacknowledged worker writes after a process restart.      |
 | `claim` / `claim.state` / `claim.queue`          | Show active work and coordinate before a write.                   |
 | `snapshot` + `readAt`                     | Reject writes based on stale state.                               |
 | `mutable`, `readOnly`, `field`, `indexed` | Advanced schema and read tuning.                                  |

package/docs/migration.md

@@ -11,7 +11,8 @@ change when you upgrade.
 
 | Version | What changed | What to do |
 |---|---|---|
-| **0.11.0** | `intent` → `claim` rename completed across the React hook, type namespace, and wire frames | `useIntent` → `useClaim`; `Register.Intents` → `Register.Claims`; `Ablo.Intent.*` → `Ablo.Claim.*`. Upgrade client **and** server together (wire frames moved `intent_*` → `claim_*`) |
+| **0.28.0** | Removed React placeholders that had no working runtime | `usePresence` → `usePeers` or `useWatch`; `useClaim` → `ablo.<model>.claim`; `SyncGroupProvider` / `useSyncGroup` → `useWatch({ scope })` |
+| **0.11.0** | Historical `intent` → `claim` rename | The hook renamed in that release was later removed in 0.28.0. Current code uses `ablo.<model>.claim` or `useWatch` |
 | **0.10.0** | Environment enum renamed `test`/`live` → `sandbox`/`production` | Update code that branches on the environment (e.g. source `mode`): `'test'`→`'sandbox'`, `'live'`→`'production'`. Key prefixes `sk_test_`/`sk_live_` are unchanged |
 | **0.9.2** | `turn` primitive + agent-work `tasks` resource removed | Coordinate with `claim`; mint a scoped session instead of `agent().run()` |
 | **0.9.2** | `intents` deprecated in favor of `claim` | Use `ablo.<model>.claim`; `ablo.intents` is now `@internal` |
@@ -25,8 +26,27 @@ change when you upgrade.
 
 ---
 
+## 0.28.0 — dead React multiplayer placeholders removed
+
+Four React exports looked usable but had no live implementation:
+
+- `usePresence` returned no provider-backed presence value. Use `usePeers` for
+  read-only presence or `useWatch` to join a scoped participant.
+- `useClaim` depended on a callback the provider never supplied and always
+  threw. Use `ablo.<model>.claim({ id, ... })` for row claims or
+  `useWatch({ scope, claim: true })` for a scoped participant claim.
+- `SyncGroupProvider` and `useSyncGroup` had no repository consumers. Pass the
+  scope directly to `useWatch({ scope })`.
+
+There is no compatibility alias: the replacement APIs were already the only
+working paths.
+
 ## 0.11.0 — `intent` → `claim` rename completed
 
+> **Historical note:** this section documents the 0.11.0 transition.
+> `useClaim` was subsequently removed in 0.28.0 because its provider callback
+> was never wired. Do not migrate new code to it; use the replacements above.
+
 The coordination primitive has been `claim` since 0.9.2, but a few `intent`-named
 surfaces lingered. 0.11.0 finishes the rename. There are three edits, all
 mechanical:

package/docs/quickstart.md

@@ -191,6 +191,17 @@ const updated = await ablo.weatherReports.update({
 console.log({ id: updated.id, status: updated.status }); // { id: '...', status: 'ready' }
 ```
 
+Read a single row back with `retrieve({ id })`. It resolves to the row, or to
+`undefined` when no row has that id — so narrow it once, then the fields are
+fully typed:
+
+```ts
+const report = await ablo.weatherReports.retrieve({ id: created.id });
+if (!report) throw new Error(`weatherReports ${created.id} not found`);
+
+console.log(report.status); // 'ready'
+```
+
 ## Add coordination for slow work
 
 When AI or background work will touch an existing row for more than a quick

package/docs/react.md

@@ -178,52 +178,6 @@ imperative work after an event or effect.
 
 See [API reference](/docs/api) for the full options surface.
 
-## useClaim — named-claim dispatcher
-
-`useClaim` (renamed from `useIntent` in 0.11.0) is typed sugar for invoking a
-*named* claim from your own coordination vocabulary — distinct from the
-row-level `ablo.<model>.claim({ id })` resource claim. Use it when you want to
-broadcast a semantic claim like "I'm editing this layer" or "the agent is
-generating here" and let your transport turn it into a network effect.
-
-Declare the vocabulary once via module augmentation on the `Register` interface
-(the `Claims` key — previously `Intents`):
-
-```ts
-declare module '@abloatai/ablo' {
-  interface Register {
-    Claims: {
-      editLayer: { slideId: string; layerId: string };
-      generateWithAI: { entityId: string; tool: string };
-    };
-  }
-}
-```
-
-Then `useClaim('editLayer')` returns a function whose sole argument is the
-`editLayer` shape — purely compile-time narrowing, no runtime checks:
-
-```tsx
-'use client';
-
-import { useClaim } from '@abloatai/ablo/react';
-
-export function LayerToolbar({ slideId, layerId }: { slideId: string; layerId: string }) {
-  const claimEditLayer = useClaim('editLayer');
-
-  return (
-    <button onClick={() => claimEditLayer({ slideId, layerId })}>
-      Edit layer
-    </button>
-  );
-}
-```
-
-The hook is pure sugar: the actual network effect lives in the `beginClaim`
-function wired into the provider (bound to your transport). If no `beginClaim`
-is wired, the returned invoker throws `AbloValidationError` with code
-`claim_not_wired`.
-
 ## useWatch — scoped presence + read interest
 
 `useWatch` is the React form of `ablo.<model>.watch`. It joins multiplayer for a

package/examples/README.md

@@ -21,13 +21,14 @@ const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY });
 Then:
 
 - create with `ablo.weatherReports.create`
-- read with `ablo.weatherReports.load`
-- mark long-running AI work with `ablo.weatherReports.edit`
+- read with `ablo.weatherReports.retrieve` or `ablo.weatherReports.list`
+- coordinate long-running work with `ablo.weatherReports.claim`
 - write with `ablo.weatherReports.update`
-- wait for confirmation when the write must be durable before continuing
+- dispose the client when the worker finishes
 
-Use schema-less resources and `commits.create` only for advanced runtimes that
-intentionally cannot import the app schema.
+Import the same schema in every runtime. Use `commits.create` only when several
+typed row operations must land atomically; ordinary writes stay on
+`ablo.<model>.create/update/delete`.
 
 ## Running
 

package/llms.txt

@@ -8,7 +8,7 @@ Use AI SDK for the agent loop. Use Ablo when agent reads and writes must persist
 
 ## Start here
 
-First action when integrating into an app: run `npx ablo init --yes --framework <nextjs|vite|remix|vanilla>`. Agents have no TTY — `--yes` is REQUIRED or it HANGS. The default `--storage direct` (connection string) scaffolds `ablo/schema.ts`, the client, and (for Next.js) the browser provider + session route; pass `--storage endpoint` instead when database credentials must stay inside the app — that variant scaffolds a signed Data Source endpoint. All on the current API. Edit the generated files rather than hand-writing from this doc.
+First action when integrating into an app: run `npx ablo init --yes --framework <nextjs|vite|remix|vanilla>`. Agents have no TTY — `--yes` is REQUIRED or it HANGS. It scaffolds `ablo/schema.ts`, the `Ablo({ schema, apiKey })` client, and (for Next.js) the browser provider + session route. All on the current API. Edit the generated files rather than hand-writing from this doc. Connecting a database is a SEPARATE step with one path — logical replication via `npx ablo connect` (see Storage Boundary); the signed Data Source endpoint is the fallback when database credentials must stay inside the app.
 
 Second: make sure a key exists — WITHOUT printing it. The key is a secret; it must never appear in your output, your reasoning, or a file you echo (it would live in the conversation history forever). Check PRESENCE only: `[ -n "$ABLO_API_KEY" ] && echo set` and `grep -cq '^ABLO_API_KEY=' .env.local && echo wired` — never `cat .env.local`, never `echo $ABLO_API_KEY`. If neither check passes, ask the HUMAN to run `npx ablo login` once — it opens a browser and saves a `sk_test_` key locally; an agent must NOT run it. You never copy the key by hand: the next step writes it into `.env.local` (and gitignores it) for you.
 
@@ -69,14 +69,14 @@ await. The query reads accept `where`, `filter`, `orderBy`, `limit`, `offset`,
 and `state`; state defaults to `'live'`, with `'archived'` and `'all'` to include
 retired rows.
 
-Workers that can't import the app schema can use a schema-less mode (covered in
-`integration-guide`).
+Workers import the same app schema and select `transport: 'http'`. The transport
+changes; the typed `ablo.<model>` contract does not. There is no public
+schema-less or string-keyed model client.
 
 React reads should use selector `useAblo`: `useAblo((ablo) => ablo.weatherReports.get(id))` (synchronous local read, reactive in render).
 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
-first integration path.
+event handler or effect. The older string-keyed hooks (`useQuery`, `useOne`,
+`useReader`, and `useMutate`) are removed; do not import or recommend them.
 
 ## Multiplayer
 
@@ -98,9 +98,10 @@ coordination until the app reports it through Data Source events.
 ## Claimed Behavior
 
 Reads never silently block. Schema reads stay open while a row is claimed.
-Server reads through `ablo.model(name)` can pass `ifClaimed: 'return'` (the
-default — returns the row plus active claim metadata) or `ifClaimed: 'fail'`
-to throw `AbloClaimedError`.
+Typed reads through `ablo.<model>.retrieve({ id })` return the row by default,
+even while it is claimed. Pass `ifClaimed: 'fail'` to throw
+`AbloClaimedError`, and inspect active coordination separately through
+`ablo.<model>.claim.state({ id })`.
 
 Reads never block on a claim. To wait for a row to free up, `claim({ id })` it —
 the claim queues fairly behind the current holder and is granted when the row
@@ -126,9 +127,7 @@ THE ONE PATH IS LOGICAL REPLICATION. In production every schema model is backed
 
 FALLBACK (only when the database can't grant a `REPLICATION` role, e.g. a locked-down managed DB): a signed Data Source endpoint that hands Ablo an ORM `adapter` (Drizzle default; Prisma and Kysely supported) — it owns the transaction, exactly-once idempotency, and outbox in ONE pass; your credentials never leave your infrastructure.
 
-DEPRECATED — being removed, do NOT recommend or scaffold: the `databaseUrl` constructor option (the dial-in, where Ablo held a read/write connection and committed directly to your DB). The end-state constructor is `Ablo({ schema, apiKey })`; the database is connected out of band via `ablo connect`, not through `databaseUrl`. (Note: `ablo init` still defaults to `--storage direct` scaffolding `databaseUrl` — that default is itself slated to lead with `ablo connect`; prefer logical replication regardless of what `init` scaffolds.)
-
-GOTCHA the user WILL hit: `DATABASE_URL` must use a NON-superuser, NON-BYPASSRLS role (Ablo enforces row-level security; owner roles are rejected with `database_role_cannot_enforce_rls`). Neon's and Supabase's default dashboard connection strings use the database OWNER (e.g. `neondb_owner`) and are rejected. EASIEST: `npx ablo migrate` detects the unsafe role and creates the scoped one automatically from the user's machine (owner credential never reaches Ablo; new DATABASE_URL written to the env file). Manual alternative — create a scoped role first: `CREATE ROLE ablo_app LOGIN PASSWORD '...' NOSUPERUSER NOBYPASSRLS; GRANT CREATE, CONNECT ON DATABASE <db> TO ablo_app; GRANT CREATE, USAGE ON SCHEMA public TO ablo_app;` — then swap user/password into the same host/db string.
+DEPRECATED — being removed, do NOT recommend or scaffold: the `databaseUrl` constructor option (the dial-in, where Ablo held a read/write connection and committed directly to your DB). The end-state constructor is `Ablo({ schema, apiKey })`; the database is connected out of band via `ablo connect`, not through `databaseUrl`. The role rule you may have seen belongs ONLY to this dial-in: a `databaseUrl` had to name a NON-superuser, NON-BYPASSRLS role, or Ablo rejected it with `database_role_cannot_enforce_rls` (it enforced row-level security through the connection it held, so an owner/BYPASSRLS role — e.g. Neon's `neondb_owner` — would have silently skipped RLS). The WAL path retires that rule entirely: Ablo never holds a connection to your rows, so there is no `DATABASE_URL` to scope — `ablo connect` needs a `REPLICATION` role instead. `ablo init` still scaffolds `--storage direct`/`databaseUrl` for existing dial-in projects and the CLI now warns on it; prefer `ablo connect` regardless of what `init` scaffolds.
 
 ```ts
 // app/api/ablo/source/route.ts
@@ -146,7 +145,7 @@ export const { POST } = dataSourceNext({
 });
 ```
 
-`npx ablo init` defaults to `--storage direct` (the connection-string path — it scaffolds the client carrying `databaseUrl` and the `DATABASE_URL` env entry; see CLI below). Pass `--storage endpoint` to scaffold the signed Data Source endpoint above instead, when app database credentials must stay private — Ablo only calls the endpoint.
+Connect a database with `npx ablo connect` (logical replication — the one path above). The signed Data Source endpoint (code above) is the fallback when app database credentials must stay private; scaffold it with `npx ablo init --storage endpoint` — Ablo only calls the endpoint. (`--storage direct` still exists for existing dial-in projects but is deprecated; the CLI warns on it.)
 
 ## Sandboxes
 
@@ -172,7 +171,7 @@ two-writer stale/claim smoke test.
 
 Import from these public paths only:
 
-- `@abloatai/ablo` — `Ablo`, errors, typed model clients, claims, `dataSource`, and advanced protocol models.
+- `@abloatai/ablo` — `Ablo`, errors, typed model clients, claims, and `dataSource`.
 - `@abloatai/ablo/schema` — schema DSL.
 - `@abloatai/ablo/react` — React provider and hooks.
 - `@abloatai/ablo/testing` — test harnesses and mocks.
@@ -188,7 +187,8 @@ Do not teach `/api`, `/agent`, `/ai-sdk`, `/core`, `/realtime`, or internal subp
 
 `ablo init` and other prompts need a TTY; an agent/CI run has none and will HANG. Always:
 
-- `npx ablo init --yes` (flags: `--framework`, `--auth`, `--storage direct|endpoint` (default `direct`), `--no-agent`, `--no-pull`, `--no-install`, `--no-login`). Generates `ablo/schema.ts` + the client; `--storage direct` (default) wires `databaseUrl`, `--storage endpoint` scaffolds the `ablo/data-source.ts` endpoint above instead.
+- `npx ablo init --yes` (flags: `--framework`, `--auth`, `--storage direct|endpoint`, `--no-agent`, `--no-pull`, `--no-install`, `--no-login`). Generates `ablo/schema.ts` + the `Ablo({ schema, apiKey })` client. `--storage endpoint` also scaffolds the `ablo/data-source.ts` fallback endpoint; `--storage direct` (deprecated, CLI warns) wires the legacy `databaseUrl`.
+- `npx ablo connect` connects your database via logical replication — the read path (prints the `wal_level=logical` + publication + `REPLICATION`-role SQL); `npx ablo connect --register` registers it, `npx ablo connect --check` validates.
 - Key: see "Start here" — env → `.env.local` → ask the human to `npx ablo login`; never run `login` yourself, never copy keys by hand (`ablo push` writes `.env.local`).
 - Adopt an existing DB: `npx ablo pull prisma [path]` / `npx ablo pull drizzle <module>`.
 - `npx ablo push` pushes the schema (sandbox) AND writes `ABLO_API_KEY` to `.env.local`; `npx ablo dev --no-watch` is the push-once form of the watcher; `npx ablo logs --no-follow` exits instead of tailing forever; `npx ablo mode sandbox|production` always needs the argument. `npx ablo push`/`status`/`pull`/`check`/`generate` are one-shot.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/ablo",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "The Collaboration Layer For AI Agents",
   "license": "Apache-2.0",
   "type": "module",
@@ -28,11 +28,6 @@
       "import": "./dist/coordination/index.js",
       "default": "./dist/coordination/index.js"
     },
-    "./commit": {
-      "types": "./dist/commit/index.d.ts",
-      "import": "./dist/commit/index.js",
-      "default": "./dist/commit/index.js"
-    },
     "./react": {
       "types": "./dist/react/index.d.ts",
       "import": "./dist/react/index.js",
@@ -163,7 +158,7 @@
     "test:e2e": "E2E_TEST=true jest --config jest.e2e.config.ts",
     "test:e2e:up": "docker compose -f docker-compose.test.yml up -d --wait",
     "test:e2e:down": "docker compose -f docker-compose.test.yml down -v",
-    "test:e2e:run": "npm run test:e2e:up && npm run test:e2e; npm run test:e2e:down"
+    "test:e2e:run": "node scripts/run-e2e.mjs"
   },
   "publishConfig": {
     "access": "public",

package/dist/client/ApiClient.d.ts

@@ -1,177 +0,0 @@
-/**
- * The stateless API client behind `Ablo({ apiKey })`. It carries no schema,
- * object pool, local database, or WebSocket, and maps the public Model, Claim,
- * and Commit nouns directly to HTTP routes on the server. This is the transport
- * used for server-side agents, workers, and serverless code.
- */
-import type { AbloOptions } from './options.js';
-import type { CommitResource, ClaimCreateOptions, ClaimWaitOptions, ModelClient, ModelClaim, ModelTarget, CreateSessionParams, AbloSession } from './resourceTypes.js';
-import type { SchemaRecord } from '../schema/schema.js';
-import type { Duration } from '../utils/duration.js';
-import type { Claim, ClaimHeartbeat } from '../types/streams.js';
-import type { SyncObservabilityProvider } from '../interfaces/index.js';
-export type AbloApiClientOptions = Omit<AbloOptions, 'schema'> & {
-    readonly schema?: null | undefined;
-    readonly bootstrapBaseUrl?: string | undefined;
-    /**
-     * The observability provider forwarded from `Ablo({ observability })`. The HTTP
-     * transport emits the same claim and conflict events as the WebSocket transport,
-     * so a `ClaimLog` works identically for headless server-agent evaluations.
-     */
-    readonly observability?: SyncObservabilityProvider;
-    /**
-     * Per-request deadline in milliseconds for the stateless HTTP transport.
-     * Every request this client issues is aborted after this long and surfaces
-     * as a retryable connection error — without it a black-holed server hangs
-     * a headless agent forever (browsers never time fetch out on their own).
-     * Pass `0` to disable the deadline.
-     *
-     * @default 30_000
-     */
-    readonly timeoutMs?: number;
-};
-/** Default per-request deadline for the stateless HTTP transport. */
-export declare const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
-export interface AbloApiClaims {
-    create(options: ClaimCreateOptions): Promise<Claim>;
-    list(target?: Partial<ModelTarget>): Promise<readonly ModelClaim[]>;
-    waitFor(target: Partial<ModelTarget>, options?: ClaimWaitOptions): Promise<void>;
-    /**
-     * The batched beat — extend every lease this credential holds in one
-     * request (`POST /v1/claims/heartbeat`), the stateless twin of the
-     * WebSocket keepalive. One round trip per cadence for a worker holding
-     * many rows. Returns one {@link ClaimHeartbeat} per extended lease,
-     * tagged with its claim id — no separate result type to learn.
-     */
-    heartbeatAll(options?: {
-        ttl?: Duration;
-    }): Promise<readonly (ClaimHeartbeat & {
-        readonly claimId: string;
-    })[]>;
-}
-export type CapabilityParticipantKind = 'agent' | 'system';
-export interface CapabilityCreateBaseOptions {
-    readonly participantKind?: CapabilityParticipantKind;
-    readonly participantId?: string;
-    readonly syncGroups: readonly string[];
-    readonly operations: readonly string[];
-    readonly label?: string;
-    readonly wideScope?: boolean;
-    readonly userMeta?: Record<string, unknown>;
-}
-export interface CapabilityCreateOptions extends CapabilityCreateBaseOptions {
-    /**
-     * Preferred public name. A capability is a lease; the SDK and server
-     * clean it up when the run finishes or when the lease expires.
-     */
-    readonly lease?: Duration;
-    readonly leaseSeconds?: number;
-    /** @deprecated Use `lease`. */
-    readonly ttl?: Duration;
-    /** @deprecated Use `leaseSeconds`. */
-    readonly ttlSeconds?: number;
-}
-export interface CapabilityScope {
-    readonly organizationId: string;
-    readonly syncGroups: readonly string[];
-    readonly operations: readonly string[];
-    readonly participantKind: CapabilityParticipantKind;
-    readonly participantId: string;
-}
-export interface Capability {
-    readonly id: string;
-    readonly token: string;
-    readonly expiresAt: string;
-    readonly organizationId: string;
-    readonly scope: CapabilityScope;
-    readonly userMeta?: Record<string, unknown>;
-    client(): AbloApi;
-}
-export interface CapabilityRecord {
-    readonly id: string;
-    readonly organizationId: string;
-    readonly participantKind: CapabilityParticipantKind;
-    readonly participantId: string;
-    readonly label: string | null;
-    readonly status: 'active' | 'expired' | 'revoked';
-    readonly issuedAt: string;
-    readonly expiresAt: string;
-    readonly revokedAt: string | null;
-    readonly lastUsedAt: string | null;
-    readonly operations: readonly string[];
-    readonly syncGroups: readonly string[];
-}
-export interface CapabilityRevocation {
-    readonly id: string;
-    readonly deleted: boolean;
-    readonly activeSessionsClosed?: number;
-}
-export interface CapabilityRotateOptions {
-    /**
-     * The overlap window — the old token keeps authenticating for this long after
-     * rotation, so you can deploy the replacement with zero downtime. Defaults to
-     * 24h on the server.
-     */
-    readonly grace?: Duration;
-    readonly graceSeconds?: number;
-    /**
-     * The lifetime of the replacement capability. Omit to inherit the original's
-     * lifetime.
-     */
-    readonly lease?: Duration;
-    readonly leaseSeconds?: number;
-}
-/** The fresh capability returned by `rotate`, plus a pointer to the old one. */
-export interface RotatedCapability extends Capability {
-    /**
-     * The capability that was rotated out. Its token keeps working until
-     * `expiresAt` (the end of the grace window), then expires.
-     */
-    readonly rotatedFrom: {
-        readonly id: string;
-        readonly expiresAt: string;
-    };
-}
-export interface CapabilityResource {
-    create(options: CapabilityCreateOptions): Promise<Capability>;
-    retrieve(id: string): Promise<CapabilityRecord>;
-    revoke(id: string): Promise<CapabilityRevocation>;
-    /**
-     * Rotate with overlap: mint a fresh capability that carries the same scope, and
-     * keep the old token working for a grace window so you can roll out the
-     * replacement without downtime.
-     */
-    rotate(id: string, options?: CapabilityRotateOptions): Promise<RotatedCapability>;
-    /**
-     * Alias for `create`. Kept because "mint" is common capability-token
-     * language, but `create` is the canonical SDK verb.
-     */
-    mint(options: CapabilityCreateOptions): Promise<Capability>;
-}
-export interface AbloApi {
-    ready(): Promise<void>;
-    waitForFlush(): Promise<void>;
-    dispose(): Promise<void>;
-    purge(): Promise<void>;
-    readonly capabilities: CapabilityResource;
-    readonly claims: AbloApiClaims;
-    readonly commits: CommitResource;
-    model<T = Record<string, unknown>>(name: string): ModelClient<T>;
-    /**
-     * Resolve the active bearer credential this client authenticates with — the
-     * same token its own requests carry in `Authorization`. Returns `null` when
-     * no credential is configured. Async because the API key may be supplied as
-     * an async setter. Use it to authenticate a side-band request to the same
-     * server with the credential this client already holds — no re-mint.
-     */
-    getAuthToken(): Promise<string | null>;
-    /**
-     * Mint a short-lived scoped session. Minting is a control-plane HTTP call (no
-     * socket), so it lives on this stateless client too, not only the realtime one.
-     * `{ user }` mints an `ek_`; `{ agent, can }` mints an `rk_`.
-     */
-    readonly sessions: {
-        create(params: CreateSessionParams<SchemaRecord>): Promise<AbloSession>;
-    };
-}
-export declare function createProtocolClient(options: AbloApiClientOptions): AbloApi;