@abloatai/ablo 0.27.0 → 0.28.0

package/dist/transactions/replayValidation.d.ts

@@ -45,6 +45,14 @@ export declare const persistedTransactionSchema: z.ZodObject<{
     }, z.core.$strip>;
     createdAt: z.ZodOptional<z.ZodNumber>;
     batchId: z.ZodOptional<z.ZodString>;
+    commitEnvelope: z.ZodOptional<z.ZodObject<{
+        idempotencyKey: z.core.$ZodBranded<z.ZodString, "IdempotencyKey", "out">;
+        operationIndex: z.ZodNumber;
+        operationCount: z.ZodNumber;
+        sealedAt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    sourceMutationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     writeOptions: z.ZodOptional<z.ZodObject<{
         readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
@@ -76,6 +84,7 @@ export declare function deserializePersistedTransaction(row: unknown): Transacti
  * queue is restored on reconnect.
  */
 export declare const persistedMutationSchema: z.ZodObject<{
+    mutationId: z.ZodOptional<z.ZodString>;
     type: z.ZodEnum<{
         update: "update";
         create: "create";
@@ -85,6 +94,7 @@ export declare const persistedMutationSchema: z.ZodObject<{
     modelData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     modelName: z.ZodString;
     timestamp: z.ZodString;
+    capturedChanges: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     writeOptions: z.ZodOptional<z.ZodObject<{
         readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
@@ -97,3 +107,76 @@ export declare const persistedMutationSchema: z.ZodObject<{
     }, z.core.$loose>>;
 }, z.core.$loose>;
 export type PersistedQueuedMutation = z.infer<typeof persistedMutationSchema>;
+export declare const PENDING_MUTATION_RECORD_PREFIX = "pending-mutation:";
+/**
+ * Stay one hour inside the server's 24-hour idempotency retention window.
+ * A journaled write older than this can no longer be deduplicated by the
+ * server, so restore holds it for review instead of replaying it.
+ */
+export declare const PENDING_MUTATION_REPLAY_WINDOW_MS: number;
+/** Scope-less records written by the first aggregate-journal release. */
+export declare const legacyPendingMutationRecordSchema: z.ZodObject<{
+    storageVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    type: z.ZodLiteral<"pending_mutation">;
+    mutation: z.ZodObject<{
+        type: z.ZodEnum<{
+            update: "update";
+            create: "create";
+            delete: "delete";
+            archive: "archive";
+        }>;
+        modelData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        modelName: z.ZodString;
+        timestamp: z.ZodString;
+        capturedChanges: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        writeOptions: z.ZodOptional<z.ZodObject<{
+            readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                reject: "reject";
+                overwrite: "overwrite";
+                notify: "notify";
+            }>>>;
+            idempotencyKey: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        mutationId: z.ZodString;
+    }, z.core.$loose>;
+    timestamp: z.ZodNumber;
+}, z.core.$strict>;
+export declare const pendingMutationRecordSchema: z.ZodObject<{
+    storageVersion: z.ZodLiteral<2>;
+    scope: z.ZodObject<{
+        organizationId: z.ZodString;
+        participantId: z.ZodString;
+        namespace: z.ZodString;
+    }, z.core.$strict>;
+    id: z.ZodString;
+    type: z.ZodLiteral<"pending_mutation">;
+    mutation: z.ZodObject<{
+        type: z.ZodEnum<{
+            update: "update";
+            create: "create";
+            delete: "delete";
+            archive: "archive";
+        }>;
+        modelData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        modelName: z.ZodString;
+        timestamp: z.ZodString;
+        capturedChanges: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        writeOptions: z.ZodOptional<z.ZodObject<{
+            readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                reject: "reject";
+                overwrite: "overwrite";
+                notify: "notify";
+            }>>>;
+            idempotencyKey: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        mutationId: z.ZodString;
+    }, z.core.$loose>;
+    timestamp: z.ZodNumber;
+}, z.core.$strict>;
+export type PendingMutationRecord = z.infer<typeof pendingMutationRecordSchema>;
+export declare function pendingMutationRecordId(mutationId: string): string;

package/dist/transactions/replayValidation.js

@@ -16,6 +16,7 @@
  */
 import { z } from 'zod';
 import { computePriorityScore, normalizeModelKey } from './commitPayload.js';
+import { commitEnvelopeMemberSchema, commitOutboxScopeSchema, } from './commitEnvelope.js';
 /** The subset of a write's options that is stored with each transaction or queued mutation. */
 const persistedWriteOptionsSchema = z
     .object({
@@ -49,12 +50,20 @@ export const persistedTransactionSchema = z
     }),
     createdAt: z.number().optional(),
     batchId: z.string().optional(),
+    commitEnvelope: commitEnvelopeMemberSchema.optional(),
+    sourceMutationIds: z.array(z.string().min(1)).optional(),
     writeOptions: persistedWriteOptionsSchema.optional(),
     localOnly: z.boolean().optional(),
 })
     .loose();
 /** The `type` values of stored rows that belong to other parts of the client and are not replayable transactions. */
-const NON_REPLAYABLE_TYPES = new Set(['queue', 'awaiting_delta']);
+const NON_REPLAYABLE_TYPES = new Set([
+    'queue',
+    'awaiting_delta',
+    'pending_mutation',
+    'commit_envelope',
+    'http_commit_envelope',
+]);
 /**
  * Reports whether a stored row is one of the non-transaction kinds, so callers
  * skip it instead of treating it as a corrupt transaction.
@@ -91,6 +100,12 @@ export function deserializePersistedTransaction(row) {
         priority: 'normal',
         priorityScore: computePriorityScore(tx.type, tx.modelName),
         ...(tx.batchId !== undefined ? { batchId: tx.batchId } : {}),
+        ...(tx.commitEnvelope !== undefined
+            ? { commitEnvelope: tx.commitEnvelope }
+            : {}),
+        ...(tx.sourceMutationIds !== undefined
+            ? { sourceMutationIds: tx.sourceMutationIds }
+            : {}),
         ...(tx.writeOptions !== undefined ? { writeOptions: tx.writeOptions } : {}),
         ...(tx.localOnly !== undefined ? { localOnly: tx.localOnly } : {}),
     };
@@ -102,10 +117,40 @@ export function deserializePersistedTransaction(row) {
  */
 export const persistedMutationSchema = z
     .object({
+    mutationId: z.string().min(1).optional(),
     type: z.enum(['create', 'update', 'delete', 'archive']),
     modelData: z.record(z.string(), z.unknown()),
     modelName: z.string().min(1),
     timestamp: z.string(),
+    capturedChanges: z.record(z.string(), z.unknown()).optional(),
     writeOptions: persistedWriteOptionsSchema.optional(),
 })
     .loose();
+export const PENDING_MUTATION_RECORD_PREFIX = 'pending-mutation:';
+/**
+ * Stay one hour inside the server's 24-hour idempotency retention window.
+ * A journaled write older than this can no longer be deduplicated by the
+ * server, so restore holds it for review instead of replaying it.
+ */
+export const PENDING_MUTATION_REPLAY_WINDOW_MS = 23 * 60 * 60 * 1000;
+const pendingMutationRecordBaseShape = {
+    id: z.string().startsWith(PENDING_MUTATION_RECORD_PREFIX),
+    type: z.literal('pending_mutation'),
+    mutation: persistedMutationSchema.extend({
+        mutationId: z.string().min(1),
+    }),
+    timestamp: z.number().int().nonnegative(),
+};
+/** Scope-less records written by the first aggregate-journal release. */
+export const legacyPendingMutationRecordSchema = z.strictObject({
+    ...pendingMutationRecordBaseShape,
+    storageVersion: z.literal(1),
+});
+export const pendingMutationRecordSchema = z.strictObject({
+    ...pendingMutationRecordBaseShape,
+    storageVersion: z.literal(2),
+    scope: commitOutboxScopeSchema,
+});
+export function pendingMutationRecordId(mutationId) {
+    return `${PENDING_MUTATION_RECORD_PREFIX}${mutationId}`;
+}

package/dist/wire/bootstrapReason.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+/** Machine-readable reasons a live delta stream must resume via catch-up. */
+export declare const bootstrapReasonSchema: z.ZodEnum<{
+    too_far_behind: "too_far_behind";
+    too_many_deltas: "too_many_deltas";
+    missing_entities: "missing_entities";
+    stream_gap: "stream_gap";
+}>;
+export type BootstrapReason = z.infer<typeof bootstrapReasonSchema>;

package/dist/wire/bootstrapReason.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+/** Machine-readable reasons a live delta stream must resume via catch-up. */
+export const bootstrapReasonSchema = z.enum([
+    'too_far_behind',
+    'too_many_deltas',
+    'missing_entities',
+    'stream_gap',
+]);

package/dist/wire/frames.d.ts

@@ -222,3 +222,239 @@ 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

@@ -16,6 +16,7 @@ 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
@@ -46,3 +47,23 @@ 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

@@ -19,9 +19,11 @@ export { errorEnvelope, statusForType } from './errorEnvelope.js';
 export type { ErrorEnvelope } from './errorEnvelope.js';
 export { listEnvelope } from './listEnvelope.js';
 export type { ListEnvelope } from './listEnvelope.js';
-export { commitOperationSchema, commitPayloadSchema } from './frames.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, } from './frames.js';
+export type { CommitOperation, MutationMessage, CommitMessage, MutationResultMessage, CommitRequestMessage, CommitResultMessage, LegacyCommitOperation, LegacyCommitMessage, LegacyMutationResultMessage, } 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

@@ -17,11 +17,12 @@
  */
 export { errorEnvelope, statusForType } from './errorEnvelope.js';
 export { listEnvelope } from './listEnvelope.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, commitPayloadSchema } from './frames.js';
+export { commitOperationSchema, commitPayloadSchema, commitRequestMessageSchema, commitResultMessageSchema, legacyCommitOperationSchema, legacyCommitPayloadSchema, } 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.

package/docs/api.md

@@ -206,27 +206,27 @@ The SDK is a convenience wrapper over a model-scoped HTTP surface — the same
 noun (`model`) and verbs as `ablo.<model>.…`. Non-JS callers (or curl) use it
 directly. The table below shows the shape with `{model}` as a placeholder; the
 [OpenAPI spec](./openapi.json) expands it into one **typed** path per model
-(`/v1/models/task`, `/v1/models/deck`, …, generated from your schema) so each
+(`/api/v1/models/task`, `/api/v1/models/deck`, …, generated from your schema) so each
 endpoint documents that model's real field contract instead of a generic blob.
 
 | SDK call | HTTP |
 |---|---|
-| `ablo.<model>.create({ data })` | `POST /v1/models/{model}` |
-| `ablo.<model>.list({ where })` | `GET /v1/models/{model}` |
-| `ablo.<model>.retrieve({ id })` | `GET /v1/models/{model}/{id}` |
-| `ablo.<model>.update({ id, data })` | `PATCH /v1/models/{model}/{id}` |
-| `ablo.<model>.delete({ id })` | `DELETE /v1/models/{model}/{id}` |
-| `ablo.<model>.claim({ id })` | `POST /v1/models/{model}/{id}/claim` |
-| (release a claim) | `DELETE /v1/models/{model}/{id}/claim` |
+| `ablo.<model>.create({ data })` | `POST /api/v1/models/{model}` |
+| `ablo.<model>.list({ where })` | `GET /api/v1/models/{model}` |
+| `ablo.<model>.retrieve({ id })` | `GET /api/v1/models/{model}/{id}` |
+| `ablo.<model>.update({ id, data })` | `PATCH /api/v1/models/{model}/{id}` |
+| `ablo.<model>.delete({ id })` | `DELETE /api/v1/models/{model}/{id}` |
+| `ablo.<model>.claim({ id })` | `POST /api/v1/models/{model}/{id}/claim` |
+| (release a claim) | `DELETE /api/v1/models/{model}/{id}/claim` |
 
 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 /v1/models/{model}` is cursor-paginated (`limit`, `order`,
+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 /v1/commits` remains the path for **atomic multi-op** writes (several
+`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
 above are the one-record path. Both run the identical guarded-write engine.
 

package/docs/coordination.md

@@ -465,13 +465,13 @@ Each beat's answer carries two more things:
 
 Works identically on both transports: the realtime client sends a
 `claim_heartbeat` frame; the HTTP client posts
-`POST /v1/models/{model}/{id}/claim/heartbeat` (`{ ttl?, claimId?, details? }`).
+`POST /api/v1/models/{model}/{id}/claim/heartbeat` (`{ ttl?, claimId?, details? }`).
 Over HTTP, a **queued** claim can heartbeat too — it refreshes the waiter's
 slot in the line (a queued slot is TTL'd like a lease) and reports
 `{ status: 'queued', position }`.
 
 A stateless worker holding **many** rows beats them all in one round trip:
-`ablo.claims.heartbeatAll({ ttl: '5m' })` → `POST /v1/claims/heartbeat`, one
+`ablo.claims.heartbeatAll({ ttl: '5m' })` → `POST /api/v1/claims/heartbeat`, one
 entry per extended lease. This is the socketless twin of the realtime
 keepalive, which already renews every held lease on each ping.
 

package/docs/mcp.md

@@ -16,7 +16,7 @@ edits rows → coordination; teaching your IDE assistant the SDK → helper.
 ## Coordination server (`@ablo/mcp`)
 
 The coordination server is the MCP projection of the model-scoped API
-(`/v1/models/...`) — the same surface as `ablo.<model>.create/update/claim` and
+(`/api/v1/models/...`) — the same surface as `ablo.<model>.create/update/claim` and
 the REST routes, rendered as tools. An agent connects with your API key and
 gets one safe loop: **claim → read → commit → release.**
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/ablo",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "description": "The Collaboration Layer For AI Agents",
   "license": "Apache-2.0",
   "type": "module",
@@ -28,6 +28,11 @@
       "import": "./dist/coordination/index.js",
       "default": "./dist/coordination/index.js"
     },
+    "./commit": {
+      "types": "./dist/commit/index.d.ts",
+      "import": "./dist/commit/index.js",
+      "default": "./dist/commit/index.js"
+    },
     "./react": {
       "types": "./dist/react/index.d.ts",
       "import": "./dist/react/index.js",
@@ -207,7 +212,7 @@
     "mobx": "^6.13.7",
     "mobx-react-lite": "^4.0.0",
     "uuid": "^11.1.0",
-    "zod": "^4.0.17"
+    "zod": "^4.1.11"
   },
   "devDependencies": {
     "@ai-sdk/provider": "^3.0.0",