@abloatai/transaction 0.59.0 → 0.59.2

package/dist/wire/inboundFrames.d.ts

@@ -59,27 +59,27 @@ export type InboundFrameContract =
  */
 export declare const WS_INBOUND_FRAMES: {
     readonly ping: {
-        readonly validation: "handler";
-        readonly where: "dispatchWsFrame — ignored, no payload";
+        readonly validation: 'handler';
+        readonly where: 'dispatchWsFrame — ignored, no payload';
     };
     readonly pong: {
-        readonly validation: "handler";
-        readonly where: "dispatchWsFrame — ignored, no payload";
+        readonly validation: 'handler';
+        readonly where: 'dispatchWsFrame — ignored, no payload';
     };
     readonly delta: {
-        readonly validation: "handler";
-        readonly where: "the materialiser parses each delta as it applies it";
+        readonly validation: 'handler';
+        readonly where: 'the materialiser parses each delta as it applies it';
         readonly checkedBy: z.ZodObject<{
             id: z.ZodNumber;
             actionType: z.ZodEnum<{
                 A: "A";
-                I: "I";
-                U: "U";
-                D: "D";
-                V: "V";
                 C: "C";
+                D: "D";
                 G: "G";
+                I: "I";
                 S: "S";
+                U: "U";
+                V: "V";
             }>;
             modelName: z.ZodString;
             modelId: z.ZodString;
@@ -95,16 +95,16 @@ export declare const WS_INBOUND_FRAMES: {
         }, z.core.$strip>;
     };
     readonly sync_response: {
-        readonly validation: "handler";
-        readonly where: "the reactive engine validates it while advancing its resume cursor";
+        readonly validation: 'handler';
+        readonly where: 'the reactive engine validates it while advancing its resume cursor';
     };
     readonly bootstrap_response: {
-        readonly validation: "handler";
-        readonly where: "the reactive engine validates the bootstrap payload as it applies it";
+        readonly validation: 'handler';
+        readonly where: 'the reactive engine validates the bootstrap payload as it applies it';
     };
     readonly mutation_result: {
-        readonly validation: "handler";
-        readonly where: "handleMutationResult — it validates missingIds alongside the payload before this can parse";
+        readonly validation: 'handler';
+        readonly where: 'handleMutationResult — it validates missingIds alongside the payload before this can parse';
         readonly checkedBy: z.ZodDiscriminatedUnion<[z.ZodObject<{
             status: z.ZodLiteral<"queued">;
             statusAt: z.ZodISODateTime;
@@ -122,11 +122,11 @@ export declare const WS_INBOUND_FRAMES: {
                 projectId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                 branchId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                 syncGroups: z.ZodArray<z.ZodString>;
-                operations: z.ZodArray<z.ZodTemplateLiteral<`${string}.update` | `${string}.read` | `${string}.create` | `${string}.delete`>>;
+                operations: z.ZodArray<z.ZodTemplateLiteral<`${string}.create` | `${string}.delete` | `${string}.read` | `${string}.update`>>;
                 participantKind: z.ZodEnum<{
-                    user: "user";
                     agent: "agent";
                     system: "system";
+                    user: "user";
                 }>;
                 participantId: z.ZodString;
                 deliveryPartition: z.ZodDefault<z.ZodNullable<z.ZodObject<{
@@ -138,11 +138,11 @@ export declare const WS_INBOUND_FRAMES: {
             operationResults: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 transactionId: z.ZodString;
                 outcome: z.ZodEnum<{
-                    deleted: "deleted";
-                    created: "created";
-                    updated: "updated";
                     archived: "archived";
+                    created: "created";
+                    deleted: "deleted";
                     unarchived: "unarchived";
+                    updated: "updated";
                 }>;
                 row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             }, z.core.$strict>>>;
@@ -163,11 +163,11 @@ export declare const WS_INBOUND_FRAMES: {
                 projectId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                 branchId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                 syncGroups: z.ZodArray<z.ZodString>;
-                operations: z.ZodArray<z.ZodTemplateLiteral<`${string}.update` | `${string}.read` | `${string}.create` | `${string}.delete`>>;
+                operations: z.ZodArray<z.ZodTemplateLiteral<`${string}.create` | `${string}.delete` | `${string}.read` | `${string}.update`>>;
                 participantKind: z.ZodEnum<{
-                    user: "user";
                     agent: "agent";
                     system: "system";
+                    user: "user";
                 }>;
                 participantId: z.ZodString;
                 deliveryPartition: z.ZodDefault<z.ZodNullable<z.ZodObject<{
@@ -179,23 +179,23 @@ export declare const WS_INBOUND_FRAMES: {
             operationResults: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 transactionId: z.ZodString;
                 outcome: z.ZodEnum<{
-                    deleted: "deleted";
-                    created: "created";
-                    updated: "updated";
                     archived: "archived";
+                    created: "created";
+                    deleted: "deleted";
                     unarchived: "unarchived";
+                    updated: "updated";
                 }>;
                 row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             }, z.core.$strict>>>;
         }, z.core.$strict>], "status">;
     };
     readonly claim_ack: {
-        readonly validation: "handler";
-        readonly where: "handleClaimAck narrows field by field, because a rejection carries a typed capability error it has to re-raise as CapabilityError";
+        readonly validation: 'handler';
+        readonly where: 'handleClaimAck narrows field by field, because a rejection carries a typed capability error it has to re-raise as CapabilityError';
     };
     readonly subscription_ack: {
-        readonly validation: "handler";
-        readonly where: "handleSubscriptionAck";
+        readonly validation: 'handler';
+        readonly where: 'handleSubscriptionAck';
         readonly checkedBy: z.ZodObject<{
             success: z.ZodBoolean;
             syncGroups: z.ZodArray<z.ZodString>;
@@ -208,12 +208,12 @@ export declare const WS_INBOUND_FRAMES: {
         }, z.core.$strip>;
     };
     readonly presence_update: {
-        readonly validation: "schema";
+        readonly validation: 'schema';
         readonly payload: z.ZodObject<{
             kind: z.ZodEnum<{
                 enter: "enter";
-                update: "update";
                 leave: "leave";
+                update: "update";
             }>;
             userId: z.ZodString;
             syncGroups: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -234,9 +234,9 @@ export declare const WS_INBOUND_FRAMES: {
             }, z.core.$strip>>;
             isAgent: z.ZodOptional<z.ZodBoolean>;
             participantKind: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
-                user: "user";
                 agent: "agent";
                 system: "system";
+                user: "user";
             }>>>;
             activeClaims: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 entityType: z.ZodString;
@@ -244,24 +244,24 @@ export declare const WS_INBOUND_FRAMES: {
                 field: z.ZodOptional<z.ZodString>;
                 fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
                 meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                fenceToken: z.ZodOptional<z.ZodNumber>;
+                acquiredAt: z.ZodOptional<z.ZodNumber>;
                 claimId: z.ZodString;
                 description: z.ZodOptional<z.ZodString>;
                 declaredAt: z.ZodNumber;
                 expiresAt: z.ZodNumber;
                 onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                 onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
-                    user: "user";
                     agent: "agent";
                     system: "system";
+                    user: "user";
                 }>>>>;
                 capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                fenceToken: z.ZodOptional<z.ZodNumber>;
-                acquiredAt: z.ZodOptional<z.ZodNumber>;
                 status: z.ZodOptional<z.ZodEnum<{
                     active: "active";
+                    canceled: "canceled";
                     committed: "committed";
                     expired: "expired";
-                    canceled: "canceled";
                 }>>;
                 error: z.ZodOptional<z.ZodObject<{
                     code: z.ZodString;
@@ -281,9 +281,9 @@ export declare const WS_INBOUND_FRAMES: {
                         expiresAt: z.ZodNumber;
                         onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                         onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
-                            user: "user";
                             agent: "agent";
                             system: "system";
+                            user: "user";
                         }>>>>;
                         capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                     }, z.core.$strip>>;
@@ -293,20 +293,20 @@ export declare const WS_INBOUND_FRAMES: {
         }, z.core.$catchall<z.ZodUnknown>>;
     };
     readonly claim_expired: {
-        readonly validation: "schema";
+        readonly validation: 'schema';
         readonly payload: z.ZodObject<{
             claimId: z.ZodString;
         }, z.core.$strip>;
     };
     readonly claim_rejected: {
-        readonly validation: "schema";
+        readonly validation: 'schema';
         readonly payload: z.ZodObject<{
             claimId: z.ZodString;
             reason: z.ZodPreprocess<z.ZodOptional<z.ZodEnum<{
+                capability_denied: "capability_denied";
                 conflict: "conflict";
-                expired: "expired";
                 coordination_unavailable: "coordination_unavailable";
-                capability_denied: "capability_denied";
+                expired: "expired";
                 invalid_target: "invalid_target";
                 preempted: "preempted";
             }>>>;
@@ -319,9 +319,9 @@ export declare const WS_INBOUND_FRAMES: {
             }, z.core.$strip>>;
             heldBy: z.ZodOptional<z.ZodString>;
             heldByKind: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
-                user: "user";
                 agent: "agent";
                 system: "system";
+                user: "user";
             }>>>;
             heldByClaimId: z.ZodOptional<z.ZodString>;
             heldByExpiresAt: z.ZodOptional<z.ZodNumber>;
@@ -337,9 +337,9 @@ export declare const WS_INBOUND_FRAMES: {
                 expiresAt: z.ZodNumber;
                 onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                 onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
-                    user: "user";
                     agent: "agent";
                     system: "system";
+                    user: "user";
                 }>>>>;
                 capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             }, z.core.$strip>>;
@@ -347,7 +347,7 @@ export declare const WS_INBOUND_FRAMES: {
         }, z.core.$strip>;
     };
     readonly claim_acquired: {
-        readonly validation: "schema";
+        readonly validation: 'schema';
         readonly payload: z.ZodObject<{
             claimId: z.ZodString;
             fenceToken: z.ZodOptional<z.ZodNumber>;
@@ -362,7 +362,7 @@ export declare const WS_INBOUND_FRAMES: {
         }, z.core.$strip>;
     };
     readonly claim_queued: {
-        readonly validation: "schema";
+        readonly validation: 'schema';
         readonly payload: z.ZodObject<{
             claimId: z.ZodString;
             target: z.ZodOptional<z.ZodObject<{
@@ -374,9 +374,9 @@ export declare const WS_INBOUND_FRAMES: {
             }, z.core.$strip>>;
             heldBy: z.ZodOptional<z.ZodString>;
             heldByKind: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
-                user: "user";
                 agent: "agent";
                 system: "system";
+                user: "user";
             }>>>;
             heldByClaimId: z.ZodOptional<z.ZodString>;
             heldByExpiresAt: z.ZodOptional<z.ZodNumber>;
@@ -392,26 +392,26 @@ export declare const WS_INBOUND_FRAMES: {
                 expiresAt: z.ZodNumber;
                 onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                 onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
-                    user: "user";
                     agent: "agent";
                     system: "system";
+                    user: "user";
                 }>>>>;
                 capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             }, z.core.$strip>>;
             message: z.ZodOptional<z.ZodString>;
             position: z.ZodNumber;
             reason: z.ZodOptional<z.ZodPreprocess<z.ZodOptional<z.ZodEnum<{
+                capability_denied: "capability_denied";
                 conflict: "conflict";
-                expired: "expired";
                 coordination_unavailable: "coordination_unavailable";
-                capability_denied: "capability_denied";
+                expired: "expired";
                 invalid_target: "invalid_target";
                 preempted: "preempted";
             }>>>>;
         }, z.core.$strip>;
     };
     readonly claim_granted: {
-        readonly validation: "schema";
+        readonly validation: 'schema';
         readonly payload: z.ZodObject<{
             claimId: z.ZodString;
             fenceToken: z.ZodOptional<z.ZodNumber>;
@@ -426,7 +426,7 @@ export declare const WS_INBOUND_FRAMES: {
         }, z.core.$strip>;
     };
     readonly claim_lost: {
-        readonly validation: "schema";
+        readonly validation: 'schema';
         readonly payload: z.ZodObject<{
             claimId: z.ZodString;
             reason: z.ZodEnum<{
@@ -443,7 +443,7 @@ export declare const WS_INBOUND_FRAMES: {
         }, z.core.$strip>;
     };
     readonly claim_queue: {
-        readonly validation: "schema";
+        readonly validation: 'schema';
         readonly payload: z.ZodObject<{
             target: z.ZodObject<{
                 type: z.ZodString;
@@ -463,9 +463,9 @@ export declare const WS_INBOUND_FRAMES: {
                 description: z.ZodDefault<z.ZodString>;
                 heldBy: z.ZodOptional<z.ZodString>;
                 participantKind: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
-                    user: "user";
                     agent: "agent";
                     system: "system";
+                    user: "user";
                 }>>>;
                 position: z.ZodNumber;
                 expiresAt: z.ZodNumber;
@@ -473,13 +473,13 @@ export declare const WS_INBOUND_FRAMES: {
         }, z.core.$strip>;
     };
     readonly claim_heartbeat_ack: {
-        readonly validation: "schema";
+        readonly validation: 'schema';
         readonly payload: z.ZodObject<{
             claimId: z.ZodString;
             status: z.ZodEnum<{
-                queued: "queued";
                 held: "held";
                 lost: "lost";
+                queued: "queued";
             }>;
             expiresAt: z.ZodOptional<z.ZodNumber>;
             position: z.ZodOptional<z.ZodNumber>;

package/dist/wire/inboundFrames.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inboundFrames.d.ts","sourceRoot":"","sources":["../../src/wire/inboundFrames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgBxB;;;;GAIG;AACH,eAAO,MAAM,uBAAuB;;;kCAKZ,CAAC;AACzB,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,0CAA0C;AAC1C,MAAM,MAAM,oBAAoB;AAC9B,wDAAwD;AACtD;IAAE,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,OAAO,CAAA;CAAE;AAChE;;;;;;GAMG;GACD;IACE,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC;CAChC,CAAC;AAEN;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+D2B,CAAC;AAE1D,8CAA8C;AAC9C,MAAM,MAAM,gBAAgB,GAAG,MAAM,OAAO,iBAAiB,CAAC;AAE9D;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG;KAC/B,CAAC,IAAI,gBAAgB,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAC,CAAC,SAAS;QAC7D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC;KAC7C,GACG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GACV,KAAK;CACV,CAAC;AAEF,sEAAsE;AACtE,MAAM,MAAM,wBAAwB,GAAG;KACpC,CAAC,IAAI,gBAAgB,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAC,CAAC,SAAS;QAC7D,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC;KAC/B,GACG,CAAC,GACD,KAAK;CACV,CAAC,gBAAgB,CAAC,CAAC;AAEpB,4DAA4D;AAC5D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,gBAAgB,CAE1E;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,gBAAgB,GACrB,IAAI,IAAI,wBAAwB,CAElC"}
+{"version":3,"file":"inboundFrames.d.ts","sourceRoot":"","sources":["../../src/wire/inboundFrames.ts"],"names":[],"mappings":"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"}

package/dist/wire/listEnvelope.js.map

@@ -1 +1 @@
-{"version":3,"file":"listEnvelope.js","sourceRoot":"","sources":["../../src/wire/listEnvelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,QAAQ,CAAC;AAErC,mEAAmE;AACnE,MAAM,CAAC,MAAM,kBAAkB,GAAG,gBAAgB,CAAC;AAEnD,kFAAkF;AAClF,MAAM,CAAC,MAAM,kBAAkB,GAAsB,CAAC,YAAY,EAAE,kBAAkB,CAAC,CAAC;AAExF;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAI,UAAwB;IAC5D,OAAO,CAAC,CAAC,MAAM,CAAC;QACd,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;QACzB,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,QAAQ,EAAE;QACpC,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE;QACrB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KACnC,CAAC,CAAC;AACL,CAAC;AAMD;;;;;;;;;GASG;AACH,MAAM,UAAU,YAAY,CAC1B,IAAkB,EAClB,OAA0D,EAAE;IAE5D,OAAO;QACL,MAAM,EAAE,MAAM;QACd,IAAI;QACJ,QAAQ,EAAE,IAAI,CAAC,OAAO,IAAI,KAAK;QAC/B,WAAW,EAAE,IAAI,CAAC,UAAU,IAAI,IAAI;KACrC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"listEnvelope.js","sourceRoot":"","sources":["../../src/wire/listEnvelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,QAAQ,CAAC;AAErC,mEAAmE;AACnE,MAAM,CAAC,MAAM,kBAAkB,GAAG,gBAAgB,CAAC;AAEnD,kFAAkF;AAClF,MAAM,CAAC,MAAM,kBAAkB,GAAsB,CAAC,YAAY,EAAE,kBAAkB,CAAC,CAAC;AAExF;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAI,UAAwB;IAC5D,OAAO,CAAC,CAAC,MAAM,CAAC;QACd,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;QACzB,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,QAAQ,EAAE;QACpC,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE;QACrB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KACnC,CAAC,CAAC;AACL,CAAC;AAMD;;;;;;;;;GASG;AACH,MAAM,UAAU,YAAY,CAC1B,IAAkB,EAClB,IAAI,GAAsD,EAAE;IAE5D,OAAO;QACL,MAAM,EAAE,MAAM;QACd,IAAI;QACJ,QAAQ,EAAE,IAAI,CAAC,OAAO,IAAI,KAAK;QAC/B,WAAW,EAAE,IAAI,CAAC,UAAU,IAAI,IAAI;KACrC,CAAC;AACJ,CAAC"}

package/dist/wire/modelResponses.d.ts

@@ -34,15 +34,15 @@ export declare const modelReadResponseSchema: z.ZodObject<{
         id: z.ZodString;
         actor: z.ZodString;
         participantKind: z.ZodPreprocess<z.ZodEnum<{
-            user: "user";
             agent: "agent";
             system: "system";
+            user: "user";
         }>>;
         onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
-            user: "user";
             agent: "agent";
             system: "system";
+            user: "user";
         }>>>>;
         capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         description: z.ZodOptional<z.ZodString>;

package/dist/wire/modelShape.d.ts

@@ -25,23 +25,23 @@ import { z } from 'zod';
  * narrow one of these; they do not add a member.
  */
 export declare const fieldTypeSchema: z.ZodEnum<{
-    string: "string";
-    number: "number";
     boolean: "boolean";
     date: "date";
     enum: "enum";
     json: "json";
+    number: "number";
+    string: "string";
 }>;
 export type FieldType = z.infer<typeof fieldTypeSchema>;
 /** One field of a model, as the schema artifact records it. */
 export declare const fieldMetaSchema: z.ZodObject<{
     type: z.ZodEnum<{
-        string: "string";
-        number: "number";
         boolean: "boolean";
         date: "date";
         enum: "enum";
         json: "json";
+        number: "number";
+        string: "string";
     }>;
     isOptional: z.ZodBoolean;
     isIndexed: z.ZodBoolean;

package/dist/wire/pricing.d.ts

@@ -7,9 +7,9 @@
  */
 import { z } from 'zod';
 export declare const planTierSchema: z.ZodEnum<{
+    enterprise: "enterprise";
     free: "free";
     scale: "scale";
-    enterprise: "enterprise";
 }>;
 export type PlanTier = z.infer<typeof planTierSchema>;
 /**
@@ -24,10 +24,10 @@ export type PlanTier = z.infer<typeof planTierSchema>;
  * the act of connecting.
  */
 export declare const meterEventSchema: z.ZodEnum<{
+    "api.bootstraps": "api.bootstraps";
+    "api.claim_creates": "api.claim_creates";
     "api.commit_ops": "api.commit_ops";
     "api.model_reads": "api.model_reads";
-    "api.claim_creates": "api.claim_creates";
-    "api.bootstraps": "api.bootstraps";
 }>;
 export type MeterEvent = z.infer<typeof meterEventSchema>;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"protocolVersion.d.ts","sourceRoot":"","sources":["../../src/wire/protocolVersion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAEhD,yEAAyE;AACzE,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,cAAe,CAAC;AAExD,MAAM,MAAM,wBAAwB,GAClC,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/C,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,SAAS,GAAG,eAAe,CAAC;AAE7E;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,sBAAsB,GAAG,IAAI,CAO/B;AAED,yEAAyE;AACzE,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,wBAAwB,GAAG,IAAI,CAGjC;AAED,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB,0BAA0B,CAAC"}
+{"version":3,"file":"protocolVersion.d.ts","sourceRoot":"","sources":["../../src/wire/protocolVersion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAEhD,yEAAyE;AACzE,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,YAAI,CAAC,CAAU,CAAC;AAExD,MAAM,MAAM,wBAAwB,GAClC,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/C,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,SAAS,GAAG,eAAe,CAAC;AAE7E;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,sBAAsB,GAAG,IAAI,CAO/B;AAED,yEAAyE;AACzE,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,wBAAwB,GAAG,IAAI,CAGjC;AAED,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB,0BAA0B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/transaction",
-  "version": "0.59.0",
+  "version": "0.59.2",
   "description": "The headless Ablo transaction client and canonical contracts for reads, commits, confirmation, claims, and durable observation.",
   "license": "Apache-2.0",
   "type": "module",
@@ -292,6 +292,7 @@
     "prepack": "npm run build && node ../ablo/scripts/strip-source-condition.mjs",
     "postpack": "node ../ablo/scripts/restore-source-condition.mjs",
     "pack:check": "node ../ablo/scripts/pack-check.mjs",
+    "pack:smoke:websocket": "node scripts/packed-websocket-smoke.mjs",
     "lint:pkg": "publint",
     "test": "vitest run src/client/headless.test.ts && jest",
     "typecheck": "tsc --noEmit && tsc -p typetests/tsconfig.json"

package/src/client/ablo.ts

@@ -23,6 +23,7 @@
 import {
   createAbloHttpClient,
   type AbloHttpClient,
+  type AbloWebSocketClient,
 } from '../transport/http/client.js';
 import type { SchemaRecord } from '../schema/schema.js';
 import type { PublicAbloOptions } from './surface.js';
@@ -34,14 +35,18 @@ import type * as _Http from './resources/httpResources.js';
 /**
  * Create a coordination-layer client in one call.
  *
- * The core carries one transport today — request/response HTTP — so
- * `transport: 'http'` is accepted for symmetry with the reactive package's
- * factory and may be omitted. The duplex transport joins this slot when the
- * socket carve lands (ADR 0016, follow-up 3a).
+ * HTTP is the default. A resident process may select `transport: 'websocket'`
+ * without changing the model, commit, or claim vocabulary.
  */
+export function Ablo<const S extends SchemaRecord>(
+  options: PublicAbloOptions<S> & { readonly transport: 'websocket' },
+): AbloWebSocketClient<S>;
+export function Ablo<const S extends SchemaRecord>(
+  options: PublicAbloOptions<S>,
+): AbloHttpClient<S>;
 export function Ablo<const S extends SchemaRecord>(
   options: PublicAbloOptions<S>,
-): AbloHttpClient<S> {
+): AbloHttpClient<S> | AbloWebSocketClient<S> {
   return createAbloHttpClient(options);
 }
 

package/src/client/surface.ts

@@ -14,7 +14,7 @@ export type PublicAbloOptions<S extends SchemaRecord = SchemaRecord> = Omit<
   AbloHttpClientOptions<S>,
   'onCommitReceipt' | 'transport'
 > & {
-  readonly transport?: 'http';
+  readonly transport?: 'http' | 'websocket';
 };
 
 export const PUBLIC_ABLO_OPTION_KEYS = [
@@ -36,6 +36,13 @@ export const PUBLIC_ABLO_OPTION_KEYS = [
   'commitOutboxScope',
   'transport',
   'timeoutMs',
+  'syncGroups',
+  'collaborationEvents',
+  'cursorStore',
+  'cursorKey',
+  'reconnectDelay',
+  'maxReconnectDelay',
+  'connectTimeoutMs',
 ] as const;
 
 type Equal<A, B> =

package/src/commit/recordRuntime.ts

@@ -21,8 +21,9 @@ interface WebSocketCommitObservation {
   readonly operations: readonly {
     readonly type: string;
     readonly model: string;
-    readonly id: string;
-    readonly input?: Record<string, unknown>;
+    readonly id: string | null;
+    readonly input?: Record<string, unknown> | null;
+    readonly where?: Record<string, unknown> | null;
     readonly claimId?: string | null;
     readonly readAt?: number | null;
     readonly fenceToken?: number | null;
@@ -149,6 +150,7 @@ export function recordWebSocketCommitReceipt(
     model: operation.model,
     id: operation.id,
     ...(operation.input ? { data: operation.input } : {}),
+    ...(operation.where ? { where: operation.where } : {}),
     ...(operation.claimId ? { claimId: operation.claimId } : {}),
     ...(typeof operation.readAt === 'number' ? { readAt: operation.readAt } : {}),
     ...(typeof operation.fenceToken === 'number'

package/src/errorCodes.ts

@@ -39,7 +39,7 @@ import { z } from 'zod';
  * error documentation and returned on the `Ablo-Version` response header, so a
  * consumer can detect when its expected contract has drifted from the server's.
  */
-export const ERROR_CONTRACT_VERSION = '2026-08-15';
+export const ERROR_CONTRACT_VERSION = '2026-08-30';
 
 /** A coarse grouping of error codes, used to organize metrics and documentation. */
 export type ErrorCategory =
@@ -1238,6 +1238,10 @@ export const ERROR_CODES = {
     false,
     'The offline grace window expired before this commit could be sent, so it was not applied. Re-apply the change once the connection returns.'
   ),
+  observation_buffer_overflow: client(
+    'transport',
+    'A WebSocket observer fell behind its bounded in-memory backlog. Restart observation to replay from the last durable checkpoint.'
+  ),
   queue_too_deep: wire(
     'transport',
     503,

package/src/errors.ts

@@ -871,6 +871,19 @@ function detailsFromBody(body: unknown): Record<string, unknown> | undefined {
   return Object.keys(rest).length > 0 ? rest : undefined;
 }
 
+function detailsFromNestedError(
+  nested: NestedErrorShape | undefined,
+): Record<string, unknown> | undefined {
+  if (!nested) return undefined;
+  const extras = detailsFromBody(nested) ?? {};
+  delete extras.details;
+  const direct = typeof nested.details === 'object' && nested.details !== null
+    ? nested.details as Record<string, unknown>
+    : {};
+  const merged = { ...extras, ...direct };
+  return Object.keys(merged).length > 0 ? merged : undefined;
+}
+
 export function translateHttpError(
   status: number,
   body: unknown,
@@ -911,6 +924,10 @@ export function translateHttpError(
     typeof body === 'object' && body !== null && 'request_id' in body
       ? (body as { request_id?: unknown }).request_id
       : undefined;
+  const details = {
+    ...(detailsFromBody(body) ?? {}),
+    ...(detailsFromNestedError(nested) ?? {}),
+  };
 
   return errorFromWire(message, {
     code,
@@ -918,7 +935,7 @@ export function translateHttpError(
     requestId: requestId ?? (typeof bodyRequestId === 'string' ? bodyRequestId : undefined),
     requiredCapability,
     claims,
-    details: detailsFromBody(body),
+    details: Object.keys(details).length > 0 ? details : undefined,
   });
 }
 

package/src/index.ts

@@ -31,6 +31,7 @@ export { Ablo } from './client/ablo.js';
 export type {
   AbloHttpClient,
   AbloHttpClientOptions,
+  AbloWebSocketClient,
   CapturedRow,
   HttpModelClient,
   HttpModelMutationParams,