@abloatai/transaction 0.57.0 → 0.59.0

package/src/transport/{httpTransport.ts → http/transport.ts}

@@ -16,13 +16,13 @@ import {
   AbloNotFoundError,
   claimedError,
   translateHttpError,
-} from '../errors.js';
+} from '../../errors.js';
 import { z } from 'zod';
 import {
   reconcileFunctionalUpdate,
   type ModelUpdater,
   type FunctionalUpdateOptions,
-} from '../resources/functionalUpdate.js';
+} from '../../client/resources/functionalUpdate.js';
 import {
   assertBrowserSafety,
   readProcessEnv,
@@ -33,41 +33,42 @@ import {
   resolveBootstrapBaseUrl,
   rejectRemovedDatabaseUrlOption,
   warnIfCliKeyMismatch,
-} from '../auth/apiKey.js';
-import { PROTOCOL_VERSION, PROTOCOL_VERSION_HEADER } from '../wire/protocolVersion.js';
+} from '../../auth/apiKey.js';
+import { PROTOCOL_VERSION, PROTOCOL_VERSION_HEADER } from '../../wire/protocolVersion.js';
 import {
   commitRecordSchema,
   commitRecordListSchema,
   commitRecordListOptionsSchema,
   commitRecordWhereSchema,
   type CommitReceiptWire,
-} from '../wire/commit.js';
-import { logListResponseSchema } from '../wire/feedEvent.js';
+} from '../../commit/contract.js';
+import { logListResponseSchema } from '../../observation/feedContract.js';
 import {
   claimAcquireResponseSchema,
   claimHeartbeatBatchReplySchema,
   claimHeartbeatReplySchema,
   claimListResponseSchema,
   claimStateSchema,
+  DEFAULT_CLAIM_TTL_MS,
   type ClaimHeartbeatReply,
   type ClaimListResponse,
   type ClaimQueuedResponse,
   type ClaimRequest,
   type ClaimState,
   type ClaimTargetBody,
-} from '../wire/claims.js';
+} from '../../claims/contract.js';
 import {
   modelListResponseSchema,
   modelReadResponseSchema,
-} from '../wire/modelResponses.js';
-import { toMs } from '../utils/duration.js';
+} from '../../wire/modelResponses.js';
+import { toMs } from '../../utils/duration.js';
 import {
   heartbeatCadenceMs,
   resolveHeartbeatOptions,
   resolveHeartbeatPlan,
   startClaimHeartbeatLoop,
-} from '../coordination/claimHeartbeatLoop.js';
-import type { HttpClientConfig } from './httpOptions.js';
+} from '../../claims/heartbeat.js';
+import type { HttpClientConfig } from './options.js';
 import type {
   ClaimedOptions,
   CommitCreateOptions,
@@ -79,7 +80,7 @@ import type {
   HttpClaimsResource,
   HttpTransportModel,
   ModelClaim,
-  ModelMutationOptions,
+  InternalModelMutationOptions as ModelMutationOptions,
   ModelReadOptions,
   HttpTransportRead,
   HttpTransportList,
@@ -88,64 +89,68 @@ import type {
   CreateSessionParams,
   AbloSession,
   SessionResource,
-} from '../resources/httpResources.js';
-import { mintSession } from '../auth/sessionMint.js';
+} from '../../client/resources/httpResources.js';
+import { mintSession } from '../../auth/sessionMint.js';
 import {
   revokeCapability,
   rotateCapability,
-} from '../auth/capabilityLifecycle.js';
-import { parseIdentityResolveResponse } from '../auth/schemas.js';
-import type { EffectiveAuthority } from '../auth/capability.js';
+} from '../../auth/capabilityLifecycle.js';
+import { parseIdentityResolveResponse } from '../../auth/schemas.js';
+import type { EffectiveAuthority } from '../../auth/capability.js';
 
 import {
   claimFromModelClaim,
   heldHeartbeatReply,
   parseSuccessfulCommitResponse,
-} from './httpTransportHelpers.js';
-import type { SchemaRecord } from '../schema/schema.js';
+} from './helpers.js';
+import type { SchemaRecord } from '../../schema/schema.js';
 import type {
   ClaimLookupParams,
   ClaimOptions,
   ClaimParams,
   ClaimSkipParams,
+  ClaimSkipOptions,
   ClaimReorderParams,
-  ModelTrackParams,
-  ModelTrackResult,
   ModelCreateManyParams,
   ServerReadOptions,
   ResolvedClaimContentionOptions,
   ClaimQueueView,
-} from '../resources/modelOperations.js';
+} from '../../client/resources/modelOperations.js';
 import {
   claimAttemptFailure,
   claimQueueView,
   emitClaimStatus,
   resolveClaimContentionOptions,
-} from '../resources/modelOperations.js';
-import type { Duration } from '../utils/duration.js';
-import type { TrackDependency } from '../coordination/schema.js';
-import { claimDescription, partName } from '../coordination/schema.js';
-import type { BatchFence } from '../coordination/locator.js';
+} from '../../client/resources/modelOperations.js';
+import type { Duration } from '../../utils/duration.js';
+import { claimDescription, partName } from '../../coordination/schema.js';
+import type { BatchFence } from '../../claims/locator.js';
 import {
   subTarget,
   streamTarget,
   batchFence,
   claimIdFor,
   fenceTokenFor,
-} from '../coordination/locator.js';
-import { declaredMeta, wireMeta } from '../coordination/claimMeta.js';
-import type { Claim, ClaimHeartbeat, ClaimHeartbeatOptions, HeldClaim } from '../types/streams.js';
-import type { CoordinationObservability } from '../observability.js';
+} from '../../claims/locator.js';
+import { declaredMeta, wireMeta } from '../../claims/meta.js';
+import type {
+  Claim,
+  ClaimHeartbeat,
+  ClaimHeartbeatOptions,
+  HeldClaim,
+  HeldLease,
+} from '../../types/streams.js';
+import type { CoordinationObservability } from '../../observability.js';
 import {
   assertWriteOptions,
   assertWriteTarget,
-} from '../resources/writeOptionsSchema.js';
+} from '../../client/resources/writeOptionsSchema.js';
 import {
   createModelId,
   resolveCreatedRows,
   resolveCreateId,
-} from '../resources/modelCreate.js';
-import { normalizeWhere } from '../resources/where.js';
+} from '../../client/resources/modelCreate.js';
+import { normalizeWhere } from '../../client/resources/where.js';
 import {
   createDurableHttpCommitEnvelope,
   canonicalHttpCommitBody,
@@ -154,15 +159,16 @@ import {
   isHttpCommitReplayExpired,
   type DurableHttpCommitEnvelope,
   type DurableHttpCommitMethod,
-} from '../transactions/confirmation/httpCommitEnvelope.js';
-import type { CommitOutboxScope } from '../transactions/confirmation/commitEnvelope.js';
+} from '../../commit/confirmation/httpCommitEnvelope.js';
+import type { CommitOutboxScope } from '../../commit/confirmation/commitEnvelope.js';
 import {
   createClientTxId,
   normalizeCommitOperations,
   replicationLagTimeout,
   type ExactHttpCommitRequest,
-} from './httpCommitRequest.js';
-import { resolveDurableWrites } from '../durableWrites.js';
+} from '../../commit/httpRequest.js';
+import { resolveDurableWrites } from '../../commit/durableWrites.js';
+import { createHttpReadOnChange, type HttpReadOnChange } from './subscription.js';
 
 /** @internal Private options for the schema-agnostic HTTP protocol transport. */
 export type HttpTransportOptions = Omit<HttpClientConfig, 'schema'> & {
@@ -190,12 +196,6 @@ export type HttpTransportOptions = Omit<HttpClientConfig, 'schema'> & {
 /** @internal Default per-request deadline for the private HTTP transport. */
 export const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
 const HTTP_CONFIRMATION_POLL_INTERVAL_MS = 250;
-/**
- * The server's acquire window, mirrored here as the client-side default for a
- * claim that names no `ttl` — it sets the auto-heartbeat cadence.
- */
-const DEFAULT_CLAIM_TTL_MS = 60_000;
-
 // NOTE: end-user / agent session minting is `ablo.sessions.create(...)` (typed
 // against the schema, see Ablo.ts `CreateSessionParams`). There is no separate
 // `ephemeralKeys` resource — `sessions` is the one front door for both.
@@ -207,6 +207,8 @@ export interface HttpTransport {
   /** Drains scheduled commits and active requests. */
   dispose(): Promise<void>;
   purge(): Promise<void>;
+  /** @internal Live check used only by `context().onChange`. */
+  readonly onChange: HttpReadOnChange;
   readonly commits: CommitResource;
   /**
    * Claim-ticket operations keyed by `claimId` — the id a queued acquire
@@ -279,8 +281,7 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
     const isConflict =
       code === 'stale_context' ||
       code === 'claim_conflict' ||
-      code === 'entity_claimed' ||
-      (typeof code === 'string' && code.startsWith('policy:'));
+      code === 'entity_claimed';
     if (!isConflict) return;
     const rawConflicts = errorRecord?.conflicts;
     const rows =
@@ -326,6 +327,7 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
   let activeRequests = 0;
   let requestIdleWaiters: Array<() => void> = [];
   let disposePromise: Promise<void> | null = null;
+  const readChangeControllers = new Set<AbortController>();
 
   function requestStarted(): void {
     activeRequests += 1;
@@ -447,7 +449,24 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
     return target.toString();
   }
 
+  function subscriptionEndpoint(): string {
+    const target = new URL(endpoint('/v1/subscriptions'));
+    const partition = effectiveAuthority?.deliveryPartition;
+    if (partition) {
+      target.searchParams.set('deliveryPartition', `${partition.index}-${partition.count}`);
+    }
+    return target.toString();
+  }
+
   const requestTimeoutMs = options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  const onChange = createHttpReadOnChange({
+    fetch: fetchImpl,
+    endpoint: subscriptionEndpoint,
+    authHeaders,
+    prepare: ready,
+    register: (controller) => readChangeControllers.add(controller),
+    unregister: (controller) => readChangeControllers.delete(controller),
+  });
 
   /**
    * Issues one request and returns its decoded body without a contract.
@@ -1255,11 +1274,9 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
         {
           idempotencyKey: commitOptions.idempotencyKey,
           readAt: commitOptions.readAt,
-          onStale: commitOptions.onStale,
           wait: commitOptions.wait,
           claim: commitOptions.claim,
           reads: commitOptions.reads,
-          track: commitOptions.track,
         },
         'commits.create'
       );
@@ -1271,14 +1288,12 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
         {
           ...commitOptions,
           readAt: commitOptions.readAt ?? claim?.readAt ?? null,
-          onStale: commitOptions.onStale ?? (claim?.readAt !== undefined ? 'reject' : null),
         },
         batchFence(claim?.target, claim?.fenceToken)
       );
       const requestBody = {
         operations,
         reads: commitOptions.reads,
-        track: commitOptions.track,
       };
       const wait = commitOptions.wait ?? 'confirmed';
       let body: CommitResponse;
@@ -1314,9 +1329,6 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
         id: body.id ?? body.clientTxId,
         status: body.status,
         lastSyncId: body.lastSyncId,
-        ...(body.notifications && body.notifications.length > 0
-          ? { notifications: body.notifications }
-          : {}),
         ...(body.missingIds && body.missingIds.length > 0 ? { missingIds: body.missingIds } : {}),
         ...(body.operationResults && body.operationResults.length > 0
           ? { operationResults: body.operationResults }
@@ -1430,7 +1442,7 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
     };
   }
 
-  async function retrieveModel<T>(
+  async function readModel<T>(
     modelName: string,
     params: ModelReadOptions & { readonly id: string }
   ): Promise<HttpTransportRead<T>> {
@@ -1443,7 +1455,7 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
     );
 
     // A miss is `data: undefined`, not a thrown error. The WebSocket client's
-    // `retrieve` returns `T | undefined` for a missing row; throwing only here
+    // `read` returns `T | undefined` for a missing row; throwing only here
     // made the obvious read ("does this row exist?") a hard edge that an agent
     // had to wrap in try/catch. Both transports agree: an absent row means absent
     // data. Callers branch on `.data` (the documented `.data?.x` usage).
@@ -1479,12 +1491,10 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
       options && {
         idempotencyKey: options.idempotencyKey,
         readAt: options.readAt,
-        onStale: options.onStale,
         claim: options.claim,
         claimRef: options.claimRef,
         fenceToken: options.fenceToken,
         reads: options.reads,
-        track: options.track,
       },
       `${modelName} ${action}`
     );
@@ -1510,10 +1520,8 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
     const readAt = options?.readAt ?? claimHandle?.readAt;
     const requestBody: Record<string, unknown> = {
       claim: normalizeClaimId(options?.claimRef) ?? claimHandle?.id,
-      onStale: options?.onStale ?? (claimHandle?.readAt !== undefined ? 'reject' : undefined),
       readAt,
       reads: options?.reads,
-      track: options?.track,
       // The claim's fencing token (Option B), so the per-model HTTP write door
       // fences the same as the WS proxy and `commits.create`.
       fenceToken: options?.fenceToken ?? claimHandle?.fenceToken,
@@ -1680,9 +1688,23 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
       params: ClaimSkipParams<Fields>
     ): Promise<HeldClaim<T> | null>;
     function claimImpl(params: ClaimParams<Fields>): Promise<HeldClaim<T>>;
+    function claimImpl(
+      id: string,
+      opts: ClaimSkipOptions<Fields>
+    ): Promise<HeldLease | null>;
+    function claimImpl(id: string, opts?: ClaimOptions<Fields>): Promise<HeldLease>;
     async function claimImpl(
-      params: ClaimParams<Fields>,
-    ): Promise<HeldClaim<T> | null> {
+      idOrParams: string | ClaimParams<Fields>,
+      opts?: ClaimOptions<Fields>,
+    ): Promise<HeldClaim<T> | HeldLease | null> {
+      // The row-free form names a key by id alone. Ablo has never held that
+      // row, so there is no snapshot to take after the grant and no `data` on
+      // the handle: the lease is the whole answer. The object form re-reads
+      // the row under the lease and hands back a `HeldClaim`.
+      const rowFree = typeof idOrParams === 'string';
+      const params: ClaimParams<Fields> = rowFree
+        ? { ...(opts ?? {}), id: idOrParams }
+        : idOrParams;
       let acquired: { id: string; fenceToken?: number };
       try {
         acquired = await acquireClaim(params);
@@ -1709,16 +1731,6 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
         id: params.id,
         description: claimDescription(params),
       });
-      const { data, stamp } = await retrieveModel<T>(name, { id: params.id });
-      // A held claim hands back a snapshot; the typed `HeldClaim.data` is `T`.
-      // `retrieve` now reports a miss as `undefined` rather than throwing, but a
-      // claim on a row that doesn't exist has nothing to hold — surface it.
-      if (data === undefined) {
-        throw new AbloNotFoundError(
-          `Cannot claim ${name}/${params.id}: it does not exist (or is outside this credential's scope).`,
-          [params.id]
-        );
-      }
       // One reading of the heartbeat options — cadence and callbacks from
       // whichever spelling the caller used (plan object, shorthand, or the
       // deprecated flat callbacks).
@@ -1758,10 +1770,9 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
       // way. `subTarget` is wire-shaped by contract, including here, where the
       // value happens to have started out declared.
       const { meta, ...narrowed } = subTarget(params, name);
-      return {
+      const lease: HeldLease = {
         object: 'claim',
         id: claimId,
-        readAt: stamp,
         ...(fenceToken !== undefined ? { fenceToken } : {}),
         target: {
           ...streamTarget({ model: name, id: params.id }),
@@ -1769,7 +1780,6 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
           ...(meta !== undefined ? { meta: declaredMeta(meta) } : {}),
         },
         description: claimDescription(params),
-        data,
         release,
         revoke: () => {
           void release().catch(() => {});
@@ -1777,6 +1787,24 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
         heartbeat,
         [Symbol.asyncDispose]: release,
       };
+      if (rowFree) return lease;
+
+      const { data, stamp } = await readModel<T>(name, { id: params.id });
+      // A held claim hands back a snapshot; the typed `HeldClaim.data` is `T`.
+      // `retrieve` reports a miss as `undefined`, and a claim on a row that does
+      // not exist has nothing to hold. The grant came BEFORE this read, so the
+      // miss must give the lease back first: otherwise the key stays held under
+      // this credential until the TTL lapses, behind no handle anyone can
+      // release, and every other participant is refused for the duration.
+      if (data === undefined) {
+        await release().catch(() => undefined);
+        throw new AbloNotFoundError(
+          `Cannot claim ${name}/${params.id}: it does not exist (or is outside this credential's scope). ` +
+            `To hold a key before its row exists, claim it by id alone: claim('${params.id}') returns a lease without a snapshot.`,
+          [params.id]
+        );
+      }
+      return { ...lease, readAt: stamp, data };
     }
     const claimsForEntity = (
       params: ClaimLookupParams<T>
@@ -1788,7 +1816,7 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
         { method: 'GET' },
         claimListResponseSchema
       );
-    const claim = Object.assign(claimImpl, {
+    const claim: HttpClaimApi<T, Fields> = Object.assign(claimImpl, {
       release: releaseClaim,
       state: async (params: ClaimLookupParams<T>): Promise<Claim | null> => {
         const res = await claimsForEntity(params);
@@ -1796,6 +1824,19 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
         const first = res.data.find((row) => row.status !== 'queued');
         return first ? claimFromModelClaim(first) : null;
       },
+      // Every holder, from the same one read `state` takes its first entry
+      // from: the server lists holders before waiters, and the caller's own
+      // lease before its peers'. (This member was missing for as long as the
+      // namespace was cast to its type instead of typed as it.)
+      list: async (params: ClaimLookupParams<T>) => {
+        const res = await claimsForEntity(params);
+        return {
+          object: 'list' as const,
+          data: res.data
+            .filter((row) => row.status !== 'queued')
+            .map(claimFromModelClaim),
+        };
+      },
       queue: async (
         params: ClaimLookupParams<T>
       ): Promise<ClaimQueueView> => {
@@ -1816,7 +1857,7 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
           }),
         });
       },
-    }) as HttpClaimApi<T, Fields>;
+    });
 
     const withMutationClaim = async <R>(
       id: string,
@@ -1834,7 +1875,7 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
         // handle. The result was mutual exclusion without lost-update
         // detection, on the transport agents run, under code that reads as
         // though it had both. The reactive client binds the same three values
-        // from the claim it holds; a caller's own `readAt`/`onStale` win.
+        // from the claim it holds; a caller's own `readAt` wins.
         return run({
           ...input,
           claimRef: { id: claimInput.id },
@@ -1844,9 +1885,6 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
           ...(input?.readAt === undefined && claimInput.readAt !== undefined
             ? { readAt: claimInput.readAt }
             : {}),
-          ...(input?.onStale === undefined && claimInput.readAt !== undefined
-            ? { onStale: 'reject' as const }
-            : {}),
           claim: undefined,
         });
       }
@@ -1892,7 +1930,7 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
     ): Promise<CommitReceipt | undefined> {
       // Functional form: update(id, current => next). The SDK owns the
       // read-fresh → compute → compare-and-swap → reconcile loop; correctness
-      // rides on the row's watermark (readAt + onStale:'reject'), so no claim
+      // rides on the row's watermark (`readAt`), so no claim
       // or per-participant identity is needed and contention never clobbers.
       if (typeof arg === 'string') {
         const id = arg;
@@ -1907,13 +1945,12 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
           model: name,
           id,
           readFresh: async () => {
-            const read = await retrieveModel<T>(name, { id });
+            const read = await readModel<T>(name, { id });
             return { data: read.data, stamp: read.stamp };
           },
           writeNext: (patch, readAt) =>
             mutateModel('update', name, id, patch, {
               readAt,
-              onStale: 'reject',
             }),
         });
       }
@@ -1926,11 +1963,8 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
 
     return {
       claim,
-      get(params: ModelReadOptions & { readonly id: string }): Promise<HttpTransportRead<T>> {
-        return retrieveModel<T>(name, params);
-      },
-      retrieve(params: ModelReadOptions & { readonly id: string }): Promise<HttpTransportRead<T>> {
-        return retrieveModel<T>(name, params);
+      read(params: ModelReadOptions & { readonly id: string }): Promise<HttpTransportRead<T>> {
+        return readModel<T>(name, params);
       },
       list(options?: ServerReadOptions<T>): ReturnType<typeof listModel<T>> {
         return listModel<T>(name, options);
@@ -1957,7 +1991,7 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
             params.data,
             options,
             async () => {
-              const read = await retrieveModel<T>(name, { id });
+              const read = await readModel<T>(name, { id });
               if (read.data === undefined) {
                 throw new AbloNotFoundError(
                   `create ${name}/${id} did not yield a readable row (the write did not confirm).`,
@@ -2024,7 +2058,7 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
           ids,
           operationResults: receipt.operationResults,
           readRow: async (id) => {
-            const read = await retrieveModel<T>(name, { id });
+            const read = await readModel<T>(name, { id });
             return read.data;
           },
         });
@@ -2036,29 +2070,6 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
           return mutateModel('delete', name, params.id, undefined, options);
         });
       },
-      async track(params: ModelTrackParams): Promise<ModelTrackResult> {
-        const dependency: TrackDependency = {
-          model: name.toLowerCase(),
-          id: params.id,
-          ...(params.readAt !== undefined ? { readAt: params.readAt } : {}),
-        };
-        // A track carries no write, so it rides the commit lane as a
-        // zero-operation body — the shape `/v1/commits` accepts for registering
-        // a premise without one. Going through the same durable lane as every
-        // other commit means a disconnect replays the registration rather than
-        // dropping it, and a notification that had already fired is not lost to
-        // a retry.
-        const body = await dispatchHttpCommit({
-          path: '/v1/commits',
-          method: 'POST',
-          idempotencyKey: createClientTxId(),
-          body: { track: [dependency] },
-          wait: 'confirmed',
-        });
-        return body.notifications && body.notifications.length > 0
-          ? { notifications: body.notifications }
-          : {};
-      },
     };
   }
 
@@ -2073,6 +2084,8 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
       }),
     dispose() {
       if (!disposePromise) {
+        for (const controller of readChangeControllers) controller.abort();
+        readChangeControllers.clear();
         const scheduledCommits = httpCommitLane;
         disposePromise = (async () => {
           await scheduledCommits;
@@ -2082,6 +2095,7 @@ export function createHttpTransport(options: HttpTransportOptions): HttpTranspor
       return disposePromise;
     },
     async purge() {},
+    onChange,
     commits,
     claims,
     logs,

package/src/transport/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Transport mechanisms. Business meaning belongs to commit, claims, and
+ * observation; this boundary owns only HTTP, WebSocket, and connection runtime.
+ */
+export * from './http/index.js';
+export * from './websocket/index.js';
+export * from './connection/index.js';