@abloatai/transaction 0.37.0

package/dist/wire/feedEvent.d.ts

@@ -0,0 +1,264 @@
+/**
+ * What `GET /v1/logs` returns: one envelope, two arms.
+ *
+ * The feed answers two questions that a caller without a socket cannot
+ * otherwise ask — "what changed" and "who is working on what" — and it answers
+ * them through one endpoint, one envelope, and one cursor grammar rather than
+ * growing a second feed with its own pagination dialect beside the first.
+ *
+ * The arms stay separately sequenced. A claim is a lease, not a settled fact,
+ * and putting one into the log that clients materialize rows from — and that
+ * WAL-echo promotion and compaction operate over — would make a claim-churn
+ * storm indistinguishable from committed change. They share a reading, not a
+ * sequence; {@link FeedCursor} is what carries both positions.
+ */
+import { z } from 'zod';
+import { type LogEvent } from './accountResponses.js';
+import { type ClaimEvent } from './claimEvent.js';
+import { type ListEnvelope } from './listEnvelope.js';
+/**
+ * One entry, from either source. Discriminated on `object`, so a consumer
+ * reading an arm it does not know still parses the page and can skip the entry
+ * — which is what lets the claim arm be added to a running feed at all.
+ */
+export declare const feedEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    object: z.ZodLiteral<"log_event">;
+    id: z.ZodNumber;
+    at: z.ZodString;
+    model: z.ZodString;
+    op: z.ZodEnum<{
+        update: "update";
+        create: "create";
+        delete: "delete";
+        archive: "archive";
+        revive: "revive";
+        visible: "visible";
+        group_added: "group_added";
+        group_removed: "group_removed";
+    }>;
+    recordId: z.ZodString;
+    actor: z.ZodNullable<z.ZodString>;
+    delta: z.ZodOptional<z.ZodObject<{
+        id: z.ZodNumber;
+        data: z.ZodNullable<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
+        actionType: z.ZodEnum<{
+            I: "I";
+            U: "U";
+            D: "D";
+            A: "A";
+            V: "V";
+            C: "C";
+            G: "G";
+            S: "S";
+        }>;
+        modelName: z.ZodString;
+        modelId: z.ZodString;
+        previousData: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>>;
+        createdAt: z.ZodString;
+        actor: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>>>;
+        onBehalfOf: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>>>;
+        capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        confirmationState: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            auto: "auto";
+            previewed: "previewed";
+            approved: "approved";
+            required_human_approval: "required_human_approval";
+            auto_historical: "auto_historical";
+        }>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodReadonly<z.ZodObject<{
+    target: z.ZodReadonly<z.ZodObject<{
+        model: z.ZodString;
+        id: z.ZodString;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    description: z.ZodString;
+    expiresAt: z.ZodNumber;
+    onBehalfOfId: z.ZodNullable<z.ZodString>;
+    onBehalfOfKind: z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        system: "system";
+    }>>>;
+    capabilityId: z.ZodNullable<z.ZodString>;
+    fenceToken: z.ZodOptional<z.ZodNumber>;
+    position: z.ZodOptional<z.ZodNumber>;
+    participantKind: z.ZodPreprocess<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        system: "system";
+    }>>;
+    actor: z.ZodString;
+    object: z.ZodLiteral<"claim_event">;
+    seq: z.ZodNumber;
+    at: z.ZodString;
+    claimId: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        committed: "committed";
+        expired: "expired";
+        canceled: "canceled";
+        queued: "queued";
+    }>;
+}, z.core.$strip>>], "object">;
+export type FeedEvent = LogEvent | ClaimEvent;
+/** `GET /v1/logs` — the canonical list envelope over the feed. */
+export declare const logListResponseSchema: z.ZodObject<{
+    object: z.ZodLiteral<"list">;
+    data: z.ZodReadonly<z.ZodArray<z.ZodType<{
+        object: "log_event";
+        id: number;
+        at: string;
+        model: string;
+        op: "update" | "create" | "delete" | "archive" | "revive" | "visible" | "group_added" | "group_removed";
+        recordId: string;
+        actor: string | null;
+        delta?: {
+            id: number;
+            data: string | Record<string, unknown> | null;
+            actionType: "I" | "U" | "D" | "A" | "V" | "C" | "G" | "S";
+            modelName: string;
+            modelId: string;
+            createdAt: string;
+            previousData?: string | Record<string, unknown> | null | undefined;
+            actor?: {
+                kind: "user" | "agent" | "system";
+                id: string;
+            } | null | undefined;
+            onBehalfOf?: {
+                kind: "user" | "agent" | "system";
+                id: string;
+            } | null | undefined;
+            capabilityId?: string | null | undefined;
+            confirmationState?: "auto" | "previewed" | "approved" | "required_human_approval" | "auto_historical" | null | undefined;
+        } | undefined;
+    } | Readonly<{
+        target: Readonly<{
+            model: string;
+            id: string;
+            field?: string | undefined;
+            fields?: readonly string[] | undefined;
+            meta?: Record<string, unknown> | undefined;
+        }>;
+        description: string;
+        expiresAt: number;
+        onBehalfOfId: string | null;
+        onBehalfOfKind: "user" | "agent" | "system" | null;
+        capabilityId: string | null;
+        participantKind: "user" | "agent" | "system";
+        actor: string;
+        object: "claim_event";
+        seq: number;
+        at: string;
+        claimId: string;
+        status: "active" | "committed" | "expired" | "canceled" | "queued";
+        fenceToken?: number | undefined;
+        position?: number | undefined;
+    }>, unknown, z.core.$ZodTypeInternals<{
+        object: "log_event";
+        id: number;
+        at: string;
+        model: string;
+        op: "update" | "create" | "delete" | "archive" | "revive" | "visible" | "group_added" | "group_removed";
+        recordId: string;
+        actor: string | null;
+        delta?: {
+            id: number;
+            data: string | Record<string, unknown> | null;
+            actionType: "I" | "U" | "D" | "A" | "V" | "C" | "G" | "S";
+            modelName: string;
+            modelId: string;
+            createdAt: string;
+            previousData?: string | Record<string, unknown> | null | undefined;
+            actor?: {
+                kind: "user" | "agent" | "system";
+                id: string;
+            } | null | undefined;
+            onBehalfOf?: {
+                kind: "user" | "agent" | "system";
+                id: string;
+            } | null | undefined;
+            capabilityId?: string | null | undefined;
+            confirmationState?: "auto" | "previewed" | "approved" | "required_human_approval" | "auto_historical" | null | undefined;
+        } | undefined;
+    } | Readonly<{
+        target: Readonly<{
+            model: string;
+            id: string;
+            field?: string | undefined;
+            fields?: readonly string[] | undefined;
+            meta?: Record<string, unknown> | undefined;
+        }>;
+        description: string;
+        expiresAt: number;
+        onBehalfOfId: string | null;
+        onBehalfOfKind: "user" | "agent" | "system" | null;
+        capabilityId: string | null;
+        participantKind: "user" | "agent" | "system";
+        actor: string;
+        object: "claim_event";
+        seq: number;
+        at: string;
+        claimId: string;
+        status: "active" | "committed" | "expired" | "canceled" | "queued";
+        fenceToken?: number | undefined;
+        position?: number | undefined;
+    }>, unknown>>>>;
+    has_more: z.ZodBoolean;
+    next_cursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type LogListResponse = ListEnvelope<FeedEvent>;
+/**
+ * The query string on `GET /v1/logs`.
+ *
+ * Values arrive as strings, so this describes the wire spelling rather than the
+ * parsed result — the same reason {@link listQuerySchema} does.
+ *
+ * Scope is NOT here and never will be: the plane, the organization and the sync
+ * groups all come off the credential. A caller cannot widen what it sees by
+ * asking, which is what makes this feed safe to hand an agent.
+ */
+export declare const logQuerySchema: z.ZodObject<{
+    after: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    op: z.ZodOptional<z.ZodEnum<{
+        update: "update";
+        create: "create";
+        delete: "delete";
+        archive: "archive";
+        revive: "revive";
+        visible: "visible";
+        group_added: "group_added";
+        group_removed: "group_removed";
+    }>>;
+    since: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type LogQuery = z.infer<typeof logQuerySchema>;
+/**
+ * The claim arm has no producer yet: claim transitions are broadcast today and
+ * recorded nowhere, so there is no sequence to read `seq` from. Until that log
+ * exists the route emits only `log_event`s, and there is deliberately NO
+ * request parameter for selecting arms — a knob that cannot be honoured is how
+ * a contract comes to describe a server that does not exist.
+ *
+ * What is here is the definition the producer will fill: the union parses
+ * today's pages unchanged, and the cursor already carries the second position.
+ */
+//# sourceMappingURL=feedEvent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feedEvent.d.ts","sourceRoot":"","sources":["../../src/wire/feedEvent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAA+B,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACnF,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACpE,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAG1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE9C,kEAAkE;AAClE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsC,CAAC;AACzE,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;AAEtD;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;iBAezB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD;;;;;;;;;GASG"}

package/dist/wire/feedEvent.js

@@ -0,0 +1,66 @@
+/**
+ * What `GET /v1/logs` returns: one envelope, two arms.
+ *
+ * The feed answers two questions that a caller without a socket cannot
+ * otherwise ask — "what changed" and "who is working on what" — and it answers
+ * them through one endpoint, one envelope, and one cursor grammar rather than
+ * growing a second feed with its own pagination dialect beside the first.
+ *
+ * The arms stay separately sequenced. A claim is a lease, not a settled fact,
+ * and putting one into the log that clients materialize rows from — and that
+ * WAL-echo promotion and compaction operate over — would make a claim-churn
+ * storm indistinguishable from committed change. They share a reading, not a
+ * sequence; {@link FeedCursor} is what carries both positions.
+ */
+import { z } from 'zod';
+import { logEventSchema, logOpSchema } from './accountResponses.js';
+import { claimEventSchema } from './claimEvent.js';
+import { listEnvelopeSchema } from './listEnvelope.js';
+/**
+ * One entry, from either source. Discriminated on `object`, so a consumer
+ * reading an arm it does not know still parses the page and can skip the entry
+ * — which is what lets the claim arm be added to a running feed at all.
+ */
+export const feedEventSchema = z.discriminatedUnion('object', [
+    logEventSchema,
+    claimEventSchema,
+]);
+/** `GET /v1/logs` — the canonical list envelope over the feed. */
+export const logListResponseSchema = listEnvelopeSchema(feedEventSchema);
+/**
+ * The query string on `GET /v1/logs`.
+ *
+ * Values arrive as strings, so this describes the wire spelling rather than the
+ * parsed result — the same reason {@link listQuerySchema} does.
+ *
+ * Scope is NOT here and never will be: the plane, the organization and the sync
+ * groups all come off the credential. A caller cannot widen what it sees by
+ * asking, which is what makes this feed safe to hand an agent.
+ */
+export const logQuerySchema = z.object({
+    /**
+     * The `next_cursor` from the previous page, copied back unchanged. Omit it to
+     * start from the most recent entries — this is a tail, so the first page is
+     * the end of the log and `after` walks forward from there.
+     */
+    after: z.string().optional(),
+    /** Entries per page. Clamped server-side; the default is a short tail. */
+    limit: z.string().optional(),
+    /** Only this model's entries. */
+    model: z.string().optional(),
+    /** Only this kind of change. */
+    op: logOpSchema.optional(),
+    /** Only entries at or after this ISO 8601 timestamp. */
+    since: z.string().optional(),
+});
+/**
+ * The claim arm has no producer yet: claim transitions are broadcast today and
+ * recorded nowhere, so there is no sequence to read `seq` from. Until that log
+ * exists the route emits only `log_event`s, and there is deliberately NO
+ * request parameter for selecting arms — a knob that cannot be honoured is how
+ * a contract comes to describe a server that does not exist.
+ *
+ * What is here is the definition the producer will fill: the union parses
+ * today's pages unchanged, and the cursor already carries the second position.
+ */
+//# sourceMappingURL=feedEvent.js.map

package/dist/wire/feedEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedEvent.js","sourceRoot":"","sources":["../../src/wire/feedEvent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,cAAc,EAAE,WAAW,EAAiB,MAAM,uBAAuB,CAAC;AACnF,OAAO,EAAE,gBAAgB,EAAmB,MAAM,iBAAiB,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAqB,MAAM,mBAAmB,CAAC;AAE1E;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,kBAAkB,CAAC,QAAQ,EAAE;IAC5D,cAAc;IACd,gBAAgB;CACjB,CAAC,CAAC;AAGH,kEAAkE;AAClE,MAAM,CAAC,MAAM,qBAAqB,GAAG,kBAAkB,CAAC,eAAe,CAAC,CAAC;AAGzE;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC;IACrC;;;;OAIG;IACH,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC5B,0EAA0E;IAC1E,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC5B,iCAAiC;IACjC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC5B,gCAAgC;IAChC,EAAE,EAAE,WAAW,CAAC,QAAQ,EAAE;IAC1B,wDAAwD;IACxD,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC7B,CAAC,CAAC;AAGH;;;;;;;;;GASG"}

package/dist/wire/frames.d.ts

@@ -0,0 +1,195 @@
+/**
+ * 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 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. Zod schemas are the definition site and every TypeScript
+ * shape is inferred from them. Changing any schema in this file changes the
+ * wire contract and requires the client and server to update together.
+ */
+import { z } from 'zod';
+import type { MutationResultMessageWire } from './commit.js';
+/**
+ * A single operation within a commit batch and its authoritative runtime
+ * validator. Each operation is the smallest unit the server applies atomically
+ * — one create, update, delete, archive, or unarchive against one model row.
+ * Both commit transports — the WebSocket `commit` frame and the HTTP
+ * `/v1/commits` endpoint — run this check
+ * on every operation before it is applied, so a malformed operation is rejected
+ * at the edge. It builds on the shared coordination schema, widening `bypass`
+ * to also accept `null`. The TypeScript type is inferred from this schema so
+ * the runtime and compile-time contracts have one definition site.
+ */
+export declare const wireCommitOperationSchema: 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>>;
+    fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    bypass: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strip>;
+export type WireCommitOperation = z.infer<typeof wireCommitOperationSchema>;
+/**
+ * @deprecated Renamed to {@link WireCommitOperation} — coordination/schema owns
+ * the base `CommitOperation`; this is the wire-extended form, and the two are
+ * different types that shared one name. Removed in 0.36.0.
+ */
+export type CommitOperation = WireCommitOperation;
+/** @deprecated Renamed to {@link wireCommitOperationSchema}. Removed in 0.36.0. */
+export declare const commitOperationSchema: 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>>;
+    fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    bypass: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strip>;
+/**
+ * The authoritative payload schema for a client-to-server commit frame. It
+ * checks every field the server acts on — `operations`, `clientTxId`, and
+ * `reads` — validating each operation with {@link wireCommitOperationSchema} and
+ * each premise entry with the shared {@link readDependencySchema}.
+ */
+export declare const commitPayloadSchema: 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>>;
+        fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        bypass: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strip>>;
+    clientTxId: 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.ZodReadonly<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>]>>>>;
+    track: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        model: z.ZodString;
+        readAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        group: z.ZodString;
+        readAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>>>>;
+}, z.core.$strip>;
+/** A client-to-server frame that asks the server to commit a batch atomically. */
+export declare const commitMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"commit">;
+    payload: 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>>;
+            fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            bypass: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$strip>>;
+        clientTxId: 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.ZodReadonly<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>]>>>>;
+        track: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            id: z.ZodString;
+            model: z.ZodString;
+            readAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            group: z.ZodString;
+            readAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>]>>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CommitMessage = z.infer<typeof commitMessageSchema>;
+/**
+ * The server's acknowledgement of a {@link CommitMessage}. Runtime shape and
+ * TypeScript type are both owned by `wire/commit.ts`; HTTP, WebSocket, and
+ * cached replay no longer maintain parallel receipt declarations.
+ */
+export type MutationResultMessage = MutationResultMessageWire;
+//# sourceMappingURL=frames.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frames.d.ts","sourceRoot":"","sources":["../../src/wire/frames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAI7D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;iBAEpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,mBAAmB,CAAC;AAClD,mFAAmF;AACnF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;iBAA4B,CAAC;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK9B,CAAC;AAEH,kFAAkF;AAClF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAIhE;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,yBAAyB,CAAC"}

package/dist/wire/frames.js

@@ -0,0 +1,51 @@
+/**
+ * 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 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. Zod schemas are the definition site and every TypeScript
+ * shape is inferred from them. Changing any schema in this file changes the
+ * wire contract and requires the client and server to update together.
+ */
+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, trackDependencySchema, } from '../coordination/schema.js';
+// ── Client → Server ────────────────────────────────────────────────────────
+/**
+ * A single operation within a commit batch and its authoritative runtime
+ * validator. Each operation is the smallest unit the server applies atomically
+ * — one create, update, delete, archive, or unarchive against one model row.
+ * Both commit transports — the WebSocket `commit` frame and the HTTP
+ * `/v1/commits` endpoint — run this check
+ * on every operation before it is applied, so a malformed operation is rejected
+ * at the edge. It builds on the shared coordination schema, widening `bypass`
+ * to also accept `null`. The TypeScript type is inferred from this schema so
+ * the runtime and compile-time contracts have one definition site.
+ */
+export const wireCommitOperationSchema = coordinationCommitOperationSchema.extend({
+    bypass: z.boolean().nullish(),
+});
+/** @deprecated Renamed to {@link wireCommitOperationSchema}. Removed in 0.36.0. */
+export const commitOperationSchema = wireCommitOperationSchema;
+/**
+ * The authoritative payload schema for a client-to-server commit frame. It
+ * checks every field the server acts on — `operations`, `clientTxId`, and
+ * `reads` — validating each operation with {@link wireCommitOperationSchema} and
+ * each premise entry with the shared {@link readDependencySchema}.
+ */
+export const commitPayloadSchema = z.object({
+    operations: z.array(wireCommitOperationSchema),
+    clientTxId: z.string(),
+    reads: z.array(readDependencySchema).nullish(),
+    track: z.array(trackDependencySchema).nullish(),
+});
+/** A client-to-server frame that asks the server to commit a batch atomically. */
+export const commitMessageSchema = z.object({
+    type: z.literal('commit'),
+    payload: commitPayloadSchema,
+});
+//# sourceMappingURL=frames.js.map

package/dist/wire/frames.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frames.js","sourceRoot":"","sources":["../../src/wire/frames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,4EAA4E;AAC5E,yEAAyE;AACzE,OAAO,EACL,qBAAqB,IAAI,iCAAiC,EAC1D,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,2BAA2B,CAAC;AAGnC,8EAA8E;AAE9E;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,iCAAiC,CAAC,MAAM,CAAC;IAChF,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE;CAC9B,CAAC,CAAC;AASH,mFAAmF;AACnF,MAAM,CAAC,MAAM,qBAAqB,GAAG,yBAAyB,CAAC;AAE/D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,yBAAyB,CAAC;IAC9C,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,OAAO,EAAE;IAC9C,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC,OAAO,EAAE;CAChD,CAAC,CAAC;AAEH,kFAAkF;AAClF,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;IACzB,OAAO,EAAE,mBAAmB;CAC7B,CAAC,CAAC"}