@abloatai/ablo 0.10.1 → 0.11.0

package/dist/client/Ablo.d.ts

@@ -20,15 +20,17 @@
  */
 import type { Schema, SchemaRecord, InferModel, InferCreate } from '../schema/schema.js';
 import type { SyncEngineConfig, SyncLogger, MutationExecutor, MutationDispatcher, SyncObservabilityProvider, SyncAnalytics, SessionErrorDetector, OnlineStatusProvider } from '../interfaces/index.js';
+import type { ModelTarget, ModelClaim } from '../coordination/schema.js';
+export type { ModelTarget, ModelClaim };
 import { ObjectPool } from '../ObjectPool.js';
 import type { SyncStoreContract } from '../react/context.js';
 import type { SyncWebSocket } from '../sync/SyncWebSocket.js';
 import type { SyncGroupInput } from '../schema/roles.js';
 import { type SyncStatus } from '../BaseSyncedStore.js';
-import type { IntentStream, IntentWaitOptions, PresenceStream, Snapshot } from '../types/streams.js';
+import type { ClaimStream, ClaimWaitOptions, PresenceStream, Snapshot } from '../types/streams.js';
 import type { ParticipantManager } from '../sync/participants.js';
-import type { ActiveIntent, Duration, Intent, TargetRange } from '../types/streams.js';
-import { type AbloApi, type AbloApiClientOptions, type AbloApiIntents } from './ApiClient.js';
+import type { ClaimHandle, Duration, Claim } from '../types/streams.js';
+import { type AbloApi, type AbloApiClientOptions, type AbloApiClaims } from './ApiClient.js';
 import { type AbloHttpClient, type AbloHttpClientOptions } from './httpClient.js';
 /**
  * Async function that resolves an apiKey at request time. Use for
@@ -384,30 +386,9 @@ export interface InternalAbloOptions<S extends SchemaRecord = SchemaRecord> {
  *   `claim({ id })` — durable claim handle for coordinated writes
  */
 export type { ModelCountOptions, ModelListOptions, ModelListScope, ModelLoadOptions, ModelRetrieveParams, ModelCreateParams, ModelUpdateParams, ModelDeleteParams, ClaimOptions, ClaimParams, ClaimLookupParams, ClaimReorderParams, ClaimHandle, ModelOperations, } from './createModelProxy.js';
-import type { ModelOperations, ClaimOptions, ClaimParams, ClaimLookupParams, ClaimReorderParams, ClaimHandle, ModelLoadOptions } from './createModelProxy.js';
+import type { ModelOperations, ClaimOptions, ClaimParams, ClaimLookupParams, ClaimReorderParams, ModelLoadOptions } from './createModelProxy.js';
 export type ModelOperationAction = 'create' | 'update' | 'delete' | 'archive' | 'unarchive';
 export type CommitWait = 'queued' | 'confirmed';
-export interface ModelTarget {
-    /** The model name — matches `ablo.<model>` and the schema's `model()`. */
-    readonly model: string;
-    readonly id: string;
-    readonly path?: string;
-    readonly range?: TargetRange;
-    readonly field?: string;
-    readonly meta?: Record<string, unknown>;
-}
-export interface ModelClaim {
-    readonly id: string;
-    readonly actor: string;
-    readonly participantKind: ActiveIntent['participantKind'];
-    readonly action: string;
-    readonly description?: string;
-    readonly field?: string;
-    readonly status?: 'active' | 'queued';
-    readonly position?: number;
-    readonly expiresAt: string;
-    readonly target: ModelTarget;
-}
 export interface ModelRead<T = Record<string, unknown>> {
     readonly data: T;
     readonly stamp: number;
@@ -431,18 +412,18 @@ export interface ClaimedOptions {
      */
     readonly maxQueueDepth?: number;
 }
-export type { IntentWaitOptions } from '../types/streams.js';
+export type { ClaimWaitOptions } from '../types/streams.js';
 export interface ModelReadOptions extends ClaimedOptions {
 }
-export interface IntentCreateOptions {
+export interface ClaimCreateOptions {
     readonly target: ModelTarget;
     readonly action: string;
     readonly ttl?: Duration;
     /**
      * Join the server's fair FIFO queue when the target is already claimed,
      * rather than failing immediately. `create` then resolves only once the
-     * lease is actually ours (the server pushes `intent_acquired` if the target
-     * was free, or `intent_granted` when we reach the head of the line). Without
+     * lease is actually ours (the server pushes `claim_acquired` if the target
+     * was free, or `claim_granted` when we reach the head of the line). Without
      * this, a contended claim throws. Used by `ablo.<model>.claim` so writers
      * serialize instead of racing.
      */
@@ -455,20 +436,6 @@ export interface IntentCreateOptions {
      */
     readonly maxQueueDepth?: number;
 }
-export interface IntentHandle extends AsyncDisposable {
-    readonly id: string;
-    /**
-     * True when the lease was granted AFTER waiting in the server's FIFO
-     * queue behind a holder (`intent_granted`), false/absent for an
-     * immediate grant (`intent_acquired`). Consumers re-read the target
-     * row when this is set — the row may have changed while we queued, and
-     * the local coordination snapshot can't detect that for org-scoped
-     * subscriptions (intent fan-out is entity-scoped).
-     */
-    readonly waited?: boolean;
-    release(): Promise<void>;
-    revoke(): void;
-}
 export interface CommitOperationInput {
     readonly action: ModelOperationAction;
     /** The model name — matches `ablo.<model>` and the schema's `model()`. */
@@ -481,7 +448,7 @@ export interface CommitOperationInput {
     readonly onStale?: 'reject' | 'force' | 'flag' | 'merge' | null;
 }
 export interface CommitCreateOptions {
-    readonly intent?: string | {
+    readonly claimRef?: string | {
         readonly id: string;
     } | null;
     readonly idempotencyKey?: string | null;
@@ -508,13 +475,13 @@ export interface CommitReceipt {
 export interface CommitResource {
     create(options: CommitCreateOptions): Promise<CommitReceipt>;
 }
-export interface IntentResource extends IntentStream {
-    create(options: IntentCreateOptions): Promise<IntentHandle>;
+export interface ClaimResource extends ClaimStream {
+    create(options: ClaimCreateOptions): Promise<ClaimHandle>;
     list(target?: Partial<ModelTarget>): readonly ModelClaim[];
-    waitFor(target: Partial<ModelTarget>, options?: IntentWaitOptions): Promise<void>;
+    waitFor(target: Partial<ModelTarget>, options?: ClaimWaitOptions): Promise<void>;
 }
 export interface ModelMutationOptions extends ClaimedOptions {
-    readonly intent?: string | {
+    readonly claimRef?: string | {
         readonly id: string;
     } | null;
     readonly idempotencyKey?: string | null;
@@ -537,14 +504,14 @@ export interface HttpClaimApi<T> {
      * Current holder of the lease on a row, or `null` when free. For UI badges,
      * preflight checks, and operators.
      */
-    state(params: ClaimLookupParams<T>): Promise<Intent | null>;
+    state(params: ClaimLookupParams<T>): Promise<Claim | null>;
     /**
      * FIFO wait line behind the holder. Advanced: useful for operator UIs and
      * schedulers.
      */
     queue(params: ClaimLookupParams<T>): Promise<{
         readonly object: 'list';
-        readonly data: readonly Intent[];
+        readonly data: readonly Claim[];
     }>;
     /**
      * Re-rank the wait line. Advanced and permission-gated.
@@ -859,7 +826,7 @@ export type Ablo<S extends SchemaRecord> = {
      * Canonical multiplayer participant surface. Joins a structured app
      * target, derives the transport scope internally, opens a scoped
      * claim on the existing WebSocket, and returns target-bound presence
-     * + intent helpers.
+     * + claim helpers.
      *
      * ```ts
      * const participant = await ablo.participants.join({
@@ -869,7 +836,7 @@ export type Ablo<S extends SchemaRecord> = {
      *   range: { startLine: 10, endLine: 40 },
      * });
      * participant.presence.editing();
-     * const claim = participant.intents.claim('rewrite imports');
+     * const claim = participant.claims.claim('rewrite imports');
      * ```
      */
     readonly participants: ParticipantManager;
@@ -1000,7 +967,7 @@ import type * as _SchemaTypes from '../schema/schema.js';
 export declare namespace Ablo {
     type Options<S extends SchemaRecord = SchemaRecord> = AbloOptions<S>;
     type Api = AbloApi;
-    type ApiIntents = AbloApiIntents;
+    type ApiClaims = AbloApiClaims;
     type Capability = import('./ApiClient.js').Capability;
     type CapabilityCreateOptions = import('./ApiClient.js').CapabilityCreateOptions;
     type CapabilityRecord = import('./ApiClient.js').CapabilityRecord;
@@ -1015,13 +982,13 @@ export declare namespace Ablo {
     type TargetRange = _Streams.TargetRange;
     type Duration = _Streams.Duration;
     type PresenceStream = _Streams.PresenceStream;
-    type IntentStream = _Streams.IntentStream;
+    type ClaimStream = _Streams.ClaimStream;
     type Peer = _Streams.Peer;
     type Activity = _Streams.Activity;
-    type ActiveIntent = _Streams.ActiveIntent;
-    type Claim = _Streams.Claim;
-    type IntentRejection = _Streams.IntentRejection;
-    type IntentLost = _Streams.IntentLost;
+    type ActiveClaim = _Streams.ActiveClaim;
+    type ClaimHandle = _Streams.ClaimHandle;
+    type ClaimRejection = _Streams.ClaimRejection;
+    type ClaimLost = _Streams.ClaimLost;
     type Snapshot<TSchema extends _SchemaTypes.Schema = _SchemaTypes.Schema, K extends keyof TSchema['models'] = keyof TSchema['models']> = _Streams.Snapshot<TSchema, K>;
     namespace Auth {
         type Principal = _Streams.Principal;
@@ -1057,11 +1024,11 @@ export declare namespace Ablo {
         type Receipt = import('./Ablo.js').CommitReceipt;
         type Client = import('./Ablo.js').CommitResource;
     }
-    namespace Intent {
-        type Handle = import('./Ablo.js').IntentHandle;
-        type CreateOptions = import('./Ablo.js').IntentCreateOptions;
-        type WaitOptions = import('./Ablo.js').IntentWaitOptions;
-        type Client = import('./Ablo.js').IntentResource;
+    namespace Claim {
+        type Handle = import('./Ablo.js').ClaimHandle;
+        type CreateOptions = import('./Ablo.js').ClaimCreateOptions;
+        type WaitOptions = import('./Ablo.js').ClaimWaitOptions;
+        type Client = import('./Ablo.js').ClaimResource;
     }
     namespace Model {
         type Target = import('./Ablo.js').ModelTarget;

package/dist/client/Ablo.js

@@ -19,7 +19,9 @@
  *   await sync.reports.delete({ id: reportId });
  */
 import { z } from 'zod';
-import { AbloClaimedError, AbloError, AbloAuthenticationError, AbloConnectionError, AbloValidationError, translateHttpError, toAbloError } from '../errors.js';
+import { baseFieldsSchema } from '../schema/schema.js';
+import { AbloError, AbloAuthenticationError, AbloConnectionError, AbloValidationError, translateHttpError, toAbloError, claimedError } from '../errors.js';
+import { descriptionFromMeta } from '../coordination/schema.js';
 import { LoadStrategy, PropertyType } from '../types/index.js';
 import { initSyncEngine } from '../context.js';
 import { noopObservability, browserOnlineStatus, defaultSessionErrorDetector, noopAnalytics, } from '../SyncEngineContext.js';
@@ -32,8 +34,8 @@ import { resolveParticipantIdentity } from './identity.js';
 import { Model } from '../Model.js';
 import { BaseSyncedStore } from '../BaseSyncedStore.js';
 import { createPresenceStream } from '../sync/createPresenceStream.js';
-import { createIntentStream } from '../sync/createIntentStream.js';
-import { awaitIntentGrant } from '../sync/awaitIntentGrant.js';
+import { createClaimStream } from '../sync/createClaimStream.js';
+import { awaitClaimGrant } from '../sync/awaitClaimGrant.js';
 import { createSnapshot } from '../sync/createSnapshot.js';
 import { createParticipantManager } from '../sync/participants.js';
 import { createProtocolClient, } from './ApiClient.js';
@@ -240,7 +242,18 @@ function registerModelsFromSchema(schema, registry) {
         }
         // Create a dynamic Model subclass with JSON sub-property getters
         const isLazy = modelDef.lazyObservable === true;
-        const fieldNames = Object.keys(modelDef.shape);
+        // Base provenance fields (`organizationId`, `createdBy`) live in
+        // `baseFieldsSchema`, not the per-model `shape`. The server stamps + emits
+        // them (camelCased on the wire), but hydration (`Model.assignFieldsFromData`)
+        // only assigns keys that already exist as an own/prototype property — so
+        // without a slot here, `deck.createdBy` / `deck.organizationId` silently read
+        // `undefined` (this is why the profile decks tab showed nothing: it filters
+        // `decks.filter(d => d.createdBy === userId)`). `id`/`createdAt`/`updatedAt`
+        // are already seeded by the base Model constructor, so they're excluded.
+        const fieldNames = [
+            ...Object.keys(modelDef.shape),
+            ...Object.keys(baseFieldsSchema.shape).filter((f) => f !== 'id' && f !== 'createdAt' && f !== 'updatedAt' && !(f in modelDef.shape)),
+        ];
         const computed = modelDef.computed;
         const DynamicModel = createDynamicModelClass(modelName, jsonSubFields, fieldNames, computed, isLazy);
         // Respect the schema's load strategy so lazy models skip IDB hydration + bootstrap
@@ -821,8 +834,8 @@ export function Ablo(options) {
     // becomes null, so the first Ablo's commits start throwing
     // `ws_not_ready` forever (terminal AgentJob writes hang on retry).
     syncClient.getTransactionQueue().setMutationExecutor(executor);
-    // Presence + intent streams — built eagerly so `engine.presence`
-    // and `engine.intents` return the same reference for the engine's
+    // Presence + claim streams — built eagerly so `engine.presence`
+    // and `engine.claims` return the same reference for the engine's
     // lifetime. The transport doesn't exist yet (BaseSyncedStore.initialize
     // creates it during ready()), so both streams are constructed in
     // deferred-attach mode and wired after initialize() resolves below.
@@ -837,12 +850,12 @@ export function Ablo(options) {
         syncGroups: internalOptions.syncGroups ?? [],
         isAgent: internalOptions.kind === 'agent',
     });
-    const intentStream = createIntentStream({ participantId });
+    const claimStream = createClaimStream({ participantId });
     const participantManager = createParticipantManager({
         ready,
         getTransport: () => store.getSyncWebSocket() ?? null,
         presence: presenceStream,
-        intents: intentStream,
+        claims: claimStream,
         schema,
     });
     // 6. Validate options up front — fail loudly on obviously wrong inputs so
@@ -990,14 +1003,14 @@ export function Ablo(options) {
                             code: 'bootstrap_fetch_timeout',
                         });
                 }
-                // Wire presence + intents to the now-open transport.
+                // Wire presence + claims to the now-open transport.
                 // `getSyncWebSocket()` returns non-null after a successful
                 // initialize() — the WS is created during the generator's
                 // connect step.
                 const ws = store.getSyncWebSocket();
                 if (ws) {
                     presenceStream.attach(ws);
-                    intentStream.attach(ws);
+                    claimStream.attach(ws);
                 }
                 logger.info('Sync engine ready', { models: Object.keys(schema.models).length });
             }
@@ -1073,10 +1086,10 @@ export function Ablo(options) {
             ? crypto.randomUUID()
             : `id_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
     }
-    function normalizeIntentId(intent) {
-        if (typeof intent === 'string')
-            return intent;
-        return intent?.id;
+    function normalizeClaimId(claim) {
+        if (typeof claim === 'string')
+            return claim;
+        return claim?.id;
     }
     function isClaimHandleValue(value) {
         return (typeof value === 'object' &&
@@ -1113,82 +1126,72 @@ export function Ablo(options) {
         }
         return inputOperations.map((op) => normalizeCommitOperation(op, commitOptions));
     }
-    function modelClaimFromActive(intent) {
-        const description = typeof intent.target.meta?.description === 'string'
-            ? intent.target.meta.description
-            : undefined;
+    function modelClaimFromActive(claim) {
+        const description = descriptionFromMeta(claim.target.meta);
         return {
-            id: intent.id,
-            actor: intent.heldBy,
-            participantKind: intent.participantKind,
-            action: intent.reason,
+            id: claim.id,
+            actor: claim.heldBy,
+            participantKind: claim.participantKind,
+            action: claim.reason,
             ...(description ? { description } : {}),
-            field: intent.target.field,
+            field: claim.target.field,
             status: 'active',
-            expiresAt: intent.expiresAt,
+            expiresAt: claim.expiresAt,
             target: {
-                model: intent.target.type,
-                id: intent.target.id,
-                path: intent.target.path,
-                range: intent.target.range,
-                field: intent.target.field,
-                meta: intent.target.meta,
+                model: claim.target.type,
+                id: claim.target.id,
+                path: claim.target.path,
+                range: claim.target.range,
+                field: claim.target.field,
+                meta: claim.target.meta,
             },
         };
     }
-    function modelClaimFromQueued(intent) {
+    function modelClaimFromQueued(claim) {
         return {
-            id: intent.id,
-            actor: intent.heldBy,
-            participantKind: intent.participantKind,
-            action: intent.action,
-            ...(intent.description ? { description: intent.description } : {}),
-            field: intent.target.field,
+            id: claim.id,
+            actor: claim.heldBy,
+            participantKind: claim.participantKind,
+            action: claim.action,
+            ...(claim.description ? { description: claim.description } : {}),
+            field: claim.target.field,
             status: 'queued',
-            position: intent.position,
-            expiresAt: intent.expiresAt,
+            position: claim.position,
+            expiresAt: claim.expiresAt,
             target: {
-                model: intent.target.type,
-                id: intent.target.id,
-                path: intent.target.path,
-                range: intent.target.range,
-                field: intent.target.field,
-                meta: intent.target.meta,
+                model: claim.target.type,
+                id: claim.target.id,
+                path: claim.target.path,
+                range: claim.target.range,
+                field: claim.target.field,
+                meta: claim.target.meta,
             },
         };
     }
-    function targetMatchesModel(target, intent) {
+    function targetMatchesModel(target, claim) {
         if (target.model &&
-            intent.target.type.toLowerCase() !== target.model.toLowerCase()) {
+            claim.target.type.toLowerCase() !== target.model.toLowerCase()) {
             return false;
         }
-        if (target.id && intent.target.id !== target.id)
+        if (target.id && claim.target.id !== target.id)
             return false;
-        if (target.field && intent.target.field !== target.field)
+        if (target.field && claim.target.field !== target.field)
             return false;
         return true;
     }
     function listModelClaims(target) {
-        return intentStream.others
-            .filter((intent) => (target ? targetMatchesModel(target, intent) : true))
+        return claimStream.others
+            .filter((claim) => (target ? targetMatchesModel(target, claim) : true))
             .map(modelClaimFromActive);
     }
     function listModelClaimQueue(target) {
         if (!target?.model || !target.id)
             return [];
-        return publicIntents
+        return publicClaims
             .queueFor({ type: target.model, id: target.id })
-            .filter((intent) => (target.field ? intent.target.field === target.field : true))
+            .filter((claim) => (target.field ? claim.target.field === target.field : true))
             .map(modelClaimFromQueued);
     }
-    function claimedError(target, claims, code) {
-        const label = [target.model, target.id, target.field].filter(Boolean).join('/');
-        const holder = claims[0];
-        const suffix = holder
-            ? ` held by ${holder.actor} (${holder.action})`
-            : ' held by another participant';
-        return new AbloClaimedError(`Model row is claimed: ${label || 'target'}${suffix}.`, { code, claims });
-    }
     function waitForModelUnclaimed(target, options) {
         if (listModelClaims(target).length === 0)
             return Promise.resolve();
@@ -1216,8 +1219,8 @@ export function Ablo(options) {
                 }
             };
             const onAbort = () => {
-                finish(() => reject(new AbloConnectionError('Intent wait aborted.', {
-                    code: 'intent_wait_aborted',
+                finish(() => reject(new AbloConnectionError('Claim wait aborted.', {
+                    code: 'claim_wait_aborted',
                     cause: options?.signal?.reason,
                 })));
             };
@@ -1225,7 +1228,7 @@ export function Ablo(options) {
                 onAbort();
                 return;
             }
-            unsubscribe = intentStream.onChange(check);
+            unsubscribe = claimStream.onChange(check);
             options?.signal?.addEventListener('abort', onAbort, { once: true });
             if (options?.timeout != null) {
                 timeoutId = setTimeout(() => {
@@ -1250,58 +1253,61 @@ export function Ablo(options) {
         }
         await waitForModelUnclaimed(target, { timeout: options?.claimedTimeout });
     }
-    function wrapIntentHandle(claim, waited = false) {
+    function wrapClaimHandle(claim, waited = false) {
         const release = async () => {
             claim.revoke();
         };
         return {
-            id: claim.id,
+            object: 'claim',
+            claimId: claim.claimId,
+            action: claim.action,
+            target: claim.target,
             waited,
             release,
             revoke: claim.revoke,
             [Symbol.asyncDispose]: release,
         };
     }
-    const publicIntents = Object.assign(intentStream, {
-        async create(intentOptions) {
+    const publicClaims = Object.assign(claimStream, {
+        async create(claimOptions) {
             await ready();
-            const claim = intentStream.claim({
-                type: intentOptions.target.model,
-                id: intentOptions.target.id,
-                path: intentOptions.target.path,
-                range: intentOptions.target.range,
-                field: intentOptions.target.field,
-                meta: intentOptions.target.meta,
+            const claim = claimStream.claim({
+                type: claimOptions.target.model,
+                id: claimOptions.target.id,
+                path: claimOptions.target.path,
+                range: claimOptions.target.range,
+                field: claimOptions.target.field,
+                meta: claimOptions.target.meta,
             }, {
-                reason: intentOptions.action,
-                ttl: intentOptions.ttl,
-                queue: intentOptions.queue,
+                reason: claimOptions.action,
+                ttl: claimOptions.ttl,
+                queue: claimOptions.queue,
             });
             // With `queue`, the claim is only really *ours* once the server says
-            // so (`intent_acquired` if the target was free, `intent_granted` once
+            // so (`claim_acquired` if the target was free, `claim_granted` once
             // we reach the head of the FIFO line). Block here on that grant so
             // callers — chiefly `ablo.<model>.claim` — get a handle that already
             // holds the lease, never a half-claimed one racing the queue.
             let waited = false;
-            if (intentOptions.queue) {
+            if (claimOptions.queue) {
                 const ws = store.getSyncWebSocket();
                 if (ws) {
                     try {
-                        ({ waited } = await awaitIntentGrant(ws, claim.id, {
-                            timeoutMs: intentOptions.waitTimeoutMs,
-                            maxQueueDepth: intentOptions.maxQueueDepth,
+                        ({ waited } = await awaitClaimGrant(ws, claim.claimId, {
+                            timeoutMs: claimOptions.waitTimeoutMs,
+                            maxQueueDepth: claimOptions.maxQueueDepth,
                         }));
                     }
                     catch (err) {
                         // Gave up waiting (queue too deep, timed out, or lost) — abandon
-                        // the queued intent so we don't leave a phantom entry in the
+                        // the queued claim so we don't leave a phantom entry in the
                         // line that would block or mislead other claimers.
                         claim.revoke();
                         throw err;
                     }
                 }
             }
-            return wrapIntentHandle(claim, waited);
+            return wrapClaimHandle(claim, waited);
         },
         list(target) {
             return listModelClaims(target);
@@ -1310,14 +1316,14 @@ export function Ablo(options) {
             return waitForModelUnclaimed(target, options);
         },
     });
-    // Build the typed proxy — one property per model. Done after publicIntents
+    // Build the typed proxy — one property per model. Done after publicClaims
     // exists so model clients can expose workflow helpers such as
     // `ablo.files.edit(...)` without importing protocol wiring.
     const modelProxies = {};
     for (const [schemaKey, modelDef] of Object.entries(schema.models)) {
         const registeredModelName = modelDef.typename ?? schemaKey;
         modelProxies[schemaKey] = createModelProxy(schemaKey, registeredModelName, objectPool, syncClient, modelRegistry, hydration, {
-            createIntent: (intentOptions) => publicIntents.create(intentOptions),
+            createClaim: (claimOptions) => publicClaims.create(claimOptions),
             createSnapshot: (modelKey, id) => createSnapshot({
                 pool: objectPool,
                 transport: store.getSyncWebSocket(),
@@ -1331,21 +1337,21 @@ export function Ablo(options) {
                 getLastSyncId: () => syncClient.position.readFloor,
                 entities: { [modelKey]: id },
             }),
-            queue: (target) => publicIntents.queueFor({ type: target.model, id: target.id }),
-            reorder: (target, order) => publicIntents.reorder({ type: target.model, id: target.id }, order),
+            queue: (target) => publicClaims.queueFor({ type: target.model, id: target.id }),
+            reorder: (target, order) => publicClaims.reorder({ type: target.model, id: target.id }, order),
             observe: (target) => {
-                // The live intent stream only tracks *open* (active) claims;
+                // The live claim stream only tracks *open* (active) claims;
                 // terminal states (committed / expired / canceled) drop out of
                 // the list entirely — exactly the ephemeral coordination model.
                 // So a present entry is, by definition, `status: 'active'`.
-                const held = publicIntents.list({
+                const held = publicClaims.list({
                     model: target.model,
                     id: target.id,
                 })[0];
                 if (!held)
                     return null;
                 return {
-                    object: 'intent',
+                    object: 'claim',
                     id: held.id,
                     status: 'active',
                     target: {
@@ -1362,7 +1368,7 @@ export function Ablo(options) {
                     expiresAt: held.expiresAt,
                 };
             },
-            waitFor: (target, waitOptions) => publicIntents.waitFor({ model: target.model, id: target.id }, waitOptions),
+            waitFor: (target, waitOptions) => publicClaims.waitFor({ model: target.model, id: target.id }, waitOptions),
             selfParticipantId: participantId,
         });
     }
@@ -1375,7 +1381,7 @@ export function Ablo(options) {
                 readAt: commitOptions.readAt,
                 onStale: commitOptions.onStale,
                 wait: commitOptions.wait,
-                intent: commitOptions.intent,
+                claim: commitOptions.claim,
             }, 'commits.create');
             const clientTxId = createClientTxId(commitOptions.idempotencyKey);
             // A claim handle supplies the batch stale-guard defaults — same
@@ -1388,8 +1394,8 @@ export function Ablo(options) {
                 onStale: commitOptions.onStale ?? (claim?.readAt !== undefined ? 'reject' : null),
             });
             const wait = commitOptions.wait ?? 'confirmed';
-            const intentId = normalizeIntentId(commitOptions.intent) ?? claim?.claimId;
-            void intentId; // The current wire clears intents by entity after commit.
+            const claimId = normalizeClaimId(commitOptions.claimRef) ?? claim?.claimId;
+            void claimId; // The current wire clears claims by entity after commit.
             // Route through the TransactionQueue's commit lane so the call
             // tolerates WS disconnects: the envelope stays in memory until
             // reconnect, mutationExecutor.commit() owns transport-level
@@ -1462,7 +1468,7 @@ export function Ablo(options) {
                 const id = params.id ?? createModelId();
                 await applyClaimedPolicy({ model: name, id }, params);
                 return commits.create({
-                    intent: params.intent,
+                    claimRef: params.claimRef,
                     idempotencyKey: params.idempotencyKey,
                     readAt: params.readAt,
                     onStale: params.onStale,
@@ -1481,7 +1487,7 @@ export function Ablo(options) {
             async update(params) {
                 await applyClaimedPolicy({ model: name, id: params.id }, params);
                 return commits.create({
-                    intent: params.intent,
+                    claimRef: params.claimRef,
                     idempotencyKey: params.idempotencyKey,
                     readAt: params.readAt,
                     onStale: params.onStale,
@@ -1500,7 +1506,7 @@ export function Ablo(options) {
             async delete(params) {
                 await applyClaimedPolicy({ model: name, id: params.id }, params);
                 return commits.create({
-                    intent: params.intent,
+                    claimRef: params.claimRef,
                     idempotencyKey: params.idempotencyKey,
                     readAt: params.readAt,
                     onStale: params.onStale,
@@ -1659,7 +1665,7 @@ export function Ablo(options) {
                 logger.warn('Error during sync engine disposal', { error: err.message });
             }
             presenceStream.dispose();
-            intentStream.dispose();
+            claimStream.dispose();
             syncClient.dispose();
         },
         /**
@@ -1711,8 +1717,8 @@ export function Ablo(options) {
         /** Presence livestream — same socket as entity sync, no second
          *  connection. Stable reference across the engine's lifetime. */
         presence: presenceStream,
-        /** Intent livestream — same socket. Stable reference. */
-        intents: publicIntents,
+        /** Claim livestream — same socket. Stable reference. */
+        claims: publicClaims,
         commits,
         model,
         /** Structured multiplayer participation — target-first, no