@abloatai/ablo 0.28.0 → 0.29.1

package/dist/wire/frames.d.ts

@@ -1,9 +1,9 @@
 /**
  * The write-path message shapes for the sync protocol. These cover the frames
- * a client sends to commit work — {@link CommitMessage} (a batch of raw
- * operations) and {@link MutationMessage} (a single named mutation) — and the
- * server's {@link MutationResultMessage} acknowledgement. The same frames flow
- * over a WebSocket connection and over the HTTP commit endpoint.
+ * a client sends to commit work — {@link CommitMessage}, a batch of raw
+ * operations — and the server's {@link MutationResultMessage}
+ * acknowledgement. The same frames flow over a WebSocket connection and over
+ * the HTTP commit endpoint.
  *
  * Both the client and the server import these definitions from here, so the two
  * sides cannot drift. Each interface is paired with a Zod validator
@@ -85,25 +85,10 @@ export declare const commitOperationSchema: z.ZodObject<{
     transactionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     bypass: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
 }, z.core.$strip>;
-/**
- * A client-to-server frame that invokes a single named mutation by name and
- * arguments, as opposed to the raw operation batch in {@link CommitMessage}.
- * The server resolves `mutatorName` against the set of mutations registered on
- * it and runs the matching one.
- */
-export interface MutationMessage {
-    type: 'mutation';
-    payload: {
-        mutatorName: string;
-        input: unknown;
-        clientTxId: string;
-    };
-}
 /**
  * A client-to-server frame that asks the server to commit a batch of operations
- * atomically. This is the raw-operation counterpart to {@link MutationMessage};
- * it carries a list of {@link CommitOperation} entries plus the batch metadata
- * below.
+ * atomically. It carries a list of {@link CommitOperation} entries plus the
+ * batch metadata below.
  */
 export interface CommitMessage {
     type: 'commit';
@@ -222,239 +207,3 @@ export interface MutationResultMessage {
         };
     };
 }
-/**
- * A transport frame carrying the Zod-first v2 commit request. The payload's
- * `schemaVersion` distinguishes it from the legacy `commit` payload during the
- * migration window; the transport does not duplicate the commit contract.
- */
-export declare const commitRequestMessageSchema: z.ZodObject<{
-    type: z.ZodLiteral<"commit">;
-    payload: z.ZodObject<{
-        idempotencyKey: z.core.$ZodBranded<z.ZodString, "IdempotencyKey", "out">;
-        schemaVersion: z.ZodLiteral<2>;
-        operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            type: z.ZodLiteral<"create">;
-            value: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
-            operationId: z.core.$ZodBranded<z.ZodString, "OperationId", "out">;
-            target: z.ZodObject<{
-                model: z.ZodString;
-                id: z.ZodString;
-            }, z.core.$strict>;
-            preconditions: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                type: z.ZodLiteral<"unchanged_since">;
-                cursor: z.core.$ZodBranded<z.ZodString, "SyncOffset", "out">;
-                fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>, z.ZodObject<{
-                type: z.ZodLiteral<"version_matches">;
-                version: z.ZodNumber;
-            }, z.core.$strict>, z.ZodObject<{
-                type: z.ZodLiteral<"claim_fence">;
-                claimId: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
-                generation: z.ZodNumber;
-            }, z.core.$strict>], "type">>>;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"patch">;
-            changes: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
-            operationId: z.core.$ZodBranded<z.ZodString, "OperationId", "out">;
-            target: z.ZodObject<{
-                model: z.ZodString;
-                id: z.ZodString;
-            }, z.core.$strict>;
-            preconditions: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                type: z.ZodLiteral<"unchanged_since">;
-                cursor: z.core.$ZodBranded<z.ZodString, "SyncOffset", "out">;
-                fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>, z.ZodObject<{
-                type: z.ZodLiteral<"version_matches">;
-                version: z.ZodNumber;
-            }, z.core.$strict>, z.ZodObject<{
-                type: z.ZodLiteral<"claim_fence">;
-                claimId: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
-                generation: z.ZodNumber;
-            }, z.core.$strict>], "type">>>;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"delete">;
-            operationId: z.core.$ZodBranded<z.ZodString, "OperationId", "out">;
-            target: z.ZodObject<{
-                model: z.ZodString;
-                id: z.ZodString;
-            }, z.core.$strict>;
-            preconditions: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                type: z.ZodLiteral<"unchanged_since">;
-                cursor: z.core.$ZodBranded<z.ZodString, "SyncOffset", "out">;
-                fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>, z.ZodObject<{
-                type: z.ZodLiteral<"version_matches">;
-                version: z.ZodNumber;
-            }, z.core.$strict>, z.ZodObject<{
-                type: z.ZodLiteral<"claim_fence">;
-                claimId: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
-                generation: z.ZodNumber;
-            }, z.core.$strict>], "type">>>;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"archive">;
-            operationId: z.core.$ZodBranded<z.ZodString, "OperationId", "out">;
-            target: z.ZodObject<{
-                model: z.ZodString;
-                id: z.ZodString;
-            }, z.core.$strict>;
-            preconditions: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                type: z.ZodLiteral<"unchanged_since">;
-                cursor: z.core.$ZodBranded<z.ZodString, "SyncOffset", "out">;
-                fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>, z.ZodObject<{
-                type: z.ZodLiteral<"version_matches">;
-                version: z.ZodNumber;
-            }, z.core.$strict>, z.ZodObject<{
-                type: z.ZodLiteral<"claim_fence">;
-                claimId: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
-                generation: z.ZodNumber;
-            }, z.core.$strict>], "type">>>;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"unarchive">;
-            operationId: z.core.$ZodBranded<z.ZodString, "OperationId", "out">;
-            target: z.ZodObject<{
-                model: z.ZodString;
-                id: z.ZodString;
-            }, z.core.$strict>;
-            preconditions: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                type: z.ZodLiteral<"unchanged_since">;
-                cursor: z.core.$ZodBranded<z.ZodString, "SyncOffset", "out">;
-                fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>, z.ZodObject<{
-                type: z.ZodLiteral<"version_matches">;
-                version: z.ZodNumber;
-            }, z.core.$strict>, z.ZodObject<{
-                type: z.ZodLiteral<"claim_fence">;
-                claimId: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
-                generation: z.ZodNumber;
-            }, z.core.$strict>], "type">>>;
-        }, z.core.$strict>], "type">>;
-        metadata: z.ZodOptional<z.ZodObject<{
-            label: z.ZodOptional<z.ZodString>;
-            causedByTaskId: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type CommitRequestMessage = z.output<typeof commitRequestMessageSchema>;
-/** A transport frame carrying one terminal, status-discriminated v2 receipt. */
-export declare const commitResultMessageSchema: z.ZodObject<{
-    type: z.ZodLiteral<"commit_result">;
-    payload: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        status: z.ZodLiteral<"committed">;
-        syncCursor: z.core.$ZodBranded<z.ZodString, "SyncCursor", "out">;
-        operationCount: z.ZodNumber;
-        object: z.ZodLiteral<"commit_receipt">;
-        schemaVersion: z.ZodLiteral<2>;
-        idempotencyKey: z.core.$ZodBranded<z.ZodString, "IdempotencyKey", "out">;
-        commitId: z.core.$ZodBranded<z.ZodUUID, "CommitId", "out">;
-    }, z.core.$strict>, z.ZodObject<{
-        status: z.ZodLiteral<"conflicted">;
-        syncCursor: z.core.$ZodBranded<z.ZodString, "SyncCursor", "out">;
-        conflicts: z.ZodArray<z.ZodObject<{
-            operationId: z.core.$ZodBranded<z.ZodString, "OperationId", "out">;
-            target: z.ZodObject<{
-                model: z.ZodString;
-                id: z.ZodString;
-            }, z.core.$strict>;
-            fields: z.ZodArray<z.ZodString>;
-            currentValues: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
-            observedAt: z.core.$ZodBranded<z.ZodString, "SyncOffset", "out">;
-        }, z.core.$strict>>;
-        object: z.ZodLiteral<"commit_receipt">;
-        schemaVersion: z.ZodLiteral<2>;
-        idempotencyKey: z.core.$ZodBranded<z.ZodString, "IdempotencyKey", "out">;
-        commitId: z.core.$ZodBranded<z.ZodUUID, "CommitId", "out">;
-    }, z.core.$strict>, z.ZodObject<{
-        status: z.ZodLiteral<"rejected">;
-        error: z.ZodObject<{
-            code: z.ZodUnion<readonly [z.ZodEnum<{}>, z.ZodCustom<`policy:${string}`, `policy:${string}`>]>;
-            message: z.ZodString;
-            field: z.ZodOptional<z.ZodString>;
-            requiredCapability: z.ZodOptional<z.ZodObject<{
-                scope: z.ZodString;
-                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
-                issuer: z.ZodOptional<z.ZodString>;
-                ttlSeconds: z.ZodOptional<z.ZodNumber>;
-                nonce: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>>;
-            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-        }, z.core.$strict>;
-        object: z.ZodLiteral<"commit_receipt">;
-        schemaVersion: z.ZodLiteral<2>;
-        idempotencyKey: z.core.$ZodBranded<z.ZodString, "IdempotencyKey", "out">;
-        commitId: z.core.$ZodBranded<z.ZodUUID, "CommitId", "out">;
-    }, z.core.$strict>], "status">;
-}, z.core.$strict>;
-export type CommitResultMessage = z.output<typeof commitResultMessageSchema>;
-/** Explicit compatibility name for the v1 uppercase operation schema. */
-export declare const legacyCommitOperationSchema: z.ZodObject<{
-    readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-        reject: "reject";
-        overwrite: "overwrite";
-        notify: "notify";
-    }>>>;
-    type: z.ZodEnum<{
-        CREATE: "CREATE";
-        UPDATE: "UPDATE";
-        DELETE: "DELETE";
-        ARCHIVE: "ARCHIVE";
-        UNARCHIVE: "UNARCHIVE";
-    }>;
-    model: z.ZodString;
-    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    input: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    transactionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    bypass: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
-}, z.core.$strip>;
-/** Explicit compatibility name for the v1 `clientTxId` payload schema. */
-export declare const legacyCommitPayloadSchema: z.ZodObject<{
-    operations: z.ZodArray<z.ZodObject<{
-        readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            reject: "reject";
-            overwrite: "overwrite";
-            notify: "notify";
-        }>>>;
-        type: z.ZodEnum<{
-            CREATE: "CREATE";
-            UPDATE: "UPDATE";
-            DELETE: "DELETE";
-            ARCHIVE: "ARCHIVE";
-            UNARCHIVE: "UNARCHIVE";
-        }>;
-        model: z.ZodString;
-        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        input: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        transactionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        bypass: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
-    }, z.core.$strip>>;
-    clientTxId: z.ZodString;
-    causedByTaskId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    reads: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        model: z.ZodString;
-        id: z.ZodString;
-        readAt: z.ZodNumber;
-        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        onStale: z.ZodOptional<z.ZodEnum<{
-            reject: "reject";
-            overwrite: "overwrite";
-            notify: "notify";
-        }>>;
-    }, z.core.$strip>, z.ZodObject<{
-        group: z.ZodString;
-        readAt: z.ZodNumber;
-        onStale: z.ZodOptional<z.ZodEnum<{
-            reject: "reject";
-            overwrite: "overwrite";
-            notify: "notify";
-        }>>;
-    }, z.core.$strip>]>>>>;
-}, z.core.$strip>;
-/** Explicit compatibility alias for the v1 uppercase operation shape. */
-export type LegacyCommitOperation = CommitOperation;
-/** Explicit compatibility alias for the v1 `clientTxId` commit frame. */
-export type LegacyCommitMessage = CommitMessage;
-/** Explicit compatibility alias for the v1 boolean-style mutation receipt. */
-export type LegacyMutationResultMessage = MutationResultMessage;

package/dist/wire/frames.js

@@ -1,9 +1,9 @@
 /**
  * The write-path message shapes for the sync protocol. These cover the frames
- * a client sends to commit work — {@link CommitMessage} (a batch of raw
- * operations) and {@link MutationMessage} (a single named mutation) — and the
- * server's {@link MutationResultMessage} acknowledgement. The same frames flow
- * over a WebSocket connection and over the HTTP commit endpoint.
+ * a client sends to commit work — {@link CommitMessage}, a batch of raw
+ * operations — and the server's {@link MutationResultMessage}
+ * acknowledgement. The same frames flow over a WebSocket connection and over
+ * the HTTP commit endpoint.
  *
  * Both the client and the server import these definitions from here, so the two
  * sides cannot drift. Each interface is paired with a Zod validator
@@ -16,7 +16,6 @@ import { z } from 'zod';
 // The runtime schema primitives are imported straight from the coordination
 // schema module to keep this file's runtime dependencies limited to Zod.
 import { commitOperationSchema as coordinationCommitOperationSchema, readDependencySchema, } from '../coordination/schema.js';
-import { commitReceiptSchema as commitReceiptV2Schema, commitRequestSchema as commitRequestV2Schema, } from '../commit/contract.js';
 /**
  * Runtime validator for {@link CommitOperation}. Both commit transports — the
  * WebSocket `commit` frame and the HTTP `/v1/commits` endpoint — run this check
@@ -47,23 +46,3 @@ export const commitPayloadSchema = z.object({
 // Pins the schema to the payload type: fails to compile if either side drifts.
 const _commitPayloadContract = true;
 void _commitPayloadContract;
-// ── Commit contract v2 ───────────────────────────────────────────────────
-/**
- * A transport frame carrying the Zod-first v2 commit request. The payload's
- * `schemaVersion` distinguishes it from the legacy `commit` payload during the
- * migration window; the transport does not duplicate the commit contract.
- */
-export const commitRequestMessageSchema = z.strictObject({
-    type: z.literal('commit'),
-    payload: commitRequestV2Schema,
-});
-/** A transport frame carrying one terminal, status-discriminated v2 receipt. */
-export const commitResultMessageSchema = z.strictObject({
-    type: z.literal('commit_result'),
-    payload: commitReceiptV2Schema,
-});
-// ── Explicit v1 compatibility names ─────────────────────────────────────
-/** Explicit compatibility name for the v1 uppercase operation schema. */
-export const legacyCommitOperationSchema = commitOperationSchema;
-/** Explicit compatibility name for the v1 `clientTxId` payload schema. */
-export const legacyCommitPayloadSchema = commitPayloadSchema;

package/dist/wire/index.d.ts

@@ -21,9 +21,10 @@ export { listEnvelope } from './listEnvelope.js';
 export type { ListEnvelope } from './listEnvelope.js';
 export { bootstrapReasonSchema } from './bootstrapReason.js';
 export type { BootstrapReason } from './bootstrapReason.js';
-export { commitOperationSchema, commitPayloadSchema, commitRequestMessageSchema, commitResultMessageSchema, legacyCommitOperationSchema, legacyCommitPayloadSchema, } from './frames.js';
-export { PROTOCOL_VERSION, MIN_SUPPORTED_PROTOCOL_VERSION, WS_CLOSE_PROTOCOL_VERSION, PROTOCOL_VERSION_HEADER, protocolVersionProblem, } from './protocolVersion.js';
-export type { CommitOperation, MutationMessage, CommitMessage, MutationResultMessage, CommitRequestMessage, CommitResultMessage, LegacyCommitOperation, LegacyCommitMessage, LegacyMutationResultMessage, } from './frames.js';
+export { commitOperationSchema, commitPayloadSchema, } 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, CommitMessage, MutationResultMessage, } from './frames.js';
 export { participantKindSchema, confirmationStateSchema, syncDeltaActionSchema, wireDeltaDataSchema, participantRefSchema, syncDeltaWireCoreSchema, clientSyncDeltaSchema, serverSyncDeltaSchema, } from './delta.js';
 export type { ParticipantKind, ConfirmationState, SyncDeltaAction, WireDeltaData, ParticipantRef, SyncDeltaWireCore, ClientSyncDelta, ServerSyncDelta, } from './delta.js';
 export { AbloError, AbloAuthenticationError, AbloPermissionError, AbloValidationError, AbloRateLimitError, AbloIdempotencyError, AbloConnectionError, AbloServerError, AbloStaleContextError, AbloClaimedError, CapabilityError, SyncSessionError, docUrlForCode, translateHttpError, errorFromWire, toAbloError, ERROR_CONTRACT_VERSION, errorCodeSpec, } from '../errors.js';

package/dist/wire/index.js

@@ -22,11 +22,11 @@ export { bootstrapReasonSchema } from './bootstrapReason.js';
 // 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, commitPayloadSchema, commitRequestMessageSchema, commitResultMessageSchema, legacyCommitOperationSchema, legacyCommitPayloadSchema, } from './frames.js';
+export { commitOperationSchema, commitPayloadSchema, } 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, WS_CLOSE_PROTOCOL_VERSION, PROTOCOL_VERSION_HEADER, protocolVersionProblem, } from './protocolVersion.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';
 // 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

package/dist/wire/protocolVersion.d.ts

@@ -2,31 +2,30 @@
  * 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 app-schema hash
- * (WebSocket close code 4009), which detects drift in your data model; this
- * detects drift in the protocol itself.
+ * 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
- * the inclusive range from {@link MIN_SUPPORTED_PROTOCOL_VERSION} to
- * {@link PROTOCOL_VERSION}, 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.
+ * {@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 a changelog
- *      entry below, and keep {@link MIN_SUPPORTED_PROTOCOL_VERSION} low enough
- *      to cover every client still in use; raise it only after a deprecation
- *      window.
- *   3. The protocol-version contract test fails on any bump — update it in the
- *      same change, deliberately.
+ *   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, mutation, claim, release, ack, and
+ *      `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
@@ -39,10 +38,22 @@ export declare const PROTOCOL_VERSION = 1;
  * 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, 4009 for app-schema drift), and its reason string is the
+ * 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.
@@ -55,6 +66,8 @@ export declare const WS_CLOSE_PROTOCOL_VERSION = 4010;
  * — 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): 'too_old' | 'too_new' | null;
+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/wire/protocolVersion.js

@@ -2,31 +2,30 @@
  * 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 app-schema hash
- * (WebSocket close code 4009), which detects drift in your data model; this
- * detects drift in the protocol itself.
+ * 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
- * the inclusive range from {@link MIN_SUPPORTED_PROTOCOL_VERSION} to
- * {@link PROTOCOL_VERSION}, 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.
+ * {@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 a changelog
- *      entry below, and keep {@link MIN_SUPPORTED_PROTOCOL_VERSION} low enough
- *      to cover every client still in use; raise it only after a deprecation
- *      window.
- *   3. The protocol-version contract test fails on any bump — update it in the
- *      same change, deliberately.
+ *   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, mutation, claim, release, ack, and
+ *      `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
@@ -39,10 +38,20 @@ export const PROTOCOL_VERSION = 1;
  * 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, 4009 for app-schema drift), and its reason string is the
+ * 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.
@@ -56,12 +65,19 @@ export const WS_CLOSE_PROTOCOL_VERSION = 4010;
  * fails closed and visibly.
  */
 export function protocolVersionProblem(announced) {
-    const v = announced ?? 1;
+    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 null;
+    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';

package/docs/agents.md

@@ -27,10 +27,15 @@ import { schema } from "./schema";
 
 const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY, transport: "http" });
 
-// Reads + writes, fully typed off your schema — each is one HTTP round-trip:
+// Reads + writes, fully typed off your schema.
+// `retrieve` resolves to the row, or `undefined` when none matches.
 const open = await ablo.tasks.list({ where: { status: "todo" } });
-const { data } = await ablo.tasks.retrieve({ id: open[0].id });
-await ablo.tasks.update({ id: open[0].id, data: { status: "done" } });
+
+const task = await ablo.tasks.retrieve({ id: open[0].id });
+if (!task) throw new Error("task not found");
+
+console.log(task.title);
+await ablo.tasks.update({ id: task.id, data: { status: "done" } });
 ```
 
 It exposes `retrieve` / `list` / `create` / `update` / `delete`, plus `commits`

package/docs/api.md

@@ -221,10 +221,12 @@ endpoint documents that model's real field contract instead of a generic blob.
 
 Auth is a bearer API key: `Authorization: Bearer sk_…`. Mutations take an
 `Idempotency-Key` header — derive it from the business event, not a random
-value, so a retry never double-writes. Writes return a `CommitReceipt`; a
-rejected write carries an error `code` (e.g. `stale_context`, `intent_conflict`)
-to act on. `GET /api/v1/models/{model}` is cursor-paginated (`limit`, `order`,
-`order_by`, `starting_after`) and returns `{ data, has_more, next_cursor }`.
+value, so a retry never double-writes. Direct HTTP writes return a protocol
+receipt; the typed SDK turns single-model writes into their application result
+(the created or updated row, or nothing for delete). A rejected write carries an
+error `code` (e.g. `stale_context`, `intent_conflict`) to act on.
+`GET /api/v1/models/{model}` is cursor-paginated (`limit`, `order`, `order_by`,
+`starting_after`) and returns `{ data, has_more, next_cursor }`.
 
 `POST /api/v1/commits` remains the path for **atomic multi-op** writes (several
 operations across rows/models that must commit together) — the per-model routes

package/docs/client-behavior.md

@@ -32,6 +32,7 @@ Common options:
 | `databaseUrl` | Optional, server-only. Registers your Postgres directly (the connection-string path). Pass it explicitly — it is **not** auto-read from the environment. Omit it for a signed Data Source endpoint or the hosted sandbox. The SDK throws if it sees this in a browser. |
 | `baseURL` | Override the hosted sync endpoint for staging or private deployments. |
 | `persistence` | `memory` by default. Use `indexeddb` for a durable browser cache that survives reloads. |
+| `durableWrites` | Optional crash recovery for unacknowledged agent/worker writes. Independent of the default memory cache; accepts `{ store, namespace? }`. |
 | `transport` | `'websocket'` (default) is the live, stateful client — a persistent socket, a local synced pool, and `onChange` subscriptions. `'http'` returns the **stateless** client for server-side actors (agents, workers, serverless): the same `ablo.<model>` read/write/claim surface, but each call is one HTTP round-trip with no socket. Under `'http'` the return type narrows to `AbloHttpClient`, so stateful-only methods (`get`/`getAll`, `onChange`, `watch`) are compile errors rather than runtime gaps. |
 | `fetch` | Custom fetch implementation for tests or non-standard runtimes. |
 | `defaultHeaders` | Extra headers attached to every HTTP request. |
@@ -109,7 +110,6 @@ await ablo.weatherReports.update({
   readAt: snap.stamp,
   onStale: 'reject',
   idempotencyKey: 'report_stockholm:mark-ready:v1',
-  timeout: 20_000,
 });
 ```
 
@@ -119,7 +119,6 @@ await ablo.weatherReports.update({
 | `readAt` | State cursor the write was based on. |
 | `onStale` | Policy when the target changed after `readAt`. Prefer `reject`. |
 | `idempotencyKey` | Stable key for retry-safe writes. The SDK generates one when omitted. |
-| `timeout` | Maximum time for the write call. |
 
 ## Claimed Behavior
 
@@ -136,7 +135,11 @@ if (active) {
 }
 
 const handle = await ablo.weatherReports.claim({ id: 'report_stockholm' });
-await ablo.weatherReports.update({ id: handle.data.id, data: { status: 'ready' } });
+await ablo.weatherReports.update({
+  id: handle.data.id,
+  data: { status: 'ready' },
+  claim: handle,
+});
 await handle.release();
 ```
 

package/docs/coordination.md

@@ -631,9 +631,8 @@ guarantee can't drift): read the freshest row + its watermark → run your updat
 comes from the watermark, **not** from participant identity — so it's immune to
 the shared-credential clobber footgun and needs no `claim` and no per-agent `rk_`.
 
-Nothing about claims, identity, or conflict codes surfaces. The call either
-returns the reconciled row (a `CommitReceipt` on the HTTP client; the row on the
-WebSocket client) or, at the extreme, throws **one** error:
+Nothing about claims, identity, or conflict codes surfaces. On both transports,
+the call returns the reconciled row or, at the extreme, throws **one** error:
 
 ```ts
 import { AbloContentionError } from '@abloatai/ablo';

package/docs/data-sources.md

@@ -180,14 +180,11 @@ database, schema — the connection string itself is sealed and never echoed bac
 the replication slot position, and the commit log that drives sync. Never your
 rows.
 
-> **Logical-replication runtime status: Preview.** The setup path above
-> (`ablo connect` and `ablo connect --check`) is real and shipping. The
-> server-side component that consumes your WAL and turns it into sync deltas is in
-> **Preview** — it is implemented and tested but **not yet GA / boot-wired in the
-> hosted runtime**. Treat WAL consumption as not-yet-deployed until this note is
-> removed. Maintainers: see
-> [internal/byo-wal-consumer.md](./internal/byo-wal-consumer.md) for the
-> architecture and remaining slices.
+> **Postgres replication status: Preview.** Registration, readiness checks, and
+> the server replication fleet are implemented and boot-wired. Preview describes
+> product rollout and support, not an inactive code path. Maintainers: see
+> [internal/postgres-replication.md](./internal/postgres-replication.md) for the
+> architecture and operational invariants.
 
 ## Next steps