@abloatai/ablo 0.27.0 → 0.28.0

package/dist/client/httpClient.d.ts

@@ -79,6 +79,8 @@ export type AbloHttpClient<S extends SchemaRecord> = {
 } & {
     /** Runs one-time setup, such as registering a configured `databaseUrl` data source, before the client is used. It also runs lazily ahead of the first request, so calling it yourself is optional. */
     ready(): Promise<void>;
+    /** Replays every pending durable HTTP write in seal order and waits for settlement. */
+    waitForFlush(): Promise<void>;
     readonly commits: CommitResource;
     dispose(): Promise<void>;
     /** Resolves the bearer credential this client authenticates with, or `null` if none is set. */

package/dist/client/modelRegistration.js

@@ -192,8 +192,19 @@ function isZodObject(schema) {
 }
 /** Create a Model subclass for a schema-defined model */
 function createDynamicModelClass(modelName, jsonSubFields, fieldNames, computed, lazyObservable = false) {
+    // Names `toReactiveSnapshot` materializes onto plain snapshots: every
+    // `${field}Json` getter plus every schema-declared computed. Without this,
+    // snapshot rows silently drop getters that the schema's inferred row type
+    // declares — reads like `snapshot.settingsObject` would be `undefined`.
+    const derivedGetterNames = Object.freeze([
+        ...jsonSubFields.map(({ fieldName }) => `${fieldName}Json`),
+        ...Object.keys(computed ?? {}),
+    ]);
     const ModelClass = class extends Model {
         _modelName = modelName;
+        getDerivedGetterNames() {
+            return derivedGetterNames;
+        }
         constructor(data) {
             super(data);
             // Suppress change tracking during initial hydration. `makeObservable()`

package/dist/client/options.d.ts

@@ -6,6 +6,8 @@
 import type { Schema, SchemaRecord } from '../schema/schema.js';
 import type { SyncEngineConfig, SyncLogger, MutationExecutor, SyncObservabilityProvider, SyncAnalytics, SessionErrorDetector, OnlineStatusProvider } from '../interfaces/index.js';
 import type { AbloPersistence } from './persistence.js';
+import type { CommitOutboxStore } from '../transactions/commitOutboxStore.js';
+import type { CommitOutboxScope } from '../transactions/commitEnvelope.js';
 /**
  * An async function that resolves an apiKey at request time. Use it for credential
  * rotation — read from a vault, refresh from session storage, or pull from an
@@ -108,6 +110,23 @@ export interface AbloOptions<S extends SchemaRecord = SchemaRecord> {
      * @default 'memory'
      */
     persistence?: AbloPersistence;
+    /**
+     * Durable commit-envelope storage for server-side agents and workers.
+     * The stateful browser client uses its strict IndexedDB transaction store;
+     * the stateless HTTP client has no implicit filesystem and therefore needs a
+     * workflow-, SQLite-, or filesystem-backed implementation to survive a
+     * process restart. One store may serve several actors because every record
+     * is checked against its authenticated scope before replay.
+     */
+    commitOutbox?: CommitOutboxStore;
+    /**
+     * Stable actor/server scope for an injected HTTP {@link commitOutbox}.
+     * Omit it to resolve `organizationId` and `participantId` from the authenticated
+     * `/auth/identity` endpoint. Supplying it avoids that one setup request in
+     * trusted worker environments; `namespace` distinguishes deployments or
+     * workflow lanes that share the same actor identity.
+     */
+    commitOutboxScope?: CommitOutboxScope;
     /**
      * Selects the transport. `'websocket'` (the default) is the live client: a
      * persistent socket, a local synced cache, and `onChange` subscriptions. `'http'`
@@ -280,6 +299,10 @@ export interface InternalAbloOptions<S extends SchemaRecord = SchemaRecord> {
      * reload-surviving local cache in a browser.
      */
     persistence?: AbloPersistence;
+    /** Internal mirror of {@link AbloOptions.commitOutbox}. */
+    commitOutbox?: CommitOutboxStore;
+    /** Internal mirror of {@link AbloOptions.commitOutboxScope}. */
+    commitOutboxScope?: CommitOutboxScope;
     /** @deprecated Use `persistence: 'indexeddb'` for durable browser storage. */
     offline?: boolean;
     /**

package/dist/client/wsMutationExecutor.d.ts

@@ -17,8 +17,9 @@ import type { MutationExecutor, MutationOperation } from '../interfaces/index.js
  * the ready socket.
  *
  * When set, `options.idempotencyKey` is sent as the wire-level `clientTxId`, so
- * retrying a call with the same key is safe; otherwise the executor generates
- * one.
+ * retrying a call with the same key is safe. TransactionQueue always supplies
+ * this key before its first attempt and owns reuse across retries. The fallback
+ * generation below exists only for direct, one-shot executor consumers.
  */
 export declare function createDefaultMutationExecutor(getWs: () => {
     sendCommit?: (operations: readonly MutationOperation[], clientTxId: string, timeoutMs?: number, causedByTaskId?: string | null, reads?: readonly ReadDependency[] | null) => Promise<{

package/dist/client/wsMutationExecutor.js

@@ -17,8 +17,9 @@ import { AbloError, AbloConnectionError } from '../errors.js';
  * the ready socket.
  *
  * When set, `options.idempotencyKey` is sent as the wire-level `clientTxId`, so
- * retrying a call with the same key is safe; otherwise the executor generates
- * one.
+ * retrying a call with the same key is safe. TransactionQueue always supplies
+ * this key before its first attempt and owns reuse across retries. The fallback
+ * generation below exists only for direct, one-shot executor consumers.
  */
 export function createDefaultMutationExecutor(getWs) {
     async function commit(operations, options) {

package/dist/commit/contract.d.ts

@@ -0,0 +1,493 @@
+/**
+ * The transport-independent v2 commit contract.
+ *
+ * A commit is a caller's atomic write intent. It contains ordered operations,
+ * a stable idempotency key, and explicit write preconditions. HTTP and
+ * WebSocket transports wrap these schemas; they do not redefine their data.
+ * Every public data type in this module is inferred from the Zod schema that
+ * validates it at a trust boundary.
+ */
+import { z } from 'zod';
+/** Current version of the transport-independent commit contract. */
+export declare const COMMIT_CONTRACT_VERSION: 2;
+/** Stable identity of one logical commit. Reused unchanged for every retry. */
+export declare const idempotencyKeySchema: z.core.$ZodBranded<z.ZodString, "IdempotencyKey", "out">;
+export type IdempotencyKey = z.output<typeof idempotencyKeySchema>;
+/** Server-issued identity of a durable commit execution. */
+export declare const commitIdSchema: z.core.$ZodBranded<z.ZodUUID, "CommitId", "out">;
+export type CommitId = z.output<typeof commitIdSchema>;
+/** Stable identity of one operation within a commit. */
+export declare const operationIdSchema: z.core.$ZodBranded<z.ZodString, "OperationId", "out">;
+export type OperationId = z.output<typeof operationIdSchema>;
+/** Identity of a pessimistic claim whose generation fences a write. */
+export declare const claimIdSchema: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+export type ClaimId = z.output<typeof claimIdSchema>;
+/**
+ * Internal committed-log offset. Decimal strings preserve PostgreSQL BIGINT
+ * precision across JavaScript and JSON boundaries.
+ */
+export declare const syncOffsetSchema: z.core.$ZodBranded<z.ZodString, "SyncOffset", "out">;
+export type SyncOffset = z.output<typeof syncOffsetSchema>;
+/** Opaque resumable cursor returned to clients; consumers must not inspect it. */
+export declare const syncCursorSchema: z.core.$ZodBranded<z.ZodString, "SyncCursor", "out">;
+export type SyncCursor = z.output<typeof syncCursorSchema>;
+/** JSON-safe value accepted by a persisted or fingerprinted commit payload. */
+export declare const jsonValueSchema: z.ZodJSONSchema;
+export type JsonValue = z.output<typeof jsonValueSchema>;
+/** JSON object accepted for entity values, patches, and structured details. */
+export declare const jsonObjectSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+export type JsonObject = z.output<typeof jsonObjectSchema>;
+/** Model and row addressed by an operation. */
+export declare const entityRefSchema: z.ZodObject<{
+    model: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strict>;
+export type EntityRef = z.output<typeof entityRefSchema>;
+/**
+ * A condition that must still hold when an operation is applied. Preconditions
+ * are data rather than option flags so they are included in the request
+ * fingerprint and can be reported precisely when a commit conflicts.
+ */
+export declare const writePreconditionSchema: 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">;
+export type WritePrecondition = z.output<typeof writePreconditionSchema>;
+/**
+ * One ordered entity change within a commit. The discriminant makes illegal
+ * combinations unrepresentable: only create carries `value`, only patch
+ * carries `changes`, and destructive actions carry neither.
+ */
+export declare const commitOperationSchema: 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">;
+export type CommitOperationInput = z.input<typeof commitOperationSchema>;
+export type CommitOperation = z.output<typeof commitOperationSchema>;
+/** Semantic lineage included in the durable intent and its fingerprint. */
+export declare const commitMetadataSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    causedByTaskId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CommitMetadata = z.output<typeof commitMetadataSchema>;
+/** The portion of a request that is fingerprinted, preserving operation order. */
+export declare const commitIntentSchema: z.ZodObject<{
+    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>;
+export type CommitIntentInput = z.input<typeof commitIntentSchema>;
+export type CommitIntent = z.output<typeof commitIntentSchema>;
+/** A caller's stable idempotency identity plus the intent it identifies. */
+export declare const commitRequestSchema: 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>;
+export type CommitRequestInput = z.input<typeof commitRequestSchema>;
+export type CommitRequest = z.output<typeof commitRequestSchema>;
+/** Returns the exact semantic value that an idempotency fingerprint covers. */
+export declare function commitIntentOf(request: CommitRequest): CommitIntent;
+/** Machine-readable failure code carried by a rejected v2 commit. */
+export declare const commitErrorCodeSchema: z.ZodUnion<readonly [z.ZodEnum<{}>, z.ZodCustom<`policy:${string}`, `policy:${string}`>]>;
+export type CommitErrorCode = z.output<typeof commitErrorCodeSchema>;
+/** Structured capability a rejected commit would require on retry. */
+export declare const requiredCapabilitySchema: 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>;
+export type RequiredCapability = z.output<typeof requiredCapabilitySchema>;
+/** Structured terminal error for a commit that did not apply. */
+export declare const commitErrorSchema: 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>;
+export type CommitError = z.output<typeof commitErrorSchema>;
+/** One failed precondition and the smallest current state needed to reconcile. */
+export declare const commitConflictSchema: 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>;
+export type CommitConflict = z.output<typeof commitConflictSchema>;
+/**
+ * Terminal result of a commit execution. Expected outcomes are a discriminated
+ * union, so committed, conflicted, and rejected results cannot expose fields
+ * belonging to another state.
+ */
+export declare const commitReceiptSchema: 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">;
+export type CommitReceiptInput = z.input<typeof commitReceiptSchema>;
+export type CommitReceipt = z.output<typeof commitReceiptSchema>;
+export type CommittedCommitReceipt = Extract<CommitReceipt, {
+    status: 'committed';
+}>;
+export type ConflictedCommitReceipt = Extract<CommitReceipt, {
+    status: 'conflicted';
+}>;
+export type RejectedCommitReceipt = Extract<CommitReceipt, {
+    status: 'rejected';
+}>;