@abloatai/ablo 0.10.1 → 0.11.1

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;