@abloatai/ablo 0.29.3 → 0.30.0

package/dist/wire/commit.d.ts

@@ -0,0 +1,671 @@
+/**
+ * Canonical runtime contracts for commit settlement.
+ *
+ * A commit crosses several boundaries during its lifetime: the server's
+ * execution cache, the HTTP/WS receipt, and the client's acknowledgement
+ * tracker. Those boundaries intentionally have different envelopes, but they
+ * all compose the same settlement vocabulary from this module:
+ *
+ *   - `confirmed` — the authoritative change is visible at a sync watermark.
+ *   - `queued` — a connected source durably accepted the write and only its
+ *     correlated authoritative source delta (WAL for direct, endpoint event
+ *     for endpoint-only), identified by `correlationId`, may promote it.
+ *
+ * Keeping the variants discriminated here makes an impossible receipt (most
+ * importantly, `queued` without a correlation) unrepresentable at every
+ * untrusted boundary without collapsing the distinct lifecycle envelopes into
+ * one giant object.
+ */
+import { z } from 'zod';
+import type { ErrorCode } from '../errorCodes.js';
+import type { RequiredCapability } from '../errors.js';
+/** Matches the permanent source/idempotency-key ceiling. */
+export declare const COMMIT_CORRELATION_ID_MAX_LENGTH = 255;
+/** Opaque server-authored identity shared by a queued receipt and its authoritative source delta. */
+export declare const correlationIdSchema: z.ZodString;
+export type CorrelationId = z.infer<typeof correlationIdSchema>;
+export declare const commitStatusSchema: z.ZodEnum<{
+    queued: "queued";
+    confirmed: "confirmed";
+}>;
+export type CommitStatus = z.infer<typeof commitStatusSchema>;
+/** The one settlement discriminant shared by every commit boundary. */
+export declare const commitSettlementSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"queued">;
+    correlationId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"confirmed">;
+    correlationId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "status">;
+export type CommitSettlement = z.infer<typeof commitSettlementSchema>;
+/**
+ * Successful HTTP/WS receipt. This schema is deliberately strict about the
+ * settlement discriminant. Zod's default object behavior strips additive
+ * fields, which is forward compatible without allowing server-internal
+ * recovery evidence to leak through a parsed wire receipt.
+ */
+export declare const commitReceiptSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"queued">;
+    correlationId: z.ZodString;
+    object: z.ZodLiteral<"commit_receipt">;
+    id: z.ZodOptional<z.ZodString>;
+    clientTxId: z.ZodString;
+    serverTxId: z.ZodString;
+    success: z.ZodLiteral<true>;
+    lastSyncId: z.ZodNumber;
+    ops: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        object: z.ZodOptional<z.ZodLiteral<"stale_notification">>;
+        model: z.ZodString;
+        id: z.ZodString;
+        readAt: z.ZodNumber;
+        observedSyncId: z.ZodNumber;
+        conflictingFields: z.ZodArray<z.ZodString>;
+        currentValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        writtenBy: z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"confirmed">;
+    correlationId: z.ZodOptional<z.ZodString>;
+    object: z.ZodLiteral<"commit_receipt">;
+    id: z.ZodOptional<z.ZodString>;
+    clientTxId: z.ZodString;
+    serverTxId: z.ZodString;
+    success: z.ZodLiteral<true>;
+    lastSyncId: z.ZodNumber;
+    ops: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        object: z.ZodOptional<z.ZodLiteral<"stale_notification">>;
+        model: z.ZodString;
+        id: z.ZodString;
+        readAt: z.ZodNumber;
+        observedSyncId: z.ZodNumber;
+        conflictingFields: z.ZodArray<z.ZodString>;
+        currentValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        writtenBy: z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>], "status">;
+export type CommitReceiptWire = z.infer<typeof commitReceiptSchema>;
+/**
+ * Compatibility decoder for pre-contract WebSocket acknowledgements. It
+ * supplies fields old servers omitted and normalizes their string sync ids,
+ * then hands the result to the exact same canonical receipt schema. It never
+ * invents a source correlation: an old/malformed queued receipt still fails
+ * closed.
+ */
+export declare const legacyCompatibleCommitReceiptSchema: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"queued">;
+    correlationId: z.ZodString;
+    object: z.ZodLiteral<"commit_receipt">;
+    id: z.ZodOptional<z.ZodString>;
+    clientTxId: z.ZodString;
+    serverTxId: z.ZodString;
+    success: z.ZodLiteral<true>;
+    lastSyncId: z.ZodNumber;
+    ops: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        object: z.ZodOptional<z.ZodLiteral<"stale_notification">>;
+        model: z.ZodString;
+        id: z.ZodString;
+        readAt: z.ZodNumber;
+        observedSyncId: z.ZodNumber;
+        conflictingFields: z.ZodArray<z.ZodString>;
+        currentValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        writtenBy: z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"confirmed">;
+    correlationId: z.ZodOptional<z.ZodString>;
+    object: z.ZodLiteral<"commit_receipt">;
+    id: z.ZodOptional<z.ZodString>;
+    clientTxId: z.ZodString;
+    serverTxId: z.ZodString;
+    success: z.ZodLiteral<true>;
+    lastSyncId: z.ZodNumber;
+    ops: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        object: z.ZodOptional<z.ZodLiteral<"stale_notification">>;
+        model: z.ZodString;
+        id: z.ZodString;
+        readAt: z.ZodNumber;
+        observedSyncId: z.ZodNumber;
+        conflictingFields: z.ZodArray<z.ZodString>;
+        currentValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        writtenBy: z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>], "status">>;
+/** The failure arm is separate: queued/confirmed always imply `success:true`. */
+export declare const rejectedCommitReceiptSchema: z.ZodObject<{
+    object: z.ZodLiteral<"commit_receipt">;
+    clientTxId: z.ZodString;
+    serverTxId: z.ZodString;
+    success: z.ZodLiteral<false>;
+    status: z.ZodLiteral<"rejected">;
+    lastSyncId: z.ZodOptional<z.ZodNumber>;
+    ops: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodObject<{
+        code: z.ZodCustom<ErrorCode, ErrorCode>;
+        message: z.ZodString;
+        field: z.ZodOptional<z.ZodString>;
+        requiredCapability: z.ZodOptional<z.ZodCustom<RequiredCapability, RequiredCapability>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RejectedCommitReceiptWire = z.infer<typeof rejectedCommitReceiptSchema>;
+export declare const mutationResultPayloadSchema: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"queued">;
+    correlationId: z.ZodString;
+    object: z.ZodLiteral<"commit_receipt">;
+    id: z.ZodOptional<z.ZodString>;
+    clientTxId: z.ZodString;
+    serverTxId: z.ZodString;
+    success: z.ZodLiteral<true>;
+    lastSyncId: z.ZodNumber;
+    ops: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        object: z.ZodOptional<z.ZodLiteral<"stale_notification">>;
+        model: z.ZodString;
+        id: z.ZodString;
+        readAt: z.ZodNumber;
+        observedSyncId: z.ZodNumber;
+        conflictingFields: z.ZodArray<z.ZodString>;
+        currentValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        writtenBy: z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"confirmed">;
+    correlationId: z.ZodOptional<z.ZodString>;
+    object: z.ZodLiteral<"commit_receipt">;
+    id: z.ZodOptional<z.ZodString>;
+    clientTxId: z.ZodString;
+    serverTxId: z.ZodString;
+    success: z.ZodLiteral<true>;
+    lastSyncId: z.ZodNumber;
+    ops: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        object: z.ZodOptional<z.ZodLiteral<"stale_notification">>;
+        model: z.ZodString;
+        id: z.ZodString;
+        readAt: z.ZodNumber;
+        observedSyncId: z.ZodNumber;
+        conflictingFields: z.ZodArray<z.ZodString>;
+        currentValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        writtenBy: z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>], "status">, z.ZodObject<{
+    object: z.ZodLiteral<"commit_receipt">;
+    clientTxId: z.ZodString;
+    serverTxId: z.ZodString;
+    success: z.ZodLiteral<false>;
+    status: z.ZodLiteral<"rejected">;
+    lastSyncId: z.ZodOptional<z.ZodNumber>;
+    ops: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodObject<{
+        code: z.ZodCustom<ErrorCode, ErrorCode>;
+        message: z.ZodString;
+        field: z.ZodOptional<z.ZodString>;
+        requiredCapability: z.ZodOptional<z.ZodCustom<RequiredCapability, RequiredCapability>>;
+    }, z.core.$strip>;
+}, z.core.$strip>]>;
+export type MutationResultPayload = z.infer<typeof mutationResultPayloadSchema>;
+export declare const mutationResultMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"mutation_result">;
+    payload: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"queued">;
+        correlationId: z.ZodString;
+        object: z.ZodLiteral<"commit_receipt">;
+        id: z.ZodOptional<z.ZodString>;
+        clientTxId: z.ZodString;
+        serverTxId: z.ZodString;
+        success: z.ZodLiteral<true>;
+        lastSyncId: z.ZodNumber;
+        ops: z.ZodNumber;
+        notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            object: z.ZodOptional<z.ZodLiteral<"stale_notification">>;
+            model: z.ZodString;
+            id: z.ZodString;
+            readAt: z.ZodNumber;
+            observedSyncId: z.ZodNumber;
+            conflictingFields: z.ZodArray<z.ZodString>;
+            currentValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            writtenBy: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    user: "user";
+                    agent: "agent";
+                    system: "system";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strip>;
+            group: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"confirmed">;
+        correlationId: z.ZodOptional<z.ZodString>;
+        object: z.ZodLiteral<"commit_receipt">;
+        id: z.ZodOptional<z.ZodString>;
+        clientTxId: z.ZodString;
+        serverTxId: z.ZodString;
+        success: z.ZodLiteral<true>;
+        lastSyncId: z.ZodNumber;
+        ops: z.ZodNumber;
+        notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            object: z.ZodOptional<z.ZodLiteral<"stale_notification">>;
+            model: z.ZodString;
+            id: z.ZodString;
+            readAt: z.ZodNumber;
+            observedSyncId: z.ZodNumber;
+            conflictingFields: z.ZodArray<z.ZodString>;
+            currentValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            writtenBy: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    user: "user";
+                    agent: "agent";
+                    system: "system";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strip>;
+            group: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>], "status">, z.ZodObject<{
+        object: z.ZodLiteral<"commit_receipt">;
+        clientTxId: z.ZodString;
+        serverTxId: z.ZodString;
+        success: z.ZodLiteral<false>;
+        status: z.ZodLiteral<"rejected">;
+        lastSyncId: z.ZodOptional<z.ZodNumber>;
+        ops: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodObject<{
+            code: z.ZodCustom<ErrorCode, ErrorCode>;
+            message: z.ZodString;
+            field: z.ZodOptional<z.ZodString>;
+            requiredCapability: z.ZodOptional<z.ZodCustom<RequiredCapability, RequiredCapability>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
+export type MutationResultMessageWire = z.infer<typeof mutationResultMessageSchema>;
+export declare const commitExecutionResultSchema: z.ZodPipe<z.ZodObject<{
+    lastSyncId: z.ZodNumber;
+    firstSyncId: z.ZodNumber;
+    status: z.ZodOptional<z.ZodEnum<{
+        queued: "queued";
+        confirmed: "confirmed";
+    }>>;
+    correlationId: z.ZodOptional<z.ZodString>;
+    confirmationTransactionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        object: z.ZodOptional<z.ZodLiteral<"stale_notification">>;
+        model: z.ZodString;
+        id: z.ZodString;
+        readAt: z.ZodNumber;
+        observedSyncId: z.ZodNumber;
+        conflictingFields: z.ZodArray<z.ZodString>;
+        currentValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        writtenBy: z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodTransform<{
+    status: "queued" | "confirmed";
+    lastSyncId: number;
+    firstSyncId: number;
+    correlationId?: string | undefined;
+    confirmationTransactionIds?: string[] | undefined;
+    notifications?: {
+        model: string;
+        id: string;
+        readAt: number;
+        observedSyncId: number;
+        conflictingFields: string[];
+        currentValues: Record<string, unknown>;
+        writtenBy: {
+            kind: "user" | "agent" | "system";
+            id: string;
+        };
+        object?: "stale_notification" | undefined;
+        group?: string | undefined;
+    }[] | undefined;
+    missingIds?: string[] | undefined;
+}, {
+    lastSyncId: number;
+    firstSyncId: number;
+    status?: "queued" | "confirmed" | undefined;
+    correlationId?: string | undefined;
+    confirmationTransactionIds?: string[] | undefined;
+    notifications?: {
+        model: string;
+        id: string;
+        readAt: number;
+        observedSyncId: number;
+        conflictingFields: string[];
+        currentValues: Record<string, unknown>;
+        writtenBy: {
+            kind: "user" | "agent" | "system";
+            id: string;
+        };
+        object?: "stale_notification" | undefined;
+        group?: string | undefined;
+    }[] | undefined;
+    missingIds?: string[] | undefined;
+}>>;
+export type CommitExecutionResultInput = z.input<typeof commitExecutionResultSchema>;
+export type CommitExecutionResult = z.infer<typeof commitExecutionResultSchema>;
+/** Normalized acknowledgement handed from a mutation transport to the queue. */
+export declare const commitAckSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"queued">;
+    correlationId: z.ZodString;
+    lastSyncId: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        object: z.ZodOptional<z.ZodLiteral<"stale_notification">>;
+        model: z.ZodString;
+        id: z.ZodString;
+        readAt: z.ZodNumber;
+        observedSyncId: z.ZodNumber;
+        conflictingFields: z.ZodArray<z.ZodString>;
+        currentValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        writtenBy: z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"confirmed">;
+    correlationId: z.ZodOptional<z.ZodString>;
+    lastSyncId: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        object: z.ZodOptional<z.ZodLiteral<"stale_notification">>;
+        model: z.ZodString;
+        id: z.ZodString;
+        readAt: z.ZodNumber;
+        observedSyncId: z.ZodNumber;
+        conflictingFields: z.ZodArray<z.ZodString>;
+        currentValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        writtenBy: z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>], "status">;
+export type CommitAck = z.infer<typeof commitAckSchema>;
+/**
+ * Compatibility boundary for injected/older mutation executors. New
+ * transports return `commitAckSchema`; a legacy `{lastSyncId}` is normalized
+ * to explicit confirmed settlement before queue code branches on it.
+ */
+export declare const mutationCommitResultSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"queued">;
+    correlationId: z.ZodString;
+    lastSyncId: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        object: z.ZodOptional<z.ZodLiteral<"stale_notification">>;
+        model: z.ZodString;
+        id: z.ZodString;
+        readAt: z.ZodNumber;
+        observedSyncId: z.ZodNumber;
+        conflictingFields: z.ZodArray<z.ZodString>;
+        currentValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        writtenBy: z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"confirmed">;
+    correlationId: z.ZodOptional<z.ZodString>;
+    lastSyncId: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        object: z.ZodOptional<z.ZodLiteral<"stale_notification">>;
+        model: z.ZodString;
+        id: z.ZodString;
+        readAt: z.ZodNumber;
+        observedSyncId: z.ZodNumber;
+        conflictingFields: z.ZodArray<z.ZodString>;
+        currentValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        writtenBy: z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>], "status">, z.ZodObject<{
+    status: z.ZodOptional<z.ZodUndefined>;
+    correlationId: z.ZodOptional<z.ZodUndefined>;
+    lastSyncId: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        object: z.ZodOptional<z.ZodLiteral<"stale_notification">>;
+        model: z.ZodString;
+        id: z.ZodString;
+        readAt: z.ZodNumber;
+        observedSyncId: z.ZodNumber;
+        conflictingFields: z.ZodArray<z.ZodString>;
+        currentValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        writtenBy: z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>]>, z.ZodTransform<{
+    status: "queued";
+    correlationId: string;
+    lastSyncId: number;
+    notifications?: {
+        model: string;
+        id: string;
+        readAt: number;
+        observedSyncId: number;
+        conflictingFields: string[];
+        currentValues: Record<string, unknown>;
+        writtenBy: {
+            kind: "user" | "agent" | "system";
+            id: string;
+        };
+        object?: "stale_notification" | undefined;
+        group?: string | undefined;
+    }[] | undefined;
+    missingIds?: string[] | undefined;
+} | {
+    status: "confirmed";
+    lastSyncId: number;
+    correlationId?: string | undefined;
+    notifications?: {
+        model: string;
+        id: string;
+        readAt: number;
+        observedSyncId: number;
+        conflictingFields: string[];
+        currentValues: Record<string, unknown>;
+        writtenBy: {
+            kind: "user" | "agent" | "system";
+            id: string;
+        };
+        object?: "stale_notification" | undefined;
+        group?: string | undefined;
+    }[] | undefined;
+    missingIds?: string[] | undefined;
+}, {
+    status: "queued";
+    correlationId: string;
+    lastSyncId: number;
+    notifications?: {
+        model: string;
+        id: string;
+        readAt: number;
+        observedSyncId: number;
+        conflictingFields: string[];
+        currentValues: Record<string, unknown>;
+        writtenBy: {
+            kind: "user" | "agent" | "system";
+            id: string;
+        };
+        object?: "stale_notification" | undefined;
+        group?: string | undefined;
+    }[] | undefined;
+    missingIds?: string[] | undefined;
+} | {
+    status: "confirmed";
+    lastSyncId: number;
+    correlationId?: string | undefined;
+    notifications?: {
+        model: string;
+        id: string;
+        readAt: number;
+        observedSyncId: number;
+        conflictingFields: string[];
+        currentValues: Record<string, unknown>;
+        writtenBy: {
+            kind: "user" | "agent" | "system";
+            id: string;
+        };
+        object?: "stale_notification" | undefined;
+        group?: string | undefined;
+    }[] | undefined;
+    missingIds?: string[] | undefined;
+} | {
+    lastSyncId: number;
+    status?: undefined;
+    correlationId?: undefined;
+    notifications?: {
+        model: string;
+        id: string;
+        readAt: number;
+        observedSyncId: number;
+        conflictingFields: string[];
+        currentValues: Record<string, unknown>;
+        writtenBy: {
+            kind: "user" | "agent" | "system";
+            id: string;
+        };
+        object?: "stale_notification" | undefined;
+        group?: string | undefined;
+    }[] | undefined;
+    missingIds?: string[] | undefined;
+}>>;
+export type MutationCommitResultInput = z.input<typeof mutationCommitResultSchema>;
+export type MutationCommitResult = z.infer<typeof mutationCommitResultSchema>;
+/**
+ * Public SDK projection returned by `ablo.commits` and model mutations.
+ *
+ * This intentionally does not compose `commitSettlementSchema`: on the WS
+ * facade, `wait:'queued'` currently means locally sealed/enqueued, before a
+ * server has necessarily accepted the write. Renaming that public state to
+ * `enqueued` is a separate protocol change; the authoritative settlement
+ * union above is reserved for server acknowledgements.
+ */
+export declare const clientCommitReceiptSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        queued: "queued";
+        confirmed: "confirmed";
+    }>;
+    lastSyncId: z.ZodOptional<z.ZodNumber>;
+    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        object: z.ZodOptional<z.ZodLiteral<"stale_notification">>;
+        model: z.ZodString;
+        id: z.ZodString;
+        readAt: z.ZodNumber;
+        observedSyncId: z.ZodNumber;
+        conflictingFields: z.ZodArray<z.ZodString>;
+        currentValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        writtenBy: z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type ClientCommitReceipt = z.infer<typeof clientCommitReceiptSchema>;