@abloatai/ablo 0.35.0 → 0.37.0

package/dist/transaction/wire/index.d.ts

@@ -1,50 +0,0 @@
-/**
- * The wire contract for the sync protocol: the HTTP envelope shapes and the
- * write-path frames, with no dependency on the client runtime. A server — a
- * route handler, an edge function — can import the envelope producers here
- * without pulling in the full sync client.
- *
- * It has two halves, used across every endpoint:
- *   - Error responses — {@link errorEnvelope}, {@link ErrorEnvelope}, and
- *     {@link statusForType} turn any thrown value into the uniform
- *     `{ type, code, param, message, doc_url, request_id }` body.
- *   - List responses — {@link listEnvelope} and {@link ListEnvelope} stamp the
- *     uniform `{ object: 'list', data, has_more, next_cursor }` collection.
- *
- * The {@link AbloError} hierarchy, {@link docUrlForCode}, and the wire-parsing
- * helpers are re-exported too, so a single import lets a route throw the right
- * typed error and serialize it back out.
- */
-export { errorEnvelopeSchema, errorEnvelope, statusForType, INTERNAL_ERROR_PUBLIC_MESSAGE, } from './errorEnvelope.js';
-export type { ErrorEnvelope } from './errorEnvelope.js';
-export { listEnvelopeSchema, listEnvelope } from './listEnvelope.js';
-export type { ListEnvelope } from './listEnvelope.js';
-export { claimEventSchema } from './claimEvent.js';
-export type { ClaimEvent } from './claimEvent.js';
-export { feedEventSchema, logListResponseSchema } from './feedEvent.js';
-export type { FeedEvent, LogListResponse } from './feedEvent.js';
-export { feedCursorSchema, parseFeedCursor, formatFeedCursor, feedCursorAdvanced, FEED_CURSOR_START, FEED_CURSOR_FORMAT, FEED_CURSOR_EXAMPLE, } from './feedCursor.js';
-export type { FeedCursor } from './feedCursor.js';
-export { bootstrapReasonSchema } from './bootstrapReason.js';
-export type { BootstrapReason } from './bootstrapReason.js';
-export { commitOperationSchema, wireCommitOperationSchema, commitPayloadSchema, commitMessageSchema, } from './frames.js';
-export { PROTOCOL_VERSION, MIN_SUPPORTED_PROTOCOL_VERSION, DEFAULT_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, WS_CLOSE_PROTOCOL_VERSION, PROTOCOL_VERSION_HEADER, protocolVersionProblem, resolveProtocolVersion, } from './protocolVersion.js';
-export type { SupportedProtocolVersion, ProtocolVersionProblem, } from './protocolVersion.js';
-export type { CommitOperation, WireCommitOperation, CommitMessage, MutationResultMessage, } from './frames.js';
-export { COMMIT_CORRELATION_ID_MAX_LENGTH, correlationIdSchema, commitStatusSchema, commitWaitSchema, commitSettlementSchema, commitReceiptSchema, rejectedCommitReceiptSchema, mutationResultPayloadSchema, mutationResultMessageSchema, commitAckSchema, mutationCommitResultSchema, commitOperationControlShape, commitOperationBodySchema, commitRequestSchema, } from './commit.js';
-export type { CommitOperationBody, CommitRequest, CorrelationId, CommitStatus, CommitWait, CommitSettlement, CommitReceiptWire, RejectedCommitReceiptWire, MutationResultPayload, MutationResultMessageWire, CommitAck, MutationCommitResultInput, MutationCommitResult, } from './commit.js';
-export { participantKindSchema, confirmationStateSchema, syncDeltaActionSchema, wireDeltaDataSchema, participantRefSchema, syncDeltaWireCoreSchema, clientSyncDeltaSchema, serverSyncDeltaSchema, deltaSchema, } from './delta.js';
-export type { ParticipantKind, ConfirmationState, SyncDeltaAction, WireDeltaData, ParticipantRef, SyncDeltaWireCore, ClientSyncDelta, ServerSyncDelta, Delta, } from './delta.js';
-export { AbloError, AbloAuthenticationError, AbloPermissionError, AbloValidationError, AbloRateLimitError, AbloIdempotencyError, AbloConnectionError, AbloNotFoundError, AbloServerError, AbloStaleContextError, AbloContentionError, AbloClaimedError, CapabilityError, AbloSessionError, SyncSessionError, docUrlForCode, translateHttpError, errorFromWire, toAbloError, ERROR_CONTRACT_VERSION, errorCodeSpec, } from '../errors.js';
-export type { ErrorCode, WireErrorCode, RequiredCapability } from '../errors.js';
-export { PING_INTERVAL_MS, LEASE_TTL_MS, WS_BEARER_SUBPROTOCOL_PREFIX, WS_SYNC_SUBPROTOCOL, } from './protocol.js';
-export { claimTargetSchema, claimRequestSchema, claimHeartbeatRequestSchema, listQuerySchema, claimListQuerySchema, claimStateSchema, claimAcquiredResponseSchema, claimQueuedResponseSchema, claimAcquireResponseSchema, claimHeartbeatReplySchema, claimHeartbeatBatchReplySchema, claimListResponseSchema, } from './claims.js';
-export type { ClaimTargetBody, ClaimRequest, ClaimHeartbeatRequest, ListQuery, ClaimListQuery, ClaimState, ClaimAcquiredResponse, ClaimQueuedResponse, ClaimAcquireResponse, ClaimHeartbeatReply, ClaimHeartbeatBatchReply, ClaimListResponse, } from './claims.js';
-export { modelReadResponseSchema, modelListResponseSchema, } from './modelResponses.js';
-export type { ModelReadResponse, ModelListResponse } from './modelResponses.js';
-export { projectResponseSchema, projectListResponseSchema, provisionedKeySchema, provisionKeyResponseSchema, conflictAxisWireSchema, schemaModelResponseSchema, schemaReadResponseSchema, logOpSchema, LOG_OP_BY_ACTION, logEventSchema, usageBucketSchema, usageReportResponseSchema, controlKeySchema, controlKeyListResponseSchema, keyMintedResponseSchema, keyRevokedResponseSchema, } from './accountResponses.js';
-export type { ProjectResponse, ProjectListResponse, ProvisionedKey, ProvisionKeyResponse, SchemaModelResponse, SchemaReadResponse, LogOp, LogEvent, UsageBucket, UsageReportResponse, ControlKey, ControlKeyListResponse, KeyMintedResponse, KeyRevokedResponse, } from './accountResponses.js';
-export { WS_INBOUND_FRAMES, wsInboundEnvelopeSchema, isKnownInboundFrame, isSchemaValidatedFrame, } from './inboundFrames.js';
-export type { InboundFrameContract, InboundFrameType, InboundFramePayload, SchemaValidatedFrameType, WsInboundEnvelope, } from './inboundFrames.js';
-export { ephemeralKeyUserSchema, ephemeralKeyRequestSchema, capabilityRequestSchema, } from './auth.js';
-export type { EphemeralKeyUser, EphemeralKeyRequest, CapabilityRequest, } from './auth.js';

package/dist/transaction/wire/index.js

@@ -1,74 +0,0 @@
-/**
- * The wire contract for the sync protocol: the HTTP envelope shapes and the
- * write-path frames, with no dependency on the client runtime. A server — a
- * route handler, an edge function — can import the envelope producers here
- * without pulling in the full sync client.
- *
- * It has two halves, used across every endpoint:
- *   - Error responses — {@link errorEnvelope}, {@link ErrorEnvelope}, and
- *     {@link statusForType} turn any thrown value into the uniform
- *     `{ type, code, param, message, doc_url, request_id }` body.
- *   - List responses — {@link listEnvelope} and {@link ListEnvelope} stamp the
- *     uniform `{ object: 'list', data, has_more, next_cursor }` collection.
- *
- * The {@link AbloError} hierarchy, {@link docUrlForCode}, and the wire-parsing
- * helpers are re-exported too, so a single import lets a route throw the right
- * typed error and serialize it back out.
- */
-export { errorEnvelopeSchema, errorEnvelope, statusForType, INTERNAL_ERROR_PUBLIC_MESSAGE, } from './errorEnvelope.js';
-export { listEnvelopeSchema, listEnvelope } from './listEnvelope.js';
-// The `GET /v1/logs` feed — the two arms, their envelope, and the cursor that
-// carries a position in each.
-export { claimEventSchema } from './claimEvent.js';
-export { feedEventSchema, logListResponseSchema } from './feedEvent.js';
-export { feedCursorSchema, parseFeedCursor, formatFeedCursor, feedCursorAdvanced, FEED_CURSOR_START, FEED_CURSOR_FORMAT, FEED_CURSOR_EXAMPLE, } from './feedCursor.js';
-export { bootstrapReasonSchema } from './bootstrapReason.js';
-// The write-path frame contract: the message shapes shared by the client and
-// the server. The runtime Zod validators sit beside the interfaces and are
-// pinned to them, and they gate every operation and payload on both commit
-// transports.
-export { commitOperationSchema, wireCommitOperationSchema, commitPayloadSchema, commitMessageSchema, } from './frames.js';
-// Protocol versioning: the single integer the client and server compare to
-// confirm they can speak to each other, plus the WebSocket close code used to
-// reject a mismatch. See protocolVersion.ts for the changelog and deploy rules.
-export { PROTOCOL_VERSION, MIN_SUPPORTED_PROTOCOL_VERSION, DEFAULT_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, WS_CLOSE_PROTOCOL_VERSION, PROTOCOL_VERSION_HEADER, protocolVersionProblem, resolveProtocolVersion, } from './protocolVersion.js';
-// Commit settlement backbone. The transport receipt, server execution cache,
-// and normalized client acknowledgement are different envelopes composed from
-// this one discriminated settlement vocabulary.
-export { COMMIT_CORRELATION_ID_MAX_LENGTH, correlationIdSchema, commitStatusSchema, commitWaitSchema, commitSettlementSchema, commitReceiptSchema, rejectedCommitReceiptSchema, mutationResultPayloadSchema, mutationResultMessageSchema, commitAckSchema, mutationCommitResultSchema, 
-// The request side of the same boundary — one definition, which the published
-// OpenAPI reference derives from rather than describing separately.
-commitOperationControlShape, commitOperationBodySchema, commitRequestSchema, } from './commit.js';
-// The read-path delta contract: the shape the server broadcasts to clients as the
-// payload of a `delta` or `sync_response` frame, together with the shared
-// participant vocabulary it carries. Both ends derive their delta type from these
-// schemas, so the client and server cannot drift apart.
-export { participantKindSchema, confirmationStateSchema, syncDeltaActionSchema, wireDeltaDataSchema, participantRefSchema, syncDeltaWireCoreSchema, clientSyncDeltaSchema, serverSyncDeltaSchema, deltaSchema, } from './delta.js';
-// The error surface a wire consumer needs to throw, classify, and serialize.
-export { AbloError, AbloAuthenticationError, AbloPermissionError, AbloValidationError, AbloRateLimitError, AbloIdempotencyError, AbloConnectionError, AbloNotFoundError, AbloServerError, AbloStaleContextError, AbloContentionError, AbloClaimedError, CapabilityError, AbloSessionError, SyncSessionError, docUrlForCode, translateHttpError, errorFromWire, toAbloError, ERROR_CONTRACT_VERSION, 
-// The table mapping each error code to its HTTP status and retryable flag —
-// plain data a server can use to resolve a code's canonical status the same
-// way the client's error serializer does.
-errorCodeSpec, } from '../errors.js';
-// Protocol timing constants — the 30-second ping cadence and the lease window
-// derived from it, shared by the client heartbeat and the server keepalive,
-// claim leasing, and presence expiry (see protocol.ts) — plus the WebSocket
-// subprotocols used during the authenticated handshake.
-export { PING_INTERVAL_MS, LEASE_TTL_MS, WS_BEARER_SUBPROTOCOL_PREFIX, WS_SYNC_SUBPROTOCOL, } from './protocol.js';
-// The claim routes' half of the boundary — requests and responses both, beside
-// the commit body for the same reason: the server answers in these shapes, the
-// client reads them back through the same schemas, and the OpenAPI reference
-// derives from them rather than describing them from memory.
-export { claimTargetSchema, claimRequestSchema, claimHeartbeatRequestSchema, listQuerySchema, claimListQuerySchema, claimStateSchema, claimAcquiredResponseSchema, claimQueuedResponseSchema, claimAcquireResponseSchema, claimHeartbeatReplySchema, claimHeartbeatBatchReplySchema, claimListResponseSchema, } from './claims.js';
-// The model read routes' responses — the envelope around a row, which is
-// protocol, around `data`, which is the caller's schema.
-export { modelReadResponseSchema, modelListResponseSchema, } from './modelResponses.js';
-// The account routes' responses — projects, the deployed schema, the commit
-// log, usage. What the server, the CLI, and the MCP server agree on.
-export { projectResponseSchema, projectListResponseSchema, provisionedKeySchema, provisionKeyResponseSchema, conflictAxisWireSchema, schemaModelResponseSchema, schemaReadResponseSchema, logOpSchema, LOG_OP_BY_ACTION, logEventSchema, usageBucketSchema, usageReportResponseSchema, controlKeySchema, controlKeyListResponseSchema, keyMintedResponseSchema, keyRevokedResponseSchema, } from './accountResponses.js';
-// The inbound socket surface: every frame the server can send, and how each
-// one's payload is validated.
-export { WS_INBOUND_FRAMES, wsInboundEnvelopeSchema, isKnownInboundFrame, isSchemaValidatedFrame, } from './inboundFrames.js';
-// Credential minting — the first call any caller makes, so the contract cannot
-// omit it. Response side lives in `auth/schemas.ts`.
-export { ephemeralKeyUserSchema, ephemeralKeyRequestSchema, capabilityRequestSchema, } from './auth.js';

package/dist/transaction/wire/listEnvelope.d.ts

@@ -1,37 +0,0 @@
-/**
- * The envelope every endpoint that returns a collection wraps its results in.
- * Because the shape is always the same — `{ object: 'list', data, has_more,
- * next_cursor }` — a consumer can detect and paginate any list the same way,
- * instead of learning a different payload key for each endpoint.
- *
- * The list endpoints emit this shape and the {@link listEnvelope} helper
- * produces it, so every list across the API reads from one definition. The
- * generic type parameter carries the row type of `data`.
- */
-import { z } from 'zod';
-/**
- * Builds the authoritative list-envelope schema for a row schema. Keeping the
- * item validator generic lets every endpoint share the same envelope contract
- * without weakening `data` to `unknown[]`.
- */
-export declare function listEnvelopeSchema<T>(itemSchema: z.ZodType<T>): z.ZodObject<{
-    object: z.ZodLiteral<"list">;
-    data: z.ZodReadonly<z.ZodArray<z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>>>;
-    has_more: z.ZodBoolean;
-    next_cursor: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
-export type ListEnvelope<T> = Readonly<z.infer<ReturnType<typeof listEnvelopeSchema<T>>>>;
-/**
- * Wraps an already-fetched page of rows in the uniform {@link ListEnvelope}.
- *
- * Pagination stays the caller's job — fetch one more row than the limit to
- * decide `hasMore`, and derive the cursor from the last row's sort key. This
- * helper only applies the envelope so no endpoint has to build the shape by
- * hand. The defaults describe a small, unpaginated collection
- * (`has_more: false`, `next_cursor: null`); a paginated endpoint passes both
- * explicitly.
- */
-export declare function listEnvelope<T>(data: readonly T[], opts?: {
-    hasMore?: boolean;
-    nextCursor?: string | null;
-}): ListEnvelope<T>;

package/dist/transaction/wire/listEnvelope.js

@@ -1,42 +0,0 @@
-/**
- * The envelope every endpoint that returns a collection wraps its results in.
- * Because the shape is always the same — `{ object: 'list', data, has_more,
- * next_cursor }` — a consumer can detect and paginate any list the same way,
- * instead of learning a different payload key for each endpoint.
- *
- * The list endpoints emit this shape and the {@link listEnvelope} helper
- * produces it, so every list across the API reads from one definition. The
- * generic type parameter carries the row type of `data`.
- */
-import { z } from 'zod';
-/**
- * Builds the authoritative list-envelope schema for a row schema. Keeping the
- * item validator generic lets every endpoint share the same envelope contract
- * without weakening `data` to `unknown[]`.
- */
-export function listEnvelopeSchema(itemSchema) {
-    return z.object({
-        object: z.literal('list'),
-        data: z.array(itemSchema).readonly(),
-        has_more: z.boolean(),
-        next_cursor: z.string().nullable(),
-    });
-}
-/**
- * Wraps an already-fetched page of rows in the uniform {@link ListEnvelope}.
- *
- * Pagination stays the caller's job — fetch one more row than the limit to
- * decide `hasMore`, and derive the cursor from the last row's sort key. This
- * helper only applies the envelope so no endpoint has to build the shape by
- * hand. The defaults describe a small, unpaginated collection
- * (`has_more: false`, `next_cursor: null`); a paginated endpoint passes both
- * explicitly.
- */
-export function listEnvelope(data, opts = {}) {
-    return {
-        object: 'list',
-        data,
-        has_more: opts.hasMore ?? false,
-        next_cursor: opts.nextCursor ?? null,
-    };
-}

package/dist/transaction/wire/modelResponses.d.ts

@@ -1,85 +0,0 @@
-/**
- * What the model read routes answer with — `GET /v1/models/{model}/{id}` and
- * `GET /v1/models/{model}`.
- *
- * `data` is `unknown` here on purpose. The transport that reads these responses
- * is schema-agnostic: it moves rows for whatever schema the caller declared, so
- * it validates the envelope around a row and leaves the row itself to the typed
- * surface above it. Everything outside `data` — the watermark, the claims, the
- * pagination — is protocol, and protocol is validated here.
- */
-import { z } from 'zod';
-/**
- * `GET /v1/models/{model}/{id}`.
- *
- * `stamp` is the row's watermark: the log position the read reflects. A write
- * that guards on this premise (`readAt`) is rejected if the row moved on in
- * between, which is what makes a read→decide→write sequence safe without a
- * lock. A missing row answers 404, so `data` is always present here.
- */
-export declare const modelReadResponseSchema: z.ZodObject<{
-    object: z.ZodLiteral<"model">;
-    model: z.ZodString;
-    id: z.ZodString;
-    data: z.ZodUnknown;
-    stamp: z.ZodNumber;
-    claims: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-        id: z.ZodString;
-        actor: z.ZodString;
-        participantKind: z.ZodPreprocess<z.ZodEnum<{
-            user: "user";
-            agent: "agent";
-            system: "system";
-        }>>;
-        onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
-            user: "user";
-            agent: "agent";
-            system: "system";
-        }>>>>;
-        capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        description: z.ZodOptional<z.ZodString>;
-        status: z.ZodOptional<z.ZodEnum<{
-            active: "active";
-            queued: "queued";
-        }>>;
-        position: z.ZodOptional<z.ZodNumber>;
-        expiresAt: z.ZodNumber;
-        fenceToken: z.ZodOptional<z.ZodNumber>;
-        target: z.ZodReadonly<z.ZodObject<{
-            model: z.ZodString;
-            id: z.ZodString;
-            path: z.ZodOptional<z.ZodString>;
-            range: z.ZodOptional<z.ZodObject<{
-                startLine: z.ZodNumber;
-                endLine: z.ZodNumber;
-                startColumn: z.ZodOptional<z.ZodNumber>;
-                endColumn: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-            field: z.ZodOptional<z.ZodString>;
-            fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$strip>>;
-        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        field: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>>;
-}, z.core.$strip>;
-export type ModelReadResponse = z.infer<typeof modelReadResponseSchema>;
-/**
- * `GET /v1/models/{model}` — the list envelope, with the two fields the model
- * routes add to it: the model's name and the org-wide watermark the page was
- * read at.
- *
- * The envelope is derived, not restated. A schema-agnostic row is `z.unknown()`,
- * which the generic helper accepts like any other item schema, so there is no
- * layer at which the shared fields have to be spelled a second time.
- */
-export declare const modelListResponseSchema: z.ZodObject<{
-    object: z.ZodLiteral<"list">;
-    data: z.ZodReadonly<z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
-    has_more: z.ZodBoolean;
-    next_cursor: z.ZodNullable<z.ZodString>;
-    model: z.ZodString;
-    stamp: z.ZodNumber;
-}, z.core.$strip>;
-export type ModelListResponse = z.infer<typeof modelListResponseSchema>;

package/dist/transaction/wire/modelResponses.js

@@ -1,43 +0,0 @@
-/**
- * What the model read routes answer with — `GET /v1/models/{model}/{id}` and
- * `GET /v1/models/{model}`.
- *
- * `data` is `unknown` here on purpose. The transport that reads these responses
- * is schema-agnostic: it moves rows for whatever schema the caller declared, so
- * it validates the envelope around a row and leaves the row itself to the typed
- * surface above it. Everything outside `data` — the watermark, the claims, the
- * pagination — is protocol, and protocol is validated here.
- */
-import { z } from 'zod';
-import { modelClaimSchema } from '../coordination/schema.js';
-import { listEnvelopeSchema } from './listEnvelope.js';
-/**
- * `GET /v1/models/{model}/{id}`.
- *
- * `stamp` is the row's watermark: the log position the read reflects. A write
- * that guards on this premise (`readAt`) is rejected if the row moved on in
- * between, which is what makes a read→decide→write sequence safe without a
- * lock. A missing row answers 404, so `data` is always present here.
- */
-export const modelReadResponseSchema = z.object({
-    object: z.literal('model'),
-    model: z.string(),
-    id: z.string(),
-    data: z.unknown(),
-    stamp: z.number(),
-    /** Who holds this row right now — empty when no claim store is configured. */
-    claims: z.array(modelClaimSchema).readonly(),
-});
-/**
- * `GET /v1/models/{model}` — the list envelope, with the two fields the model
- * routes add to it: the model's name and the org-wide watermark the page was
- * read at.
- *
- * The envelope is derived, not restated. A schema-agnostic row is `z.unknown()`,
- * which the generic helper accepts like any other item schema, so there is no
- * layer at which the shared fields have to be spelled a second time.
- */
-export const modelListResponseSchema = listEnvelopeSchema(z.unknown()).extend({
-    model: z.string(),
-    stamp: z.number(),
-});

package/dist/transaction/wire/protocol.d.ts

@@ -1,38 +0,0 @@
-/**
- * The timing constants both sides of the protocol must agree on: the ping
- * cadence and the lease window derived from it. Defining them here once keeps
- * the client and the server from skewing apart — a change to the ping interval
- * that did not also move the lease window would make claim expiry and presence
- * timeouts disagree between the two.
- *
- * {@link PING_INTERVAL_MS} is how often the connection pings to prove it is
- * alive. {@link LEASE_TTL_MS} is how long a claim or presence entry stays valid
- * without a renewing ping. On the client, these set the heartbeat cadence and
- * the fallback expiry for a claim taken without an explicit lease. On the
- * server, they set the keepalive interval, the lease granted per keepalive, and
- * the presence-entry lifetime, so a silently disconnected client drops off the
- * roster within one lease window.
- *
- * The lease is three ping intervals long and is renewed on every ping, so a
- * live holder always has at least two intervals of runway and a silent one
- * lapses about two missed pings after it stops renewing. The window measures
- * liveness, not how long a task may run: widening the lease without also
- * widening the ping makes holders flap, and neither value should be redefined
- * anywhere else.
- */
-export declare const PING_INTERVAL_MS = 30000;
-export declare const LEASE_TTL_MS: number;
-/**
- * The WebSocket subprotocols that carry the bearer credential out of the URL.
- *
- * A browser cannot set an `Authorization` header on a WebSocket, so the client
- * offers the token as a `Sec-WebSocket-Protocol` value — `ablo.bearer.<token>` —
- * alongside the real `ablo.sync.v1` protocol the server selects. This keeps the
- * credential out of the query string, which access logs, proxies, and browser
- * history would otherwise capture. The server reads the token from the
- * subprotocol and echoes back only `ablo.sync.v1`, never the token-bearing
- * value. Both the client and the server import these constants, so the
- * handshake format cannot drift.
- */
-export declare const WS_BEARER_SUBPROTOCOL_PREFIX = "ablo.bearer.";
-export declare const WS_SYNC_SUBPROTOCOL = "ablo.sync.v1";

package/dist/transaction/wire/protocol.js

@@ -1,38 +0,0 @@
-/**
- * The timing constants both sides of the protocol must agree on: the ping
- * cadence and the lease window derived from it. Defining them here once keeps
- * the client and the server from skewing apart — a change to the ping interval
- * that did not also move the lease window would make claim expiry and presence
- * timeouts disagree between the two.
- *
- * {@link PING_INTERVAL_MS} is how often the connection pings to prove it is
- * alive. {@link LEASE_TTL_MS} is how long a claim or presence entry stays valid
- * without a renewing ping. On the client, these set the heartbeat cadence and
- * the fallback expiry for a claim taken without an explicit lease. On the
- * server, they set the keepalive interval, the lease granted per keepalive, and
- * the presence-entry lifetime, so a silently disconnected client drops off the
- * roster within one lease window.
- *
- * The lease is three ping intervals long and is renewed on every ping, so a
- * live holder always has at least two intervals of runway and a silent one
- * lapses about two missed pings after it stops renewing. The window measures
- * liveness, not how long a task may run: widening the lease without also
- * widening the ping makes holders flap, and neither value should be redefined
- * anywhere else.
- */
-export const PING_INTERVAL_MS = 30_000;
-export const LEASE_TTL_MS = 3 * PING_INTERVAL_MS;
-/**
- * The WebSocket subprotocols that carry the bearer credential out of the URL.
- *
- * A browser cannot set an `Authorization` header on a WebSocket, so the client
- * offers the token as a `Sec-WebSocket-Protocol` value — `ablo.bearer.<token>` —
- * alongside the real `ablo.sync.v1` protocol the server selects. This keeps the
- * credential out of the query string, which access logs, proxies, and browser
- * history would otherwise capture. The server reads the token from the
- * subprotocol and echoes back only `ablo.sync.v1`, never the token-bearing
- * value. Both the client and the server import these constants, so the
- * handshake format cannot drift.
- */
-export const WS_BEARER_SUBPROTOCOL_PREFIX = 'ablo.bearer.';
-export const WS_SYNC_SUBPROTOCOL = 'ablo.sync.v1';

package/dist/transaction/wire/protocolVersion.d.ts

@@ -1,73 +0,0 @@
-/**
- * The sync protocol version — a single integer, increasing over time, that
- * covers everything the client and server must agree on to talk to each other:
- * the WebSocket frame shapes, the HTTP request and response envelopes, and the
- * delta encodings a client replays. It is separate from the advisory
- * app-schema hash, which diagnoses data-model drift; this version selects a
- * concrete transport codec.
- *
- * Deploy ordering: the server is deployed first. It accepts every version in
- * {@link SUPPORTED_PROTOCOL_VERSIONS}, and a client is never expected to connect
- * to a server older than itself. If that does happen — for example a partial
- * server rollback — {@link protocolVersionProblem} reports it as `too_new` so
- * the mismatch is visible rather than undefined.
- *
- * To change the protocol:
- *   1. Make the change backward-tolerant where you can. The server ignores
- *      unknown payload keys, so an additive field usually needs no version bump.
- *   2. For a breaking change, bump {@link PROTOCOL_VERSION}, add its codec to
- *      {@link SUPPORTED_PROTOCOL_VERSIONS}, and add a changelog entry below.
- *   3. Keep {@link MIN_SUPPORTED_PROTOCOL_VERSION} low enough to cover every
- *      client still in use; raise it only after a deprecation window.
- *   4. The protocol contract tests fail on a version without a codec and on any
- *      unreviewed bump — update them in the same change, deliberately.
- *
- * Changelog
- *   v1 (2026-07-03) — the protocol as of this field's introduction: the
- *      sync-request frame (`cursor`, `lastSyncId`, `capabilities`, optional
- *      `protocolVersion`), the commit, claim, release, ack, and
- *      presence-update frames, the bootstrap and delta batches, and the HTTP
- *      error and list envelopes. A client that predates this field sends no
- *      `protocolVersion` and is treated as v1, since introducing the field
- *      changed no behavior.
- */
-export declare const PROTOCOL_VERSION = 1;
-/**
- * The oldest client protocol version this build still serves. Raising it cuts
- * off clients that have not upgraded, so do it only after a deprecation window
- * and with a changelog entry.
- */
-export declare const MIN_SUPPORTED_PROTOCOL_VERSION = 1;
-/** The version used by clients from before the version field existed. */
-export declare const DEFAULT_PROTOCOL_VERSION = 1;
-/**
- * Every wire version this build can actually decode. This is intentionally an
- * explicit manifest rather than a computed numeric range: a version is not
- * supported merely because its number falls between two constants. Server
- * codec registries use {@link SupportedProtocolVersion} as their key type, so
- * adding a version here makes a missing decoder a compile error.
- */
-export declare const SUPPORTED_PROTOCOL_VERSIONS: readonly [1];
-export type SupportedProtocolVersion = (typeof SUPPORTED_PROTOCOL_VERSIONS)[number];
-export type ProtocolVersionProblem = 'too_old' | 'too_new' | 'codec_missing';
-/**
- * The WebSocket close code the server sends to reject a protocol-version
- * mismatch. It sits alongside the other application close codes (4001 for a
- * credential problem), and its reason string is the
- * error code `protocol_version_unsupported`. A client should treat this close
- * as terminal: reconnecting cannot heal a version mismatch, but upgrading the
- * client or rolling the server forward can.
- */
-export declare const WS_CLOSE_PROTOCOL_VERSION = 4010;
-/**
- * Classifies a peer's announced protocol version against what this build
- * supports, returning `'too_old'`, `'too_new'`, or `null` when the versions are
- * compatible. An `undefined` version — a client from before versioning existed
- * — counts as v1. A non-integer value is treated as `'too_old'` so the check
- * fails closed and visibly.
- */
-export declare function protocolVersionProblem(announced: number | undefined): ProtocolVersionProblem | null;
-/** Resolve an announced value to a version that has a concrete codec. */
-export declare function resolveProtocolVersion(announced: number | undefined): SupportedProtocolVersion | null;
-/** The HTTP request header a client uses to announce its protocol version. */
-export declare const PROTOCOL_VERSION_HEADER = "Ablo-Protocol-Version";

package/dist/transaction/wire/protocolVersion.js

@@ -1,83 +0,0 @@
-/**
- * The sync protocol version — a single integer, increasing over time, that
- * covers everything the client and server must agree on to talk to each other:
- * the WebSocket frame shapes, the HTTP request and response envelopes, and the
- * delta encodings a client replays. It is separate from the advisory
- * app-schema hash, which diagnoses data-model drift; this version selects a
- * concrete transport codec.
- *
- * Deploy ordering: the server is deployed first. It accepts every version in
- * {@link SUPPORTED_PROTOCOL_VERSIONS}, and a client is never expected to connect
- * to a server older than itself. If that does happen — for example a partial
- * server rollback — {@link protocolVersionProblem} reports it as `too_new` so
- * the mismatch is visible rather than undefined.
- *
- * To change the protocol:
- *   1. Make the change backward-tolerant where you can. The server ignores
- *      unknown payload keys, so an additive field usually needs no version bump.
- *   2. For a breaking change, bump {@link PROTOCOL_VERSION}, add its codec to
- *      {@link SUPPORTED_PROTOCOL_VERSIONS}, and add a changelog entry below.
- *   3. Keep {@link MIN_SUPPORTED_PROTOCOL_VERSION} low enough to cover every
- *      client still in use; raise it only after a deprecation window.
- *   4. The protocol contract tests fail on a version without a codec and on any
- *      unreviewed bump — update them in the same change, deliberately.
- *
- * Changelog
- *   v1 (2026-07-03) — the protocol as of this field's introduction: the
- *      sync-request frame (`cursor`, `lastSyncId`, `capabilities`, optional
- *      `protocolVersion`), the commit, claim, release, ack, and
- *      presence-update frames, the bootstrap and delta batches, and the HTTP
- *      error and list envelopes. A client that predates this field sends no
- *      `protocolVersion` and is treated as v1, since introducing the field
- *      changed no behavior.
- */
-export const PROTOCOL_VERSION = 1;
-/**
- * The oldest client protocol version this build still serves. Raising it cuts
- * off clients that have not upgraded, so do it only after a deprecation window
- * and with a changelog entry.
- */
-export const MIN_SUPPORTED_PROTOCOL_VERSION = 1;
-/** The version used by clients from before the version field existed. */
-export const DEFAULT_PROTOCOL_VERSION = 1;
-/**
- * Every wire version this build can actually decode. This is intentionally an
- * explicit manifest rather than a computed numeric range: a version is not
- * supported merely because its number falls between two constants. Server
- * codec registries use {@link SupportedProtocolVersion} as their key type, so
- * adding a version here makes a missing decoder a compile error.
- */
-export const SUPPORTED_PROTOCOL_VERSIONS = [1];
-/**
- * The WebSocket close code the server sends to reject a protocol-version
- * mismatch. It sits alongside the other application close codes (4001 for a
- * credential problem), and its reason string is the
- * error code `protocol_version_unsupported`. A client should treat this close
- * as terminal: reconnecting cannot heal a version mismatch, but upgrading the
- * client or rolling the server forward can.
- */
-export const WS_CLOSE_PROTOCOL_VERSION = 4010;
-/**
- * Classifies a peer's announced protocol version against what this build
- * supports, returning `'too_old'`, `'too_new'`, or `null` when the versions are
- * compatible. An `undefined` version — a client from before versioning existed
- * — counts as v1. A non-integer value is treated as `'too_old'` so the check
- * fails closed and visibly.
- */
-export function protocolVersionProblem(announced) {
-    const v = announced ?? DEFAULT_PROTOCOL_VERSION;
-    if (!Number.isInteger(v) || v < MIN_SUPPORTED_PROTOCOL_VERSION)
-        return 'too_old';
-    if (v > PROTOCOL_VERSION)
-        return 'too_new';
-    return SUPPORTED_PROTOCOL_VERSIONS.some((candidate) => candidate === v)
-        ? null
-        : 'codec_missing';
-}
-/** Resolve an announced value to a version that has a concrete codec. */
-export function resolveProtocolVersion(announced) {
-    const version = announced ?? DEFAULT_PROTOCOL_VERSION;
-    return SUPPORTED_PROTOCOL_VERSIONS.find((candidate) => candidate === version) ?? null;
-}
-/** The HTTP request header a client uses to announce its protocol version. */
-export const PROTOCOL_VERSION_HEADER = 'Ablo-Protocol-Version';