@abloatai/ablo 0.26.0 → 0.28.0

package/dist/transactions/TransactionStore.d.ts

@@ -1,8 +1,10 @@
 /**
- * In-memory transaction index — id map plus a by-status secondary index so
- * the queue's hot paths (`getByStatus('pending')` on every batch/coalesce
- * decision) stay O(status bucket) instead of O(all transactions). Lifted out
- * of `TransactionQueue.ts` as a stateful leaf with no queue coupling.
+ * An in-memory index of transactions by id, with a secondary index by status.
+ * The status index keeps the queue's hot paths — such as `getByStatus('pending')`
+ * on every batch and coalesce decision — proportional to the number of
+ * transactions in that status rather than the total across all statuses.
+ * {@link TransactionQueue} owns an instance and routes every status change
+ * through {@link updateStatus}, which keeps the two indexes consistent.
  */
 import type { Transaction } from './commitPayload.js';
 export declare class TransactionStore {

package/dist/transactions/TransactionStore.js

@@ -1,8 +1,10 @@
 /**
- * In-memory transaction index — id map plus a by-status secondary index so
- * the queue's hot paths (`getByStatus('pending')` on every batch/coalesce
- * decision) stay O(status bucket) instead of O(all transactions). Lifted out
- * of `TransactionQueue.ts` as a stateful leaf with no queue coupling.
+ * An in-memory index of transactions by id, with a secondary index by status.
+ * The status index keeps the queue's hot paths — such as `getByStatus('pending')`
+ * on every batch and coalesce decision — proportional to the number of
+ * transactions in that status rather than the total across all statuses.
+ * {@link TransactionQueue} owns an instance and routes every status change
+ * through {@link updateStatus}, which keeps the two indexes consistent.
  */
 export class TransactionStore {
     transactions = new Map();

package/dist/transactions/UnconfirmedWrites.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Tracks the transactions this client has applied locally but the server has
+ * not yet confirmed, so their echoes can be recognized when they return over
+ * the sync stream. When a change is made optimistically, the client updates
+ * its own state at once; the server later broadcasts the same change as a sync
+ * delta stamped with the originating `transactionId`. This tracker lets the
+ * receive path recognize that delta as its own echo and skip re-applying it,
+ * since the optimistic write already reflects it. Without this discriminator
+ * the apply path would re-apply the confirmation on top of state that may have
+ * changed since, producing a visible flicker.
+ *
+ * An entry is added with {@link markPending} and drained either by
+ * {@link consumeEcho} when the matching delta arrives, or by
+ * {@link drainOnRollback} when the originating transaction is cancelled.
+ *
+ * The set is bounded by `maxSize` to guard against unbounded growth if
+ * transactions are somehow never confirmed and never rolled back. When the
+ * bound is reached the oldest id is evicted first, since the backing Map
+ * iterates in insertion order. Eviction carries no correctness risk for the
+ * client that made the write, whose local state already reflects the change;
+ * the only cost is that a later echo of the evicted transaction is applied as
+ * if it were a foreign change, at worst a single redundant re-set.
+ */
+export interface UnconfirmedWritesOptions {
+    /**
+     * The maximum number of unconfirmed transaction ids to track. Once this many
+     * are held, adding another evicts the oldest. Defaults to 10,000, which
+     * leaves ample headroom even for a client with many tabs open during a large
+     * bulk edit.
+     */
+    maxSize?: number;
+}
+export interface UnconfirmedWritesMetrics {
+    /** Total ids currently tracked. */
+    size: number;
+    /** Cumulative ids ever added since construction. */
+    totalAdded: number;
+    /** Cumulative successful echo matches (delta arrived → drained). */
+    hits: number;
+    /** Cumulative explicit rollback drains (transaction never made it). */
+    rollbacks: number;
+    /** Cumulative ids evicted due to maxSize pressure. */
+    evictions: number;
+}
+export declare class UnconfirmedWrites {
+    private readonly ids;
+    private readonly maxSize;
+    private _totalAdded;
+    private _hits;
+    private _rollbacks;
+    private _evictions;
+    constructor(options?: UnconfirmedWritesOptions);
+    /**
+     * Mark a transaction as locally-applied. The next sync delta with a
+     * matching `transactionId` will be recognized as the server's
+     * confirmation of this same write. Idempotent — repeated calls with
+     * the same id are no-ops.
+     */
+    markPending(transactionId: string): void;
+    /**
+     * Reports whether an incoming delta is this client's own echo, draining the
+     * entry if so. Returns true when the id was being tracked, signalling the
+     * caller to skip re-applying the change because the optimistic write already
+     * reflects it; returns false for a change that originated elsewhere, which
+     * should be applied normally.
+     *
+     * The check and drain are combined into one call so the receive path cannot
+     * accidentally treat two deltas carrying the same id, arriving in one batch,
+     * as separate echoes.
+     */
+    consumeEcho(transactionId: string | null | undefined): boolean;
+    /**
+     * Drains the entry for a transaction that was rolled back before the server
+     * confirmed it. No echo will ever arrive for a cancelled transaction, so
+     * without this the pending entry would leak. Rollbacks are counted separately
+     * from confirmed echoes, so a rise in rollbacks relative to hits can flag
+     * network or server trouble.
+     */
+    drainOnRollback(transactionId: string): void;
+    getMetrics(): Readonly<UnconfirmedWritesMetrics>;
+    clear(): void;
+}

package/dist/transactions/UnconfirmedWrites.js

@@ -0,0 +1,104 @@
+/**
+ * Tracks the transactions this client has applied locally but the server has
+ * not yet confirmed, so their echoes can be recognized when they return over
+ * the sync stream. When a change is made optimistically, the client updates
+ * its own state at once; the server later broadcasts the same change as a sync
+ * delta stamped with the originating `transactionId`. This tracker lets the
+ * receive path recognize that delta as its own echo and skip re-applying it,
+ * since the optimistic write already reflects it. Without this discriminator
+ * the apply path would re-apply the confirmation on top of state that may have
+ * changed since, producing a visible flicker.
+ *
+ * An entry is added with {@link markPending} and drained either by
+ * {@link consumeEcho} when the matching delta arrives, or by
+ * {@link drainOnRollback} when the originating transaction is cancelled.
+ *
+ * The set is bounded by `maxSize` to guard against unbounded growth if
+ * transactions are somehow never confirmed and never rolled back. When the
+ * bound is reached the oldest id is evicted first, since the backing Map
+ * iterates in insertion order. Eviction carries no correctness risk for the
+ * client that made the write, whose local state already reflects the change;
+ * the only cost is that a later echo of the evicted transaction is applied as
+ * if it were a foreign change, at worst a single redundant re-set.
+ */
+const DEFAULT_MAX_SIZE = 10_000;
+export class UnconfirmedWrites {
+    // Map (not Set) for O(1) FIFO eviction via insertion order.
+    // Value is unused; Map.keys() iterates in insertion order so
+    // `keys().next()` yields the oldest id.
+    ids = new Map();
+    maxSize;
+    // Metrics — internal counters; exposed via `getMetrics()`. Kept
+    // numeric (not BigInt) since cumulative-since-page-load fits well
+    // under Number.MAX_SAFE_INTEGER for any realistic session.
+    _totalAdded = 0;
+    _hits = 0;
+    _rollbacks = 0;
+    _evictions = 0;
+    constructor(options = {}) {
+        this.maxSize = options.maxSize ?? DEFAULT_MAX_SIZE;
+    }
+    /**
+     * Mark a transaction as locally-applied. The next sync delta with a
+     * matching `transactionId` will be recognized as the server's
+     * confirmation of this same write. Idempotent — repeated calls with
+     * the same id are no-ops.
+     */
+    markPending(transactionId) {
+        if (this.ids.has(transactionId))
+            return;
+        if (this.ids.size >= this.maxSize) {
+            const oldest = this.ids.keys().next().value;
+            if (oldest !== undefined) {
+                this.ids.delete(oldest);
+                this._evictions += 1;
+            }
+        }
+        this.ids.set(transactionId, true);
+        this._totalAdded += 1;
+    }
+    /**
+     * Reports whether an incoming delta is this client's own echo, draining the
+     * entry if so. Returns true when the id was being tracked, signalling the
+     * caller to skip re-applying the change because the optimistic write already
+     * reflects it; returns false for a change that originated elsewhere, which
+     * should be applied normally.
+     *
+     * The check and drain are combined into one call so the receive path cannot
+     * accidentally treat two deltas carrying the same id, arriving in one batch,
+     * as separate echoes.
+     */
+    consumeEcho(transactionId) {
+        if (!transactionId)
+            return false;
+        if (!this.ids.has(transactionId))
+            return false;
+        this.ids.delete(transactionId);
+        this._hits += 1;
+        return true;
+    }
+    /**
+     * Drains the entry for a transaction that was rolled back before the server
+     * confirmed it. No echo will ever arrive for a cancelled transaction, so
+     * without this the pending entry would leak. Rollbacks are counted separately
+     * from confirmed echoes, so a rise in rollbacks relative to hits can flag
+     * network or server trouble.
+     */
+    drainOnRollback(transactionId) {
+        if (this.ids.delete(transactionId)) {
+            this._rollbacks += 1;
+        }
+    }
+    getMetrics() {
+        return {
+            size: this.ids.size,
+            totalAdded: this._totalAdded,
+            hits: this._hits,
+            rollbacks: this._rollbacks,
+            evictions: this._evictions,
+        };
+    }
+    clear() {
+        this.ids.clear();
+    }
+}

package/dist/transactions/coalesceRules.d.ts

@@ -1,34 +1,58 @@
 /**
- * Coalescing rules — the queue's same-entity causality guards, lifted out of
- * `TransactionQueue.ts` as a leaf over a minimal store-shaped interface:
+ * The queue's rules for coalescing operations that touch the same row, so their
+ * causal order is preserved. {@link TransactionQueue} calls into these through a
+ * small store-shaped interface:
  *
- *   • create-then-delete cancellation (`takeUnsentCreateForModel`): a delete
- *     of a row whose create never left the client cancels both locally;
- *   • the create barrier (`findCreateBarrierForDelete`) + deferred-delete
- *     parking (`deferDeleteUntilCreateSettles` / `release…`): once a create
- *     HAS been sent, a delete must wait for it to settle or the server could
- *     see DELETE-before-CREATE;
- *   • update-payload merging (`mergeUpdateData`): collapses rapid same-entity
- *     updates into one wire op.
+ *   - Create-then-delete cancellation ({@link takeUnsentCreateForModel}):
+ *     deleting a row whose create never left the client cancels both locally.
+ *   - The create barrier ({@link findCreateBarrierForDelete}) and deferred-delete
+ *     parking ({@link deferDeleteUntilCreateSettles} /
+ *     {@link releaseDeferredDeletesForCreate}): once a create has been sent, a
+ *     delete must wait for it to settle, or the server could receive the delete
+ *     before the create.
+ *   - Update-payload merging ({@link mergeUpdateData}): collapses rapid updates
+ *     to the same row into one wire operation.
  *
- * The queue's `enqueue`/`delete` verbs stay in the host (they orchestrate
- * optimistic state + events); the RULES live here.
+ * The queue keeps the `enqueue` and `delete` methods that orchestrate optimistic
+ * state and events; these functions hold only the coalescing rules.
  */
 import type { MutationInput, Transaction } from './commitPayload.js';
-/** The slice of `TransactionStore` the coalescing rules read. */
+/** The subset of {@link TransactionStore} that the coalescing rules read. */
 export interface TransactionStoreLike {
     get(id: string): Transaction | undefined;
     getByStatus(status: Transaction['status']): Transaction[];
 }
 export declare const entityKey: (modelName: string, modelId: string) => string;
 /**
- * Find-and-remove a create for (model, id) that has never been sent —
- * checking the microtask staging area, the execution queue, and the store's
- * pending bucket, in that order. Splices the winner out of whichever queue
- * held it so the caller can cancel it instead of shipping create+delete.
+ * Finds and removes a create for the given model and id that has never been
+ * sent, searching the staging area, the execution queue, and the store's
+ * pending bucket in that order. It splices the match out of whichever queue
+ * held it, so the caller can cancel it rather than send a create followed by a
+ * delete.
  */
 export declare function takeUnsentCreateForModel(staged: Transaction[], queued: Transaction[], store: Pick<TransactionStoreLike, 'getByStatus'>, modelName: string, modelId: string): Transaction | undefined;
+/**
+ * Returns the most recent in-flight create for the given model and id that a
+ * delete must wait behind, or undefined if there is none. A pending create that
+ * has never been attempted is not a barrier, because it can be cancelled
+ * instead; once a create has been sent, even a retry-pending one is a barrier.
+ */
 export declare function findCreateBarrierForDelete(store: Pick<TransactionStoreLike, 'getByStatus'>, modelName: string, modelId: string): Transaction | undefined;
+/**
+ * Parks a delete until the create for the same row settles, keyed by the
+ * create's model and id. {@link releaseDeferredDeletesForCreate} re-enqueues
+ * the parked deletes once that create completes.
+ */
 export declare function deferDeleteUntilCreateSettles(deferredDeletesByCreate: Map<string, Transaction[]>, createTransaction: Transaction, deleteTransaction: Transaction): void;
+/**
+ * Re-enqueues the deletes parked behind a create once that create settles,
+ * skipping any whose status is no longer pending.
+ */
 export declare function releaseDeferredDeletesForCreate(deferredDeletesByCreate: Map<string, Transaction[]>, store: Pick<TransactionStoreLike, 'get'>, enqueue: (transaction: Transaction) => void, createTransaction: Transaction): void;
+/**
+ * Merges two update payloads for the same row into one. Later values win, with
+ * one exception: a `metadata` field is deep-merged as an object — parsing it
+ * first when it arrives as a JSON string — rather than replaced, so partial
+ * metadata updates accumulate instead of overwriting each other.
+ */
 export declare function mergeUpdateData(left: MutationInput | undefined, right: MutationInput | undefined, _modelName?: string): MutationInput;

package/dist/transactions/coalesceRules.js

@@ -1,26 +1,29 @@
 /**
- * Coalescing rules — the queue's same-entity causality guards, lifted out of
- * `TransactionQueue.ts` as a leaf over a minimal store-shaped interface:
+ * The queue's rules for coalescing operations that touch the same row, so their
+ * causal order is preserved. {@link TransactionQueue} calls into these through a
+ * small store-shaped interface:
  *
- *   • create-then-delete cancellation (`takeUnsentCreateForModel`): a delete
- *     of a row whose create never left the client cancels both locally;
- *   • the create barrier (`findCreateBarrierForDelete`) + deferred-delete
- *     parking (`deferDeleteUntilCreateSettles` / `release…`): once a create
- *     HAS been sent, a delete must wait for it to settle or the server could
- *     see DELETE-before-CREATE;
- *   • update-payload merging (`mergeUpdateData`): collapses rapid same-entity
- *     updates into one wire op.
+ *   - Create-then-delete cancellation ({@link takeUnsentCreateForModel}):
+ *     deleting a row whose create never left the client cancels both locally.
+ *   - The create barrier ({@link findCreateBarrierForDelete}) and deferred-delete
+ *     parking ({@link deferDeleteUntilCreateSettles} /
+ *     {@link releaseDeferredDeletesForCreate}): once a create has been sent, a
+ *     delete must wait for it to settle, or the server could receive the delete
+ *     before the create.
+ *   - Update-payload merging ({@link mergeUpdateData}): collapses rapid updates
+ *     to the same row into one wire operation.
  *
- * The queue's `enqueue`/`delete` verbs stay in the host (they orchestrate
- * optimistic state + events); the RULES live here.
+ * The queue keeps the `enqueue` and `delete` methods that orchestrate optimistic
+ * state and events; these functions hold only the coalescing rules.
  */
 export const entityKey = (modelName, modelId) => `${modelName}:${modelId}`;
 const isTransactionForModel = (transaction, modelName, modelId) => transaction.modelName === modelName && transaction.modelId === modelId;
 /**
- * Find-and-remove a create for (model, id) that has never been sent —
- * checking the microtask staging area, the execution queue, and the store's
- * pending bucket, in that order. Splices the winner out of whichever queue
- * held it so the caller can cancel it instead of shipping create+delete.
+ * Finds and removes a create for the given model and id that has never been
+ * sent, searching the staging area, the execution queue, and the store's
+ * pending bucket in that order. It splices the match out of whichever queue
+ * held it, so the caller can cancel it rather than send a create followed by a
+ * delete.
  */
 export function takeUnsentCreateForModel(staged, queued, store, modelName, modelId) {
     const isUnsentCreate = (tx) => tx.type === 'create' &&
@@ -37,6 +40,12 @@ export function takeUnsentCreateForModel(staged, queued, store, modelName, model
     }
     return store.getByStatus('pending').find(isUnsentCreate);
 }
+/**
+ * Returns the most recent in-flight create for the given model and id that a
+ * delete must wait behind, or undefined if there is none. A pending create that
+ * has never been attempted is not a barrier, because it can be cancelled
+ * instead; once a create has been sent, even a retry-pending one is a barrier.
+ */
 export function findCreateBarrierForDelete(store, modelName, modelId) {
     const liveCreates = [
         ...store.getByStatus('pending'),
@@ -50,12 +59,21 @@ export function findCreateBarrierForDelete(store, modelName, modelId) {
         (tx.status !== 'pending' || tx.attempts > 0));
     return liveCreates.sort((a, b) => b.createdAt - a.createdAt)[0];
 }
+/**
+ * Parks a delete until the create for the same row settles, keyed by the
+ * create's model and id. {@link releaseDeferredDeletesForCreate} re-enqueues
+ * the parked deletes once that create completes.
+ */
 export function deferDeleteUntilCreateSettles(deferredDeletesByCreate, createTransaction, deleteTransaction) {
     const key = entityKey(createTransaction.modelName, createTransaction.modelId);
     const deferred = deferredDeletesByCreate.get(key) ?? [];
     deferred.push(deleteTransaction);
     deferredDeletesByCreate.set(key, deferred);
 }
+/**
+ * Re-enqueues the deletes parked behind a create once that create settles,
+ * skipping any whose status is no longer pending.
+ */
 export function releaseDeferredDeletesForCreate(deferredDeletesByCreate, store, enqueue, createTransaction) {
     const key = entityKey(createTransaction.modelName, createTransaction.modelId);
     const deferred = deferredDeletesByCreate.get(key);
@@ -68,7 +86,12 @@ export function releaseDeferredDeletesForCreate(deferredDeletesByCreate, store,
         enqueue(deleteTransaction);
     }
 }
-// Merge two GraphQL update payloads with special handling for metadata fields
+/**
+ * Merges two update payloads for the same row into one. Later values win, with
+ * one exception: a `metadata` field is deep-merged as an object — parsing it
+ * first when it arrives as a JSON string — rather than replaced, so partial
+ * metadata updates accumulate instead of overwriting each other.
+ */
 export function mergeUpdateData(left, right, _modelName) {
     const out = { ...(left || {}) };
     const src = right || {};

package/dist/transactions/commitEnvelope.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Runtime contracts for retry-safe commits.
+ *
+ * `commitEnvelopeMemberSchema` is the compact pointer stored on an in-memory
+ * transaction. `durableCommitEnvelopeSchema` is the actual outbox record: one
+ * atomic IndexedDB value containing the stable request key, exact ordered wire
+ * operations, and the source mutations it supersedes.
+ */
+import { z } from 'zod';
+export declare const COMMIT_ENVELOPE_VERSION: 1;
+export declare const COMMIT_ENVELOPE_RECORD_PREFIX = "commit-envelope:";
+/** One transaction's position in a commit; this is not the envelope itself. */
+export declare const commitEnvelopeMemberSchema: z.ZodObject<{
+    idempotencyKey: z.core.$ZodBranded<z.ZodString, "IdempotencyKey", "out">;
+    operationIndex: z.ZodNumber;
+    operationCount: z.ZodNumber;
+    sealedAt: z.ZodOptional<z.ZodNumber>;
+    sequence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type CommitEnvelopeMember = z.infer<typeof commitEnvelopeMemberSchema>;
+/** The legacy mutation operation shape sent by the current commit transport. */
+export declare const durableCommitOperationSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        CREATE: "CREATE";
+        UPDATE: "UPDATE";
+        DELETE: "DELETE";
+        ARCHIVE: "ARCHIVE";
+        UNARCHIVE: "UNARCHIVE";
+    }>;
+    readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        reject: "reject";
+        overwrite: "overwrite";
+        notify: "notify";
+    }>>>;
+    model: z.ZodString;
+    id: z.ZodString;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    transactionId: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodObject<{
+        idempotencyKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export type DurableCommitOperation = z.infer<typeof durableCommitOperationSchema>;
+export type DurableCommitOperationInput = z.input<typeof durableCommitOperationSchema>;
+export declare const commitOutboxScopeSchema: z.ZodObject<{
+    organizationId: z.ZodString;
+    participantId: z.ZodString;
+    namespace: z.ZodString;
+}, z.core.$strict>;
+export type CommitOutboxScope = z.infer<typeof commitOutboxScopeSchema>;
+/**
+ * One crash-durable logical commit. Keeping every operation in one record makes
+ * membership and order atomic: recovery can observe the old record or the new
+ * record, never half an envelope.
+ */
+export declare const durableCommitEnvelopeSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"commit_envelope">;
+    storageVersion: z.ZodLiteral<1>;
+    origin: z.ZodEnum<{
+        model_batch: "model_batch";
+        atomic_commit: "atomic_commit";
+    }>;
+    idempotencyKey: z.core.$ZodBranded<z.ZodString, "IdempotencyKey", "out">;
+    operations: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            CREATE: "CREATE";
+            UPDATE: "UPDATE";
+            DELETE: "DELETE";
+            ARCHIVE: "ARCHIVE";
+            UNARCHIVE: "UNARCHIVE";
+        }>;
+        readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            reject: "reject";
+            overwrite: "overwrite";
+            notify: "notify";
+        }>>>;
+        model: z.ZodString;
+        id: z.ZodString;
+        input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        transactionId: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodObject<{
+            idempotencyKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strip>>;
+    sourceMutationIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    commitOptions: z.ZodDefault<z.ZodObject<{
+        causedByTaskId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reads: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            model: z.ZodString;
+            id: z.ZodString;
+            readAt: z.ZodNumber;
+            fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            onStale: z.ZodOptional<z.ZodEnum<{
+                reject: "reject";
+                overwrite: "overwrite";
+                notify: "notify";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            group: z.ZodString;
+            readAt: z.ZodNumber;
+            onStale: z.ZodOptional<z.ZodEnum<{
+                reject: "reject";
+                overwrite: "overwrite";
+                notify: "notify";
+            }>>;
+        }, z.core.$strip>]>>>>;
+    }, z.core.$strict>>;
+    scope: z.ZodOptional<z.ZodObject<{
+        organizationId: z.ZodString;
+        participantId: z.ZodString;
+        namespace: z.ZodString;
+    }, z.core.$strict>>;
+    createdAt: z.ZodNumber;
+    sealedAt: z.ZodNumber;
+    sequence: z.ZodOptional<z.ZodNumber>;
+    timestamp: z.ZodNumber;
+}, z.core.$strict>;
+export type DurableCommitEnvelope = z.infer<typeof durableCommitEnvelopeSchema>;
+export declare function commitEnvelopeRecordId(idempotencyKey: string): string;
+/** Constructs validated member metadata when an in-memory batch is formed. */
+export declare function createCommitEnvelopeMember(value: z.input<typeof commitEnvelopeMemberSchema>): CommitEnvelopeMember;
+/**
+ * Freezes the exact JSON request that will be persisted and sent. The JSON
+ * round-trip deliberately applies the same Date/undefined semantics as the
+ * WebSocket transport before the request fingerprint becomes durable.
+ */
+export declare function createDurableCommitEnvelope(value: Omit<z.input<typeof durableCommitEnvelopeSchema>, 'id' | 'type' | 'storageVersion' | 'timestamp'>): DurableCommitEnvelope;