@abloatai/ablo 0.34.1 → 0.36.0

package/dist/sync/wsFrameHandlers.d.ts

@@ -1,116 +1,8 @@
 /**
- * Routes each inbound frame from the sync WebSocket to the handler for its
- * type. Handlers work against a minimal {@link WsSession} interface — only
- * the members they actually touch, rather than the transport object itself,
- * which keeps this module free of an import cycle. Reading a message off the
- * socket, parsing its JSON, and tracking heartbeats all happen before this
- * point; every parsed frame then passes through {@link dispatchWsFrame}.
+ * Moved to the settlement core with the duplex transport (ADR 0016): the
+ * inbound frame dispatch is the receiving half of the wire protocol, and the
+ * handlers already worked against the minimal `WsSession` port rather than
+ * the transport object. This path re-exports it so existing importers stay
+ * unchanged.
  */
-import { type CommitAck } from './commitFrames.js';
-/**
- * In-flight `commit` request record, keyed by clientTxId in the session.
- * Resolved when a matching `mutation_result` frame arrives from the
- * server, or rejected on timeout / disconnect.
- */
-export interface PendingCommit {
-    resolve: (value: CommitAck) => void;
-    reject: (err: Error) => void;
-    timeout: ReturnType<typeof setTimeout>;
-}
-/**
- * In-flight `claim` request record, keyed by claimId. Resolved when the
- * matching `claim_ack` arrives, or rejected on timeout/disconnect.
- */
-export interface PendingClaim {
-    resolve: (value: {
-        syncGroups: string[];
-        ttlSeconds?: number;
-    }) => void;
-    reject: (err: Error) => void;
-    timeout: ReturnType<typeof setTimeout>;
-}
-/**
- * An in-flight `update_subscription` request awaiting its
- * `subscription_ack`. The wire carries no correlation id, so requests are
- * matched to their acknowledgements in first-in, first-out order, the same
- * order the server applies them.
- */
-export interface PendingSubscription {
-    resolve: (value: {
-        syncGroups: string[];
-    }) => void;
-    reject: (err: Error) => void;
-    timeout: ReturnType<typeof setTimeout>;
-}
-/**
- * A parsed inbound wire frame, straight from `JSON.parse`. The data is
- * untrusted: every payload is loosely typed, and each handler narrows it
- * defensively before use.
- */
-export interface WsInboundFrame {
-    type?: string;
-    payload?: unknown;
-    /** Some delta frames carry their delta fields at the top level rather than under `payload`. */
-    actionType?: unknown;
-    modelName?: unknown;
-    [key: string]: unknown;
-}
-/** Narrow arbitrary wire data to a plain string-keyed record. */
-export declare function isRecord(value: unknown): value is Record<string, unknown>;
-/**
- * A type guard for the parsed result of an inbound message. A frame is any
- * plain object whose `type`, when present, is a string. Validating the
- * payload itself is left to each handler; delta payloads, for example, are
- * checked against the canonical delta schema before they are applied.
- */
-export declare function isWsInboundFrame(value: unknown): value is WsInboundFrame;
-/**
- * The subset of the sync WebSocket that the frame handlers need. The
- * transport builds a single object exposing these members over its own
- * private state. Handlers read the fields live rather than capturing them,
- * so resetting a field elsewhere — such as clearing pending subscriptions
- * on close — never leaves a handler holding a stale value.
- */
-export interface WsSession {
-    /** EventEmitter surface — handlers emit the typed transport events. */
-    emit(event: string, ...args: unknown[]): boolean;
-    /** In-flight commit acks keyed by clientTxId. */
-    pendingMutations: Map<string, PendingCommit>;
-    /** In-flight claim acks keyed by claimId. */
-    pendingClaims: Map<string, PendingClaim>;
-    /** Removes and returns the oldest in-flight `update_subscription` request. */
-    shiftPendingSubscription(): PendingSubscription | undefined;
-    /** Connection options subset the handlers write back (acked sync groups). */
-    options: {
-        syncGroups: string[];
-    };
-    /** Registered collaboration event keys (colon format). */
-    collaborationEventTypes: ReadonlySet<string>;
-    /**
-     * Processes one inbound delta. The argument is untrusted wire data; the
-     * transport validates it against the canonical delta schema and drops
-     * anything malformed, so handlers here never cast.
-     */
-    handleDelta(delta: unknown): void;
-    handleSyncResponse(payload: unknown): void;
-    handleBootstrapResponse(payload: unknown): void;
-    handlePresenceUpdate(message: {
-        payload?: unknown;
-        [k: string]: unknown;
-    }): void;
-}
-export type WsFrameHandler = (session: WsSession, message: WsInboundFrame) => void;
-/**
- * Maps each frame type to its handler. Every named server frame this
- * package understands is dispatched from this table; anything else falls
- * through to the collaboration-event and unknown-type path in
- * {@link dispatchWsFrame}.
- */
-export declare const wsFrameHandlers: Record<string, WsFrameHandler>;
-/**
- * Routes one parsed inbound frame to its handler. Keepalive frames are
- * ignored, a missing `type` is treated as a bare delta, and any unknown
- * type falls through to the collaboration-event map, whose wire names use
- * underscores and whose event keys use colons.
- */
-export declare function dispatchWsFrame(session: WsSession, message: WsInboundFrame): void;
+export { isRecord, readWsInboundFrame, wsFrameHandlers, dispatchWsFrame, type PendingCommit, type PendingClaim, type PendingSubscription, type WsInboundFrame, type WsSession, type WsFrameHandler, } from '../transaction/transport/wsFrameHandlers.js';

package/dist/sync/wsFrameHandlers.js

@@ -1,394 +1,8 @@
 /**
- * Routes each inbound frame from the sync WebSocket to the handler for its
- * type. Handlers work against a minimal {@link WsSession} interface — only
- * the members they actually touch, rather than the transport object itself,
- * which keeps this module free of an import cycle. Reading a message off the
- * socket, parsing its JSON, and tracking heartbeats all happen before this
- * point; every parsed frame then passes through {@link dispatchWsFrame}.
+ * Moved to the settlement core with the duplex transport (ADR 0016): the
+ * inbound frame dispatch is the receiving half of the wire protocol, and the
+ * handlers already worked against the minimal `WsSession` port rather than
+ * the transport object. This path re-exports it so existing importers stay
+ * unchanged.
  */
-import { getContext } from '../context.js';
-import { AbloConnectionError, CapabilityError, errorFromWire, } from '../errors.js';
-import { commitAckSchema, legacyCompatibleCommitReceiptSchema, } from '../wire/commit.js';
-import { subscriptionAckPayloadSchema } from '../coordination/schema.js';
-import { formatConflict } from '../coordination/trace.js';
-import { parseNotifications, recordClaim } from './commitFrames.js';
-/** Narrow arbitrary wire data to a plain string-keyed record. */
-export function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-/**
- * A type guard for the parsed result of an inbound message. A frame is any
- * plain object whose `type`, when present, is a string. Validating the
- * payload itself is left to each handler; delta payloads, for example, are
- * checked against the canonical delta schema before they are applied.
- */
-export function isWsInboundFrame(value) {
-    if (!isRecord(value))
-        return false;
-    const type = value.type;
-    return type === undefined || typeof type === 'string';
-}
-/**
- * Handles the acknowledgement of a `commit` request. The canonical wire
- * shape is `MutationResultMessage`. The payload is parsed defensively
- * rather than cast, since it is untrusted and may be malformed or sent by
- * an older server.
- */
-const handleMutationResult = (session, message) => {
-    const p = (message.payload ?? message);
-    const { clientTxId, success, error } = p;
-    // Defensive: validate notifications against the canonical schema —
-    // untrusted wire data from a possibly-older/newer server.
-    const notifications = parseNotifications(p?.notifications);
-    const missingIds = Array.isArray(p.missingIds)
-        ? [
-            ...new Set(p.missingIds.filter((id) => typeof id === 'string' && id.length > 0)),
-        ]
-        : undefined;
-    const pending = typeof clientTxId === 'string'
-        ? session.pendingMutations.get(clientTxId)
-        : undefined;
-    if (!pending)
-        return;
-    clearTimeout(pending.timeout);
-    // `pending` exists ⇒ clientTxId was a string key (the guard above).
-    session.pendingMutations.delete(clientTxId);
-    if (success) {
-        const parsedReceipt = legacyCompatibleCommitReceiptSchema.safeParse({
-            ...p,
-            notifications,
-            missingIds,
-        });
-        if (!parsedReceipt.success) {
-            pending.reject(new AbloConnectionError('The sync server returned an invalid commit receipt; its outcome remains pending and is safe to retry.', { code: 'commit_no_result', cause: parsedReceipt.error }));
-            return;
-        }
-        const receipt = parsedReceipt.data;
-        // The write succeeded, but a guarded premise shifted underneath it.
-        // Emit the advisory signal so a caller can react, and still resolve
-        // the receipt, since the commit itself went through.
-        if (receipt.notifications && receipt.notifications.length > 0) {
-            const txId = receipt.clientTxId;
-            const event = {
-                clientTxId: txId,
-                rows: receipt.notifications.map((n) => ({
-                    model: n.model,
-                    id: n.id,
-                    fields: n.conflictingFields,
-                    writtenBy: n.writtenBy.kind,
-                })),
-            };
-            const message = formatConflict(event);
-            const ctx = getContext();
-            ctx.logger.warn(message);
-            ctx.observability.breadcrumb(message, 'sync.coordination', 'warning');
-            ctx.observability.captureConflict(event);
-            session.emit('conflict:notified', {
-                clientTxId: txId,
-                notifications: receipt.notifications,
-            });
-        }
-        pending.resolve(commitAckSchema.parse({
-            status: receipt.status,
-            ...(receipt.correlationId
-                ? { correlationId: receipt.correlationId }
-                : {}),
-            lastSyncId: receipt.lastSyncId,
-            ...(receipt.notifications && receipt.notifications.length > 0
-                ? { notifications: receipt.notifications }
-                : {}),
-            ...(receipt.missingIds && receipt.missingIds.length > 0
-                ? { missingIds: receipt.missingIds }
-                : {}),
-        }));
-    }
-    else {
-        // Capture the full server error so the caller can see what actually
-        // rejected the mutation, rather than a generic "mutation failed on
-        // server". Object errors are stringified so structured server payloads,
-        // such as validation issues, survive being wrapped in an Error.
-        let errorMessage;
-        let errorCode;
-        let requiredCapability;
-        if (typeof error === 'string') {
-            errorMessage = error;
-        }
-        else if (error != null && typeof error === 'object') {
-            const obj = error;
-            if (typeof obj.code === 'string')
-                errorCode = obj.code;
-            if (typeof obj.message === 'string') {
-                errorMessage = obj.message;
-            }
-            else {
-                try {
-                    errorMessage = JSON.stringify(error);
-                }
-                catch {
-                    errorMessage = String(error);
-                }
-            }
-            if (obj.requiredCapability != null &&
-                typeof obj.requiredCapability === 'object' &&
-                typeof obj.requiredCapability.scope === 'string') {
-                requiredCapability = obj.requiredCapability;
-            }
-        }
-        else {
-            errorMessage = 'mutation failed on server';
-        }
-        // A stale-context rejection (the write read state that has since
-        // changed) or a foreign-claim conflict is a coordination collision.
-        // The success-with-notifications path above records the conflict, and a
-        // hard rejection must record it too, or the collision count would miss
-        // every rejected write. The conflicting rows ride along on the typed
-        // error's `conflicts` detail.
-        if (errorCode === 'stale_context' ||
-            errorCode === 'claim_conflict' ||
-            errorCode === 'entity_claimed' ||
-            errorCode?.startsWith('policy:') === true) {
-            const rawConflicts = error != null &&
-                typeof error === 'object' &&
-                Array.isArray(error.conflicts)
-                ? error
-                    .conflicts
-                : [];
-            const conflictEvent = {
-                clientTxId: typeof clientTxId === 'string' ? clientTxId : '',
-                rows: rawConflicts.map((r) => ({
-                    model: typeof r.model === 'string' ? r.model : 'unknown',
-                    id: typeof r.id === 'string' ? r.id : 'unknown',
-                    fields: [],
-                })),
-            };
-            const ctx = getContext();
-            ctx.observability.breadcrumb(formatConflict(conflictEvent), 'sync.coordination', 'warning');
-            ctx.observability.captureConflict(conflictEvent);
-        }
-        // Build the proper typed AbloError from the wire code via the
-        // shared factory — the same code→class mapping the HTTP commit
-        // path uses (`translateHttpError`). This keeps rejected commits
-        // inside the typed hierarchy (capability denials →
-        // CapabilityError with `.requiredCapability`; foreign-claim
-        // conflicts → AbloClaimedError; everything else → the subclass
-        // its registry `httpStatus` implies) instead of a hand-rolled
-        // `new Error`, so callers can `instanceof`/`e.type` it and
-        // downstream retry logic can read the contract's retryability.
-        pending.reject(errorFromWire(errorMessage, {
-            code: errorCode,
-            requiredCapability,
-        }));
-    }
-};
-/**
- * Handles the acknowledgement of a `claim` request. The frame has the shape
- * `{ type: 'claim_ack', payload: { claimId, success, syncGroups?,
- * ttlSeconds?, error? } }`.
- */
-const handleClaimAck = (session, message) => {
-    const p = (message.payload ?? {});
-    const { claimId, success, syncGroups, ttlSeconds, error } = p;
-    const pending = typeof claimId === 'string'
-        ? session.pendingClaims.get(claimId)
-        : undefined;
-    if (!pending)
-        return;
-    clearTimeout(pending.timeout);
-    // `pending` exists ⇒ claimId was a string key (the guard above).
-    session.pendingClaims.delete(claimId);
-    if (success) {
-        pending.resolve({
-            syncGroups: Array.isArray(syncGroups) ? syncGroups : [],
-            ttlSeconds: typeof ttlSeconds === 'number' ? ttlSeconds : undefined,
-        });
-    }
-    else {
-        const err = error;
-        const code = err?.code && typeof err.code === 'string'
-            ? err.code
-            : 'claim_rejected';
-        const msg = err?.message && typeof err.message === 'string'
-            ? err.message
-            : 'claim rejected by server';
-        // Capability denials get the typed CapabilityError so
-        // callers can read `.requiredCapability` and attenuate-
-        // and-retry the claim with a narrower token.
-        if (code === 'capability_scope_denied' ||
-            code === 'capability_invalid') {
-            const rc = error
-                ?.requiredCapability;
-            const requiredCapability = rc != null &&
-                typeof rc === 'object' &&
-                typeof rc.scope === 'string'
-                ? rc
-                : undefined;
-            pending.reject(new CapabilityError(code, msg, requiredCapability));
-        }
-        else {
-            // Route through the shared factory so a failed claim_ack is a
-            // typed AbloError (registry code → right subclass), symmetric
-            // with the commit `mutation_result` path — never a bare Error.
-            pending.reject(errorFromWire(msg, { code }));
-        }
-    }
-};
-/**
- * Handles the acknowledgement of an `update_subscription` request. The wire
- * carries no correlation id, so the ack is matched to the oldest pending
- * request in first-in, first-out order, since the server applies and
- * acknowledges subscription updates in the order it receives them. The
- * payload is validated against its canonical schema before use.
- */
-const handleSubscriptionAck = (session, message) => {
-    const pending = session.shiftPendingSubscription();
-    if (!pending)
-        return;
-    clearTimeout(pending.timeout);
-    const parsed = subscriptionAckPayloadSchema.safeParse(message.payload);
-    if (!parsed.success) {
-        // Unreadable ack — resolve the pending request as a failure
-        // rather than hang it until timeout.
-        pending.reject(errorFromWire('malformed subscription_ack from server', {
-            code: 'malformed_subscription',
-        }));
-        return;
-    }
-    const ack = parsed.data;
-    if (ack.success) {
-        // Keep the reconnect URL aligned with current interest: a
-        // reconnect re-subscribes from `this.options.syncGroups`.
-        session.options.syncGroups = ack.syncGroups;
-        pending.resolve({ syncGroups: ack.syncGroups });
-    }
-    else {
-        pending.reject(errorFromWire(ack.error?.message ?? 'update_subscription rejected by server', { code: ack.error?.code ?? 'malformed_subscription' }));
-    }
-};
-/**
- * Handles a `delta` frame, which carries either a single delta or a
- * `{ deltas: [...] }` batch. This only tells the two shapes apart; each
- * delta is validated once downstream, so batch elements are passed along
- * raw rather than parsed here.
- */
-const handleDeltaFrame = (session, message) => {
-    const p = message.payload;
-    if (!isRecord(p))
-        return;
-    if (p.actionType || p.modelName) {
-        session.handleDelta(p);
-    }
-    else if (Array.isArray(p.deltas)) {
-        for (const d of p.deltas) {
-            session.handleDelta(d);
-        }
-        // `p.newVersions` from older servers is ignored; `sync_id` is the
-        // causality token.
-    }
-};
-/**
- * Maps each frame type to its handler. Every named server frame this
- * package understands is dispatched from this table; anything else falls
- * through to the collaboration-event and unknown-type path in
- * {@link dispatchWsFrame}.
- */
-export const wsFrameHandlers = {
-    sync_response: (session, message) => { session.handleSyncResponse(message.payload); },
-    bootstrap_response: (session, message) => { session.handleBootstrapResponse(message.payload); },
-    presence_update: (session, message) => { session.handlePresenceUpdate(message); },
-    mutation_result: handleMutationResult,
-    claim_ack: handleClaimAck,
-    subscription_ack: handleSubscriptionAck,
-    claim_expired: (session, message) => {
-        // Server-initiated expiry notification. Emit as a typed
-        // event so consumers can react (re-claim with a fresh
-        // capability, or accept the drop). The claim is already
-        // inactive server-side by the time this arrives.
-        const p = (message.payload ?? {});
-        if (typeof p.claimId === 'string') {
-            recordClaim('expired', p);
-            session.emit('claim_expired', { claimId: p.claimId });
-        }
-    },
-    claim_rejected: (session, message) => {
-        // The server denied a claim because the target is already held by
-        // another participant. The payload is forwarded as-is for the claim
-        // stream consumer to interpret (peerId, target, and so on).
-        recordClaim('rejected', (message.payload ?? {}));
-        session.emit('claim_rejected', message.payload ?? {});
-    },
-    claim_acquired: (session, message) => {
-        // Opt-in fair queue: the target was free, so the lease is ours
-        // immediately (no waiting). Payload carries { claimId, target }.
-        recordClaim('acquired', (message.payload ?? {}));
-        session.emit('claim_acquired', message.payload ?? {});
-    },
-    claim_queue: (session, message) => {
-        // Per-entity wait-queue snapshot for reactive `queue(id)`. Not a
-        // single claim's state change, so it isn't logged — the per-claim
-        // `queued`/`granted` events already tell that story.
-        session.emit('claim_queue', message.payload ?? {});
-    },
-    claim_queued: (session, message) => {
-        // Opt-in fair queue: our claim is waiting in line. Payload
-        // carries { claimId, target, position }.
-        recordClaim('queued', (message.payload ?? {}));
-        session.emit('claim_queued', message.payload ?? {});
-    },
-    claim_granted: (session, message) => {
-        // Our queued claim reached the head — the lease is now ours.
-        recordClaim('granted', (message.payload ?? {}));
-        session.emit('claim_granted', message.payload ?? {});
-    },
-    claim_lost: (session, message) => {
-        // A held/granted claim was taken from us (TTL lapse, revoke).
-        recordClaim('lost', (message.payload ?? {}));
-        session.emit('claim_lost', message.payload ?? {});
-    },
-    claim_heartbeat_ack: (session, message) => {
-        // Reply to our `claim_heartbeat` — the claim stream correlates it back
-        // to the awaiting caller by claimId. Not logged per-frame: heartbeats
-        // are a cadence, and the interesting transitions (lost) surface through
-        // the caller's error path.
-        session.emit('claim_heartbeat_ack', message.payload ?? {});
-    },
-    delta: handleDeltaFrame,
-};
-/**
- * Routes one parsed inbound frame to its handler. Keepalive frames are
- * ignored, a missing `type` is treated as a bare delta, and any unknown
- * type falls through to the collaboration-event map, whose wire names use
- * underscores and whose event keys use colons.
- */
-export function dispatchWsFrame(session, message) {
-    if (message.type === 'pong' || message.type === 'ping') {
-        // Ignore keepalive messages
-        getContext().logger.debug('Received keepalive', { type: message.type });
-        return;
-    }
-    if (message.type === undefined) {
-        // A bare delta, validated downstream like every other delta.
-        if (message.actionType || message.modelName) {
-            session.handleDelta(message);
-        }
-        return;
-    }
-    // Look up own properties only, so a wire type like 'toString' can't match
-    // an inherited Object.prototype member; such types fall through to the
-    // unknown-type path.
-    const handler = Object.prototype.hasOwnProperty.call(wsFrameHandlers, message.type)
-        ? wsFrameHandlers[message.type]
-        : undefined;
-    if (handler) {
-        handler(session, message);
-        return;
-    }
-    // Collaboration events use underscore wire format (e.g., 'sheet_selection')
-    // Convert to colon format for the event map (e.g., 'sheet:selection')
-    const eventKey = message.type?.replace(/_/g, ':');
-    if (eventKey && session.collaborationEventTypes.has(eventKey)) {
-        session.emit(eventKey, message.payload);
-    }
-    else {
-        getContext().logger.debug('Received unknown message type', { message });
-    }
-}
+export { isRecord, readWsInboundFrame, wsFrameHandlers, dispatchWsFrame, } from '../transaction/transport/wsFrameHandlers.js';

package/dist/syncLog/contract.d.ts

@@ -0,0 +1,20 @@
+/** Canonical sync-log identity and position contracts shared by client/server. */
+import { z } from 'zod';
+export declare const deltaPositionSchema: z.ZodNumber;
+export type DeltaPosition = z.infer<typeof deltaPositionSchema>;
+export declare const clientMutationIdSchema: z.ZodString;
+export type ClientMutationId = z.infer<typeof clientMutationIdSchema>;
+export declare const sourceCorrelationIdSchema: z.ZodString;
+export type SourceCorrelationId = z.infer<typeof sourceCorrelationIdSchema>;
+export declare const sourceChangeIdSchema: z.ZodString;
+export type SourceChangeId = z.infer<typeof sourceChangeIdSchema>;
+export declare const replicationLsnSchema: z.ZodString;
+export type ReplicationLSN = z.infer<typeof replicationLsnSchema>;
+export declare const commitDispatchMarkerSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"sync_deltas">;
+    organizationId: z.ZodString;
+    environment: z.ZodString;
+    firstSyncId: z.ZodNumber;
+    lastSyncId: z.ZodNumber;
+}, z.core.$strict>;
+export type CommitDispatchMarker = z.infer<typeof commitDispatchMarkerSchema>;

package/dist/syncLog/contract.js

@@ -0,0 +1,19 @@
+/** Canonical sync-log identity and position contracts shared by client/server. */
+import { z } from 'zod';
+import { environmentSchema } from '../environment.js';
+export const deltaPositionSchema = z.number().int().nonnegative().safe();
+export const clientMutationIdSchema = z.string().min(1).max(255);
+export const sourceCorrelationIdSchema = z.string().min(1).max(255);
+export const sourceChangeIdSchema = z.string().min(1).max(512);
+export const replicationLsnSchema = z.string().regex(/^[0-9A-Fa-f]+\/[0-9A-Fa-f]+$/);
+export const commitDispatchMarkerSchema = z.strictObject({
+    kind: z.literal('sync_deltas'),
+    organizationId: z.string().min(1),
+    environment: environmentSchema,
+    firstSyncId: deltaPositionSchema,
+    lastSyncId: deltaPositionSchema,
+}).superRefine((value, ctx) => {
+    if (value.firstSyncId <= 0 || value.lastSyncId < value.firstSyncId) {
+        ctx.addIssue({ code: 'custom', message: 'invalid delta position range' });
+    }
+});

package/dist/syncLog/index.d.ts

@@ -0,0 +1 @@
+export * from './contract.js';

package/dist/syncLog/index.js

@@ -0,0 +1 @@
+export * from './contract.js';

package/dist/transaction/ablo.d.ts

@@ -0,0 +1,88 @@
+/**
+ * `Ablo` — the entry point to the coordination layer.
+ *
+ * The factory constructs the stateless client: typed model resources, commits,
+ * claims, and session minting over request/response HTTP. It holds no socket,
+ * no store, and no local copy of anything — the bearer credential is the
+ * identity and the server resolves it on every request. This is the client a
+ * server-side actor installs: an agent, a worker, a cron job, a route handler.
+ *
+ * ```ts
+ * import { Ablo } from '@abloatai/ablo';
+ * import { schema } from './schema';
+ *
+ * const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY, transport: 'http' });
+ * await ablo.tasks.update({ id: taskId, data: { status: 'done' } });
+ * ```
+ *
+ * The reactive materialiser — local store, live queries, presence rendering —
+ * is the consumer package's entry point (`@abloatai/ablo`), which layers
+ * above this one and shares the same `ablo.<model>` surface (ADR 0016).
+ */
+import { type AbloHttpClient, type AbloHttpClientOptions } from './transport/httpClient.js';
+import type { SchemaRecord } from './schema/schema.js';
+import type * as _Streams from './types/streams.js';
+import type * as _SchemaTypes from './schema/schema.js';
+import type * as _Global from './types/global.js';
+import type * as _Policy from './policy/types.js';
+import type * as _Http from './resources/httpResources.js';
+/**
+ * Create a coordination-layer client in one call.
+ *
+ * The core carries one transport today — request/response HTTP — so
+ * `transport: 'http'` is accepted for symmetry with the reactive package's
+ * factory and may be omitted. The duplex transport joins this slot when the
+ * socket carve lands (ADR 0016, follow-up 3a).
+ */
+export declare function Ablo<const S extends SchemaRecord>(options: AbloHttpClientOptions<S> & {
+    transport?: 'http';
+}): AbloHttpClient<S>;
+export declare namespace Ablo {
+    type ClaimTarget = _Streams.ClaimTarget;
+    type PresenceTarget = _Streams.PresenceTarget;
+    type Duration = _Streams.Duration;
+    type Peer = _Streams.Peer;
+    type Activity = _Streams.Activity;
+    type Claim = _Streams.Claim;
+    type ClaimHeartbeat = _Streams.ClaimHeartbeat;
+    type ClaimHeartbeatOptions = _Streams.ClaimHeartbeatOptions;
+    namespace Claim {
+        type Held<T = Record<string, unknown>, M = _Global.ResolveClaimMeta> = _Streams.HeldClaim<T, M>;
+        type WaitOptions = _Streams.ClaimWaitOptions;
+        type LeaseOptions = _Streams.ClaimLeaseOptions;
+    }
+    type Schema<S extends _SchemaTypes.SchemaRecord = _SchemaTypes.SchemaRecord> = _SchemaTypes.Schema<S>;
+    /**
+     * The schema this program has registered via `interface Register { Schema }`
+     * (falls back to a loose shape when unregistered). Use it where shared code
+     * needs "this app's schema" without importing a specific one.
+     */
+    type ResolveSchema = _Global.ResolveSchema;
+    /**
+     * The claim metadata shape this program has registered via
+     * `interface Register { ClaimMeta }` (falls back to a loose record when
+     * unregistered). Every claim surface reads `target.meta` as this.
+     */
+    type ResolveClaimMeta = _Global.ResolveClaimMeta;
+    namespace Schema {
+        type Model<S extends _SchemaTypes.Schema, K extends keyof S['models']> = _SchemaTypes.Model<S, K>;
+        type InferCreate<S extends _SchemaTypes.Schema, K extends keyof S['models']> = _SchemaTypes.InferCreate<S, K>;
+        type InferModelNames<S extends _SchemaTypes.Schema> = _SchemaTypes.InferModelNames<S>;
+    }
+    type Conflict = _Policy.Conflict;
+    namespace Conflict {
+        type Kind = _Policy.ConflictKind;
+        type Operation = _Policy.ConflictOperation;
+        type Decision = _Policy.ConflictDecision;
+        type Policy = _Policy.ConflictPolicy;
+        type Axis = _Policy.ConflictAxis;
+    }
+    namespace Commit {
+        type Wait = _Http.CommitWait;
+        type OperationAction = _Http.ModelOperationAction;
+        type OperationInput = _Http.CommitOperationInput;
+        type CreateOptions = _Http.CommitCreateOptions;
+        type Receipt = _Http.CommitReceipt;
+        type Client = _Http.CommitResource;
+    }
+}