@abloatai/ablo 0.5.0 → 0.6.0

package/dist/client/createModelProxy.js

@@ -1,26 +1,26 @@
 /**
- * Per-model resource factory.
+ * Per-model client factory.
  *
- * Mirrors Anthropic SDK's `resources/messages.ts` / `resources/models.ts`
- * pattern: each resource has its own file, the client just instantiates
+ * Mirrors Anthropic SDK's per-endpoint module pattern: each model client
+ * has its own file, and the root client just instantiates
  * one per model. Extracted from `Ablo.ts` so the proxy logic is
  * testable in isolation and the constructor doesn't carry it.
  *
  * Each schema model gets one `ModelOperations<T, CreateInput>` —
  * exposes `retrieve`, `list`, `count`, `create`, `update`, `delete`,
- * `intent` (the coordination handle), `subscribe`, and `load`. The
- * factory returns a plain object; the client assembles the
+ * `claim`, `claimState`, `queue`, `release`, `subscribe`, and `load`.
+ * The factory returns a plain object; the client assembles the
  * `ablo.<model>` lookup table from these.
  */
 import { autorun } from 'mobx';
-import { AbloStaleContextError, AbloValidationError } from '../errors.js';
+import { AbloClaimedError, AbloValidationError } from '../errors.js';
 import { Model, modelAsRow } from '../Model.js';
 import { ModelScope } from '../types/index.js';
-const modelResourceMeta = new WeakMap();
-export function getModelResourceMeta(resource) {
-    if (typeof resource !== 'object' || resource === null)
+const modelClientMeta = new WeakMap();
+export function getModelClientMeta(modelClient) {
+    if (typeof modelClient !== 'object' || modelClient === null)
         return undefined;
-    return modelResourceMeta.get(resource);
+    return modelClientMeta.get(modelClient);
 }
 export function createModelProxy(schemaKey, registeredModelName, objectPool, syncClient, registry, hydration, collaboration) {
     const ModelClass = registry.getModelByName(registeredModelName);
@@ -42,6 +42,93 @@ export function createModelProxy(schemaKey, registeredModelName, objectPool, syn
         await syncClient.syncNow();
         await syncClient.waitForConfirmation(model.getModelName(), model.id);
     };
+    // Claims this proxy currently holds, keyed by entity id. Lets the flat
+    // `release(id)` and `update(id)` find the lease + snapshot a `claim(id)`
+    // took — no per-call handle. Released on dispose, explicit release, or TTL.
+    const activeClaims = new Map();
+    const releaseClaim = async (id) => {
+        const held = activeClaims.get(id);
+        if (!held)
+            return;
+        activeClaims.delete(id);
+        await held.lease.release();
+    };
+    const takeClaim = async (id, options) => {
+        if (!collaboration) {
+            throw new AbloValidationError(`Model "${schemaKey}" cannot claim a row without collaboration wiring.`, { code: 'model_claim_not_configured' });
+        }
+        // Is someone ELSE already on this target? Read the local coordination
+        // snapshot up front — it decides whether we'll need to re-read after the
+        // claim (a free / already-mine target can't have changed under us).
+        const held = collaboration.observe({ model: schemaKey, id });
+        const contended = !!held && held.heldBy !== collaboration.selfParticipantId;
+        const failFast = options?.wait === false;
+        // Fail-fast (`wait: false`): if another participant already holds it,
+        // reject now instead of queuing. Best-effort at the client (a racing
+        // claim not yet synced into our snapshot slips through here) — the
+        // commit-time intent guard is the authoritative backstop that rejects
+        // the loser's first write. For work-distribution dedup that's exactly
+        // right: don't wait (that would double-process), skip.
+        if (failFast && contended) {
+            throw new AbloClaimedError(`${registeredModelName}/${id} is held by ${held?.heldBy ?? 'another participant'}.`, { code: 'entity_claimed' });
+        }
+        // Ensure the row exists locally before claiming.
+        let model = objectPool.get(id);
+        if (!model) {
+            await load({ where: { id } });
+            model = objectPool.get(id);
+        }
+        if (!model) {
+            throw new AbloValidationError(`Entity not found: ${registeredModelName}/${id}`, { code: 'entity_not_found' });
+        }
+        // Acquire the lease. Default (`wait` !== false) goes through the server's
+        // fair FIFO queue — `queue: true` resolves only once the lease is genuinely
+        // ours, blocking behind any current holder, with no TOCTOU gap (the server
+        // orders contenders). Fail-fast skips the queue: we already rejected an
+        // observed conflict above, so this just records our lease.
+        const lease = await collaboration.createIntent({
+            target: {
+                model: schemaKey,
+                id,
+                ...(options?.field ? { field: options.field } : {}),
+            },
+            action: options?.action ?? 'editing',
+            ttl: options?.ttl,
+            queue: !failFast,
+            maxQueueDepth: options?.maxQueueDepth,
+        });
+        // Only when we actually waited behind another holder can the row have
+        // changed underneath us — re-read so the claimed snapshot reflects what
+        // they committed before releasing.
+        if (contended && !failFast) {
+            await load({ where: { id } });
+            model = objectPool.get(id) ?? model;
+        }
+        const snapshot = collaboration.createSnapshot(schemaKey, id);
+        activeClaims.set(id, { lease, snapshot });
+        const row = modelAsRow(model);
+        // `await using` calls this on scope exit; releases the claim.
+        Object.defineProperty(row, Symbol.asyncDispose, {
+            value: () => releaseClaim(id),
+            enumerable: false,
+            configurable: true,
+        });
+        return row;
+    };
+    function claim(id, a, b) {
+        if (typeof a === 'function') {
+            return (async () => {
+                const row = await takeClaim(id, b);
+                try {
+                    return await a(row);
+                }
+                finally {
+                    await releaseClaim(id);
+                }
+            })();
+        }
+        return takeClaim(id, a);
+    }
     const operations = {
         retrieve(id) {
             return objectPool.get(id);
@@ -99,9 +186,21 @@ export function createModelProxy(schemaKey, registeredModelName, objectPool, syn
             const model = objectPool.get(id);
             if (!model)
                 throw new AbloValidationError(`Entity not found: ${registeredModelName}/${id}`, { code: 'entity_not_found' });
+            // If we hold a claim on this row, guard the write with its snapshot
+            // watermark + lease so it's stale-rejected and attributed to the claim.
+            const claimed = activeClaims.get(id);
+            const effective = claimed
+                ? {
+                    wait: 'confirmed',
+                    readAt: claimed.snapshot.stamp,
+                    onStale: 'reject',
+                    intent: claimed.lease,
+                    ...options,
+                }
+                : options;
             model.updateFromData(data);
-            syncClient.update(model, options);
-            await waitForMutation(model, options);
+            syncClient.update(model, effective);
+            await waitForMutation(model, effective);
             return modelAsRow(model);
         },
         async delete(id, options) {
@@ -111,122 +210,20 @@ export function createModelProxy(schemaKey, registeredModelName, objectPool, syn
             syncClient.delete(model, options);
             await waitForMutation(model, options);
         },
-        intent(id) {
-            const target = { resource: schemaKey, id };
-            let acquired = null;
-            let snapshot = null;
-            let released = false;
-            let acquireWait;
-            // Public `cancel()` — drop the claim without committing. Calls the
-            // lower-level lease handle's `revoke()` (a different API; leave it).
-            const cancel = () => {
-                if (released)
-                    return;
-                released = true;
-                if (snapshot)
-                    snapshot.signal.removeEventListener('abort', cancel);
-                acquired?.revoke();
-            };
-            // Public `finish()` — give the claim back after committing. Calls the
-            // lower-level lease handle's `release()` (a different API; leave it).
-            const finish = async () => {
-                if (released)
-                    return;
-                released = true;
-                if (snapshot)
-                    snapshot.signal.removeEventListener('abort', cancel);
-                await acquired?.release();
-            };
-            const whenFree = async (options) => {
-                if (!collaboration)
-                    return;
-                await collaboration.waitFor(target, options);
-            };
-            const claim = async (options) => {
-                if (!collaboration) {
-                    throw new AbloValidationError(`Model "${schemaKey}" cannot claim an intent without collaboration wiring.`, { code: 'model_intent_not_configured' });
-                }
-                if (acquired)
-                    return;
-                acquireWait = options?.wait;
-                // Load the row so update() has a snapshot to guard against.
-                let model = objectPool.get(id);
-                if (!model) {
-                    await load({ where: { id } });
-                    model = objectPool.get(id);
-                }
-                if (!model) {
-                    throw new AbloValidationError(`Entity not found: ${registeredModelName}/${id}`, { code: 'entity_not_found' });
-                }
-                const snap = collaboration.createSnapshot(schemaKey, id);
-                snap.signal.addEventListener('abort', cancel, { once: true });
-                snapshot = snap;
-                released = false;
-                acquired = await collaboration.createIntent({
-                    target: {
-                        resource: schemaKey,
-                        id,
-                        ...(options?.field ? { field: options.field } : {}),
-                    },
-                    action: options?.action ?? 'editing',
-                    ttl: options?.ttl,
-                });
-            };
-            const claimOrWait = async (options) => {
-                if (!collaboration) {
-                    throw new AbloValidationError(`Model "${schemaKey}" cannot claim an intent without collaboration wiring.`, { code: 'model_intent_not_configured' });
-                }
-                const held = collaboration.observe(target);
-                // A foreign holder: wait for them to finish, then re-read before
-                // claiming. Our own claim (or a free target) goes straight to claim.
-                if (held && held.heldBy !== collaboration.selfParticipantId) {
-                    await whenFree();
-                    await load({ where: { id } });
-                }
-                await claim(options);
-            };
-            const handle = {
-                id,
-                get current() {
-                    return collaboration?.observe(target) ?? null;
-                },
-                get status() {
-                    return collaboration?.observe(target)?.status ?? 'idle';
-                },
-                claim,
-                claimOrWait,
-                async update(data, updateOptions) {
-                    if (!acquired || !snapshot) {
-                        throw new AbloValidationError(`Call claim() before update() on ablo.${schemaKey}.intent(${id}).`, { code: 'intent_not_acquired' });
-                    }
-                    if (snapshot.signal.aborted) {
-                        throw new AbloStaleContextError(`Intent context is stale for ${schemaKey}/${id}. Re-read the row and retry.`, {
-                            code: 'edit_context_stale',
-                            readAt: snapshot.stamp,
-                            cause: snapshot.signal.reason,
-                        });
-                    }
-                    try {
-                        return await operations.update(id, data, {
-                            wait: acquireWait ?? 'confirmed',
-                            readAt: snapshot.stamp,
-                            onStale: 'reject',
-                            ...updateOptions,
-                            intent: acquired,
-                        });
-                    }
-                    finally {
-                        await finish();
-                    }
-                },
-                finish,
-                whenFree,
-                cancel,
-                [Symbol.asyncDispose]: finish,
+        claim,
+        claimState(id) {
+            return collaboration?.observe({ model: schemaKey, id }) ?? null;
+        },
+        queue(id) {
+            return {
+                object: 'list',
+                data: collaboration?.queue({ model: schemaKey, id }) ?? [],
             };
-            return handle;
         },
-        subscribe(callback, options) {
+        release(id) {
+            return releaseClaim(id);
+        },
+        onChange(callback, options) {
             return autorun(() => {
                 const entities = this.list(options);
                 callback(entities);
@@ -234,7 +231,7 @@ export function createModelProxy(schemaKey, registeredModelName, objectPool, syn
         },
         load,
     };
-    modelResourceMeta.set(operations, {
+    modelClientMeta.set(operations, {
         key: schemaKey,
         typename: registeredModelName,
     });

package/dist/client/index.d.ts

@@ -15,22 +15,21 @@
  *   apiKey: process.env.ABLO_API_KEY,
  * });
  *
- * const tasks = ablo.tasks.list({ where: { status: 'todo' } });
- * await ablo.tasks.create({ title: 'New task' });
+ * const reports = ablo.weatherReports.list({ where: { status: 'pending' } });
+ * await ablo.weatherReports.create({ location: 'Stockholm', status: 'pending' });
  * ```
  *
- * For headless agents (workers, bots), pass `kind: 'agent'` plus a
- * restricted (`rk_`) API key as `capabilityToken`:
+ * For headless agents (workers, bots), pass the same schema and an API key
+ * scoped for that server runtime:
  *
  * ```ts
  * const bot = Ablo({
  *   schema,
  *   apiKey: process.env.ABLO_API_KEY,
- *   kind: 'agent',
  * });
  * ```
  */
-export { Ablo, computeFKDepthPriority, type AbloOptions, type InternalAbloOptions, type BusyOptions, type BusyPolicy, type IntentWaitOptions, type ModelCountOptions, type ModelListOptions, type ModelListScope, type ModelLoadOptions, type ModelOperations, type ResourceReadOptions, } from './Ablo.js';
+export { Ablo, computeFKDepthPriority, type AbloOptions, type InternalAbloOptions, type ClaimedOptions, type IfClaimedPolicy, type IntentWaitOptions, type ModelCountOptions, type ModelListOptions, type ModelListScope, type ModelLoadOptions, type ModelOperations, type ModelReadOptions, } from './Ablo.js';
 export type { AbloPersistence } from './persistence.js';
-export type { AbloApi, AbloApiClientOptions, AbloApiIntents, Agent, AgentIntentInput, AgentIntentOptions, AgentOptions, AgentResourceClient, AgentResourceReadOptions, AgentResourceMutationOptions, AgentRunContext, AgentRunDone, AgentRunFailed, AgentRunCancelled, AgentRunOptions, AgentRunResult, AgentRunStatus, Capability, CapabilityCreateOptions, CapabilityParticipantKind, CapabilityRecord, CapabilityResource, CapabilityRevocation, CapabilityScope, Task, TaskCloseOptions, TaskCloseResult, TaskCreateOptions, TaskResource, } from './ApiClient.js';
+export type { AbloApi, AbloApiClientOptions, AbloApiIntents, Agent, AgentIntentInput, AgentIntentOptions, AgentOptions, AgentModelClient, AgentModelReadOptions, AgentModelMutationOptions, AgentRunContext, AgentRunDone, AgentRunFailed, AgentRunCancelled, AgentRunOptions, AgentRunResult, AgentRunStatus, Capability, CapabilityCreateOptions, CapabilityParticipantKind, CapabilityRecord, CapabilityResource, CapabilityRevocation, CapabilityScope, Task, TaskCloseOptions, TaskCloseResult, TaskCreateOptions, TaskResource, } from './ApiClient.js';
 export type { EngineParticipant, JoinedParticipant, ParticipantJoinOptions, ParticipantManager, ParticipantScope, ParticipantStatus, ScopedIntents, ScopedPresence, } from '../sync/participants.js';

package/dist/client/index.js

@@ -15,18 +15,17 @@
  *   apiKey: process.env.ABLO_API_KEY,
  * });
  *
- * const tasks = ablo.tasks.list({ where: { status: 'todo' } });
- * await ablo.tasks.create({ title: 'New task' });
+ * const reports = ablo.weatherReports.list({ where: { status: 'pending' } });
+ * await ablo.weatherReports.create({ location: 'Stockholm', status: 'pending' });
  * ```
  *
- * For headless agents (workers, bots), pass `kind: 'agent'` plus a
- * restricted (`rk_`) API key as `capabilityToken`:
+ * For headless agents (workers, bots), pass the same schema and an API key
+ * scoped for that server runtime:
  *
  * ```ts
  * const bot = Ablo({
  *   schema,
  *   apiKey: process.env.ABLO_API_KEY,
- *   kind: 'agent',
  * });
  * ```
  */

package/dist/client/validateAbloOptions.js

@@ -17,9 +17,9 @@ export function validateAbloOptions(input) {
         return new Error('Ablo: `url` is required. Pass the sync server URL, e.g. ' +
             `Ablo({ baseURL: 'wss://sync.ablo.dev', schema, user })`);
     }
-    // Schema is optional for the resource-first API:
-    //   Ablo({ apiKey }).resource('clauses').retrieve(...)
-    // Passing a schema only enables typed model sugar (`ablo.tasks.update(...)`).
+    // Schema is optional for the model-first API:
+    //   Ablo({ apiKey }).model('clauses').retrieve(...)
+    // Passing a schema only enables typed model sugar (`ablo.weatherReports.update(...)`).
     if (!configuredApiKey &&
         !configuredAuthToken &&
         !options.capabilityToken &&

package/dist/core/index.d.ts

@@ -28,6 +28,8 @@ export { ObjectStore } from '../stores/ObjectStore.js';
 export { NetworkMonitor } from '../NetworkMonitor.js';
 export { SyncWebSocket, type SyncDelta, type VersionVector, type BootstrapHint, type SyncGroupChangePayload, type BootstrapDataEvent, type PresenceUpdateEvent, type SyncWebSocketOptions, } from '../sync/SyncWebSocket.js';
 export { BootstrapHelper, type BootstrapData, type BootstrapOptions, type BootstrapFetchResult } from '../sync/BootstrapHelper.js';
+export { createIntentStream, type AttachableIntentStream, type IntentStreamConfig, } from '../sync/createIntentStream.js';
+export { awaitIntentGrant, type GrantTransport, } from '../sync/awaitIntentGrant.js';
 export { OfflineTransactionStore, offlineTxStore, Priority } from '../sync/OfflineTransactionStore.js';
 export { PropertyType, LoadStrategy, MutationOperationType } from '../types/index.js';
 export type { PropertyMetadata, ReferenceMetadata, ModelMetadata, SyncAction, DeltaPacket, BootstrapMetadata, DatabaseMetadata, } from '../types/index.js';

package/dist/core/index.js

@@ -49,6 +49,13 @@ export { NetworkMonitor } from '../NetworkMonitor.js';
 // Sync layer
 export { SyncWebSocket, } from '../sync/SyncWebSocket.js';
 export { BootstrapHelper } from '../sync/BootstrapHelper.js';
+// Intent coordination primitives (the lower-level pieces behind the
+// consumer-facing `ablo.<model>.claim`). The stream factory builds the
+// announce/await machinery on a SyncWebSocket; `awaitIntentGrant` is the
+// fair-queue grant coordinator. Exposed on /core for framework-level
+// orchestration and e2e harnesses — NOT on the consumer `.` root.
+export { createIntentStream, } from '../sync/createIntentStream.js';
+export { awaitIntentGrant, } from '../sync/awaitIntentGrant.js';
 // Offline transaction queue — moved out of the main barrel in the headless
 // audit cleanup (see docs/headless-audit.md §4.1 Task 23). The class
 // touches indexedDB + crypto.subtle and therefore cannot live on the main

package/dist/errors.d.ts

@@ -111,21 +111,21 @@ export declare class AbloStaleContextError extends AbloError {
     });
 }
 /**
- * The target entity currently has an active intent held by another
- * participant and the caller asked the SDK not to return immediately.
+ * The target entity is currently claimed by another participant and the caller
+ * asked the SDK not to read/write through that claim.
  *
- * Use `ifBusy: 'wait'` to wait for the intent stream to clear, or
- * `ifBusy: 'return'` to inspect the active intents yourself.
+ * Use `ifClaimed: 'wait'` to wait for the claim to clear, or
+ * `ifClaimed: 'return'` to inspect active claims yourself.
  */
-export declare class AbloBusyError extends AbloError {
-    readonly type: "AbloBusyError";
-    readonly intents?: ReadonlyArray<unknown>;
+export declare class AbloClaimedError extends AbloError {
+    readonly type: "AbloClaimedError";
+    readonly claims?: ReadonlyArray<unknown>;
     constructor(message: string, options?: {
         code?: string;
         httpStatus?: number;
         requestId?: string;
         cause?: unknown;
-        intents?: ReadonlyArray<unknown>;
+        claims?: ReadonlyArray<unknown>;
     });
 }
 /**

package/dist/errors.js

@@ -109,19 +109,19 @@ export class AbloStaleContextError extends AbloError {
     }
 }
 /**
- * The target entity currently has an active intent held by another
- * participant and the caller asked the SDK not to return immediately.
+ * The target entity is currently claimed by another participant and the caller
+ * asked the SDK not to read/write through that claim.
  *
- * Use `ifBusy: 'wait'` to wait for the intent stream to clear, or
- * `ifBusy: 'return'` to inspect the active intents yourself.
+ * Use `ifClaimed: 'wait'` to wait for the claim to clear, or
+ * `ifClaimed: 'return'` to inspect active claims yourself.
  */
-export class AbloBusyError extends AbloError {
-    type = 'AbloBusyError';
-    intents;
+export class AbloClaimedError extends AbloError {
+    type = 'AbloClaimedError';
+    claims;
     constructor(message, options) {
         super(message, options);
-        if (options?.intents !== undefined)
-            this.intents = options.intents;
+        if (options?.claims !== undefined)
+            this.claims = options.claims;
     }
 }
 /**
@@ -224,7 +224,8 @@ export function translateHttpError(status, body, requestId) {
         flatError ??
         (typeof body === 'string' ? body : `HTTP ${status}`);
     const requiredCapability = nested?.requiredCapability ?? parsed.requiredCapability;
-    const baseOpts = { code, httpStatus: status, requestId };
+    const publicCode = code === 'intent_conflict' ? 'claim_conflict' : code;
+    const baseOpts = { code: publicCode, httpStatus: status, requestId };
     if (status === 401)
         return new AbloAuthenticationError(message, baseOpts);
     if (status === 403 || code === 'capability_scope_denied' || code === 'capability_invalid') {
@@ -233,6 +234,13 @@ export function translateHttpError(status, body, requestId) {
         }
         return new AbloPermissionError(message, baseOpts);
     }
+    // Claim enforcement also rides 409 (a commit blocked by a foreign claim).
+    // Discriminate on the code BEFORE the generic idempotency mapping so a
+    // claim rejection surfaces as AbloClaimedError, not AbloIdempotencyError —
+    // same typed error the WebSocket commit path yields for these codes.
+    if (code === 'intent_conflict' || code === 'claim_conflict' || code === 'entity_claimed') {
+        return new AbloClaimedError(message, baseOpts);
+    }
     if (status === 409)
         return new AbloIdempotencyError(message, baseOpts);
     if (status === 422 || status === 400)

package/dist/index.d.ts

@@ -5,17 +5,17 @@
  * import Ablo from '@abloatai/ablo';
  *
  * const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY });
- * await ablo.tasks.load({ where: { id: 'task_123' } });
- * await ablo.tasks.update('task_123', { title: 'Fix bug' });
+ * await ablo.weatherReports.load({ where: { id: 'report_stockholm' } });
+ * await ablo.weatherReports.update('report_stockholm', { status: 'ready' });
  *
  * type Entry = Ablo.Peer;
  * ```
  *
- * `Ablo({ schema, apiKey })` gives typed model resources. `Ablo({ apiKey })`
- * gives the lower-level Resource / Intent / Commit client for agents,
- * MCP routes, and custom runtimes.
+ * `Ablo({ schema, apiKey })` gives typed model clients. `Ablo({ apiKey })`
+ * gives the HTTP model/commit client for agents, MCP routes, and custom
+ * runtimes.
  *
- * Stripe / Anthropic / OpenAI all do this: one import, resources
+ * Stripe / Anthropic / OpenAI all do this: one import, model clients
  * reached via dot-access on the engine, types via namespace dots.
  *
  * Public subpaths:
@@ -42,14 +42,15 @@
  * If you don't recognize one, you don't need it — the default path covers you.
  */
 export { Ablo } from './client/Ablo.js';
-export type { AbloOptions, ModelCountOptions, ModelListOptions, ModelListScope, ModelLoadOptions, ModelIntentHandle, ModelIntentAcquireOptions, ModelOperations, } from './client/Ablo.js';
+export type { AbloOptions, ModelCountOptions, ModelListOptions, ModelListScope, ModelLoadOptions, ClaimOptions, ClaimedRow, ModelOperations, } from './client/Ablo.js';
 export type { AbloPersistence } from './client/persistence.js';
 export { session, agent } from './principal.js';
 import { Ablo } from './client/Ablo.js';
 export default Ablo;
 export { dataSource, abloSource, signAbloSourceRequest, verifyAbloSourceRequest, } from './source/index.js';
 export { defaultPolicy } from './policy/index.js';
-export { SyncSessionError, AbloError, AbloAuthenticationError, AbloPermissionError, AbloRateLimitError, AbloIdempotencyError, AbloConnectionError, AbloValidationError, AbloServerError, AbloStaleContextError, AbloBusyError, CapabilityError, translateHttpError, } from './errors.js';
+export { SyncSessionError, AbloError, AbloAuthenticationError, AbloPermissionError, AbloRateLimitError, AbloIdempotencyError, AbloConnectionError, AbloValidationError, AbloServerError, AbloStaleContextError, AbloClaimedError, CapabilityError, translateHttpError, } from './errors.js';
 export type { CommitReceipt, RequiredCapability } from './errors.js';
+export type { Register, DefaultSyncShape } from './types/global.js';
 export { defineMutators } from './mutators/defineMutators.js';
 export { createTransaction, type Transaction } from './mutators/Transaction.js';

package/dist/index.js

@@ -5,17 +5,17 @@
  * import Ablo from '@abloatai/ablo';
  *
  * const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY });
- * await ablo.tasks.load({ where: { id: 'task_123' } });
- * await ablo.tasks.update('task_123', { title: 'Fix bug' });
+ * await ablo.weatherReports.load({ where: { id: 'report_stockholm' } });
+ * await ablo.weatherReports.update('report_stockholm', { status: 'ready' });
  *
  * type Entry = Ablo.Peer;
  * ```
  *
- * `Ablo({ schema, apiKey })` gives typed model resources. `Ablo({ apiKey })`
- * gives the lower-level Resource / Intent / Commit client for agents,
- * MCP routes, and custom runtimes.
+ * `Ablo({ schema, apiKey })` gives typed model clients. `Ablo({ apiKey })`
+ * gives the HTTP model/commit client for agents, MCP routes, and custom
+ * runtimes.
  *
- * Stripe / Anthropic / OpenAI all do this: one import, resources
+ * Stripe / Anthropic / OpenAI all do this: one import, model clients
  * reached via dot-access on the engine, types via namespace dots.
  *
  * Public subpaths:
@@ -78,11 +78,7 @@ export { defaultPolicy } from './policy/index.js';
 // Typed error hierarchy — Stripe-style. One import gets every class
 // consumers need to discriminate failures (`e instanceof AbloX` or
 // `e.type === 'AbloX'`) plus the HTTP-response translator.
-export { SyncSessionError, AbloError, AbloAuthenticationError, AbloPermissionError, AbloRateLimitError, AbloIdempotencyError, AbloConnectionError, AbloValidationError, AbloServerError, AbloStaleContextError, AbloBusyError, CapabilityError, translateHttpError, } from './errors.js';
-// Typed-global augmentation point. Consumers declare their Schema/Presence/
-// Intents/UserMeta once in a `.d.ts` via `declare global { interface AbloSync
-// { ... } }`. Resolver types live under the `Ablo` namespace —
-// `Ablo.ResolveSchema`, `Ablo.ResolvePresence`, etc. — pure type-level.
+export { SyncSessionError, AbloError, AbloAuthenticationError, AbloPermissionError, AbloRateLimitError, AbloIdempotencyError, AbloConnectionError, AbloValidationError, AbloServerError, AbloStaleContextError, AbloClaimedError, CapabilityError, translateHttpError, } from './errors.js';
 // Advanced — most apps never import this. Custom (Zero-style) mutators:
 // `ablo.<model>.create/update/delete` already covers normal writes. Reach
 // for `defineMutators` only when you need a named, multi-step mutation with

package/dist/interfaces/index.d.ts

@@ -151,18 +151,11 @@ export interface CommitResult {
  *   When omitted, the SDK auto-generates a UUIDv4 per mutation so every
  *   call is retry-safe by default. Opt out with `{ idempotencyKey: null }`
  *   if you genuinely want retry-unsafe writes (rare).
- * - `timeout` — abort the request if it takes longer than this many ms.
- *   No default (uses underlying transport's timeout).
- * - `maxNetworkRetries` — retry with exponential backoff on 5xx / 429 /
- *   network errors. The same `idempotencyKey` is reused across retries
- *   so the server dedupes correctly. Default: 0.
  * - `label` — human-readable audit tag. Flows to `mutation_log.label`
  *   server-side for operator debugging ("nightly cleanup", "user click").
  */
 export interface MutationOptions {
     idempotencyKey?: string | null;
-    timeout?: number;
-    maxNetworkRetries?: number;
     label?: string;
     wait?: 'queued' | 'confirmed';
     readAt?: number | null;
@@ -205,9 +198,8 @@ export interface MutationOperation {
     /**
      * Per-op idempotency + audit metadata. `idempotencyKey` doubles as
      * the `mutation_log.client_tx_id` cache key; `label` is persisted to
-     * `mutation_log.label` for debugging. Client-only fields (`timeout`,
-     * `maxNetworkRetries`) are handled at the transport layer and are
-     * NOT sent over the wire.
+     * `mutation_log.label` for debugging. These are the only `MutationOptions`
+     * fields carried over the wire.
      */
     options?: Pick<MutationOptions, 'idempotencyKey' | 'label'>;
 }

package/dist/mutators/Transaction.d.ts

@@ -21,8 +21,8 @@
  */
 import type { Schema } from '../schema/schema.js';
 import type { SyncStoreContract } from '../react/context.js';
-import { type MutateActions } from '../react/useMutate.js';
-import { type ReaderActions, type ReaderFindOptions } from '../react/useReader.js';
+import { type MutateActions } from './mutateActions.js';
+import { type ReaderActions, type ReaderFindOptions } from './readerActions.js';
 /**
  * The full transaction surface. `tx.mutations.<key>.*` for writes,
  * `tx.read.<key>.*` for imperative reads. Re-exports the base read options

package/dist/mutators/Transaction.js

@@ -19,8 +19,8 @@
  * microtask coalescer in `TransactionQueue` collapses N pushes into one
  * wire commit. Same shape Zero uses: no `insertMany`, just an array map.
  */
-import { createMutateActions } from '../react/useMutate.js';
-import { createReaderActions } from '../react/useReader.js';
+import { createMutateActions } from './mutateActions.js';
+import { createReaderActions } from './readerActions.js';
 import { AbloValidationError } from '../errors.js';
 /**
  * Build a Transaction for a single mutator invocation. The returned object