@abloatai/ablo 0.34.0 → 0.35.0

package/dist/transactions/mutations/commitLatency.js

@@ -0,0 +1,130 @@
+/**
+ * Commit latency — how long a user's edit actually takes to land.
+ *
+ * The engine has never measured this. HUDs and dashboards reach for
+ * `window.fetch` timings, which the sync engine's WebSocket never touches, so
+ * the latency a user sees reported while editing has had nothing to do with
+ * the writes they are making. This module closes that gap without adding a
+ * single timestamp to the hot path: `MutationQueue` already emits the commit
+ * lifecycle, and the events already carry the correlation key.
+ *
+ * Three events, two intervals:
+ *
+ *   commit:staging ──sealMs──▶ commit:created ──ackMs──▶ transaction:completed
+ *
+ *  - `sealMs` is **local** — writing the durable envelope before the commit is
+ *    allowed onto the wire. Slow here means storage (IndexedDB), not network.
+ *  - `ackMs` is **remote** — dispatch, round-trip, and server work. For a
+ *    commit routed at a connected source this also spans the wait for the
+ *    correlated echo that promotes `queued` to `confirmed`, so it answers
+ *    "when did my edit become real" rather than raw socket round-trip. Read a
+ *    large `ackMs` against a small `sealMs` as a network or replication cost.
+ *
+ * Correlation is by `clientTxId`: `MutationQueue` uses it as the transaction
+ * id verbatim, so the staging event and the completion event share one key.
+ */
+/**
+ * Cap on commits awaiting completion. A commit whose completion never arrives
+ * (connection dropped mid-flight, retry abandoned) would otherwise pin its
+ * entry forever, so the map is bounded rather than trusted to drain.
+ */
+const MAX_PENDING_COMMITS = 256;
+function nowMs() {
+    return typeof performance !== 'undefined' ? performance.now() : Date.now();
+}
+/** Read `clientTxId` off a `commit:*` payload, or null if it isn't shaped so. */
+function readClientTxId(payload) {
+    if (typeof payload !== 'object' || payload === null)
+        return null;
+    const { clientTxId } = payload;
+    return typeof clientTxId === 'string' ? clientTxId : null;
+}
+/** Read `id` off a transaction payload (`transaction:completed` sends the tx). */
+function readTransactionId(payload) {
+    if (typeof payload !== 'object' || payload === null)
+        return null;
+    const { id } = payload;
+    return typeof id === 'string' ? id : null;
+}
+/** `transaction:failed` wraps the transaction rather than sending it bare. */
+function readFailedTransactionId(payload) {
+    if (typeof payload !== 'object' || payload === null)
+        return null;
+    return readTransactionId(payload.transaction);
+}
+/**
+ * Pair commit lifecycle events into latency samples. Returns an unsubscribe
+ * function that also drops any still-pending timings.
+ *
+ * `onSample` fires once per commit that completes, in completion order.
+ */
+export function observeCommitLatency(source, onSample) {
+    const pending = new Map();
+    const handleStaging = (payload) => {
+        const id = readClientTxId(payload);
+        if (id === null)
+            return;
+        // Map preserves insertion order, so the first key is the stalest entry.
+        if (pending.size >= MAX_PENDING_COMMITS) {
+            const oldest = pending.keys().next();
+            if (!oldest.done)
+                pending.delete(oldest.value);
+        }
+        pending.set(id, { stagedAt: nowMs(), sealedAt: null });
+    };
+    const handleCreated = (payload) => {
+        const id = readClientTxId(payload);
+        if (id === null)
+            return;
+        const timing = pending.get(id);
+        if (timing === undefined)
+            return;
+        timing.sealedAt = nowMs();
+    };
+    const handleCompleted = (payload) => {
+        const id = readTransactionId(payload);
+        if (id === null)
+            return;
+        const timing = pending.get(id);
+        // `transaction:completed` also fires for local (non-commit) transactions
+        // and for mutation-log replay. Only ids we staged are commits, so an
+        // absent entry is the normal way those are filtered out.
+        if (timing === undefined)
+            return;
+        pending.delete(id);
+        const completedAt = nowMs();
+        // A commit can complete without an observed seal only if the listener was
+        // attached mid-flight; attributing the whole span to `ackMs` keeps
+        // `sealMs + ackMs === totalMs` true rather than reporting a bogus seal.
+        const sealedAt = timing.sealedAt ?? timing.stagedAt;
+        onSample({
+            clientTxId: id,
+            sealMs: sealedAt - timing.stagedAt,
+            ackMs: completedAt - sealedAt,
+            totalMs: completedAt - timing.stagedAt,
+        });
+    };
+    const handleSealFailed = (payload) => {
+        const id = readClientTxId(payload);
+        if (id !== null)
+            pending.delete(id);
+    };
+    const handleFailed = (payload) => {
+        const id = readFailedTransactionId(payload);
+        if (id !== null)
+            pending.delete(id);
+    };
+    source.on('commit:staging', handleStaging);
+    source.on('commit:created', handleCreated);
+    source.on('commit:seal_failed', handleSealFailed);
+    source.on('transaction:completed', handleCompleted);
+    source.on('transaction:failed', handleFailed);
+    return () => {
+        source.off('commit:staging', handleStaging);
+        source.off('commit:created', handleCreated);
+        source.off('commit:seal_failed', handleSealFailed);
+        source.off('transaction:completed', handleCompleted);
+        source.off('transaction:failed', handleFailed);
+        pending.clear();
+    };
+}

package/dist/transactions/{commitOutboxStore.d.ts → mutations/commitOutboxStore.d.ts}

@@ -3,13 +3,9 @@
  *
  * Browser clients use {@link DatabaseCommitOutboxStore}. Agent/Node hosts can
  * inject a workflow-, SQLite-, or filesystem-backed implementation without
- * coupling TransactionQueue to the browser database/cache implementation.
+ * coupling MutationQueue to the browser database/cache implementation.
  */
 import type { DurableWriteStore, PendingWrite } from './durableWriteStore.js';
-/** @deprecated Use {@link PendingWrite}. */
-export type CommitOutboxRecord = PendingWrite;
-/** @deprecated Use {@link DurableWriteStore}. */
-export type CommitOutboxStore = DurableWriteStore;
 /**
  * The exact subset of the browser `Database` that {@link DatabaseCommitOutboxStore}
  * drives. Typing the adapter to this narrow port instead of importing the

package/dist/transactions/{commitOutboxStore.js → mutations/commitOutboxStore.js}

@@ -3,7 +3,7 @@
  *
  * Browser clients use {@link DatabaseCommitOutboxStore}. Agent/Node hosts can
  * inject a workflow-, SQLite-, or filesystem-backed implementation without
- * coupling TransactionQueue to the browser database/cache implementation.
+ * coupling MutationQueue to the browser database/cache implementation.
  */
 /** Strict IndexedDB adapter backed by Database's `__transactions` store. */
 export class DatabaseCommitOutboxStore {

package/dist/transactions/{commitPayload.d.ts → mutations/commitPayload.d.ts}

@@ -1,6 +1,6 @@
 /**
  * The vocabulary a local transaction uses on the wire. This module defines the
- * {@link Transaction} record and the helpers that turn a transaction into a
+ * {@link QueuedMutation} record and the helpers that turn a transaction into a
  * wire-safe commit operation: schema-field projection
  * ({@link projectCommitPayload}), write-option projection
  * ({@link applyWriteOptions}), foreign-key-aware priority scoring
@@ -8,9 +8,10 @@
  * transport errors. Nothing here holds queue state or timers, so the batched
  * queue path and the HTTP commit path share the same projection.
  */
-import { MutationOperationType } from '../types/index.js';
-import type { MutationOptions, WriteOptions } from '../interfaces/index.js';
-import type { CommitEnvelopeMember } from './commitEnvelope.js';
+import { MutationOperationType } from '../../transaction/types/index.js';
+import type { OnStaleMode } from '../../transaction/coordination/schema.js';
+import type { MutationOptions, WriteOptions } from '../../interfaces/index.js';
+import type { CommitEnvelopeMember } from '../../transaction/transactions/settlement/commitEnvelope.js';
 export interface UserContext {
     userId: string;
     organizationId: string;
@@ -25,22 +26,22 @@ export type MutationInput = Record<string, unknown>;
  *
  *   1. Drops framework-internal keys (`__class`, `__typename`, `clientId`,
  *      `syncStatus`) and anything not declared on the model's schema.
- *   2. Passes each declared field's value through unchanged, including
- *      JSON-typed fields, which are sent as objects rather than pre-serialized
- *      strings (see the note in the body for why).
+ *   2. Takes a fresh plain JSON snapshot of the projected values. JSON-typed
+ *      fields stay objects rather than pre-serialized strings, while reactive
+ *      proxies cannot leak into persistence or the wire payload.
  *
  * For updates (`dropUndefined: true`), `undefined` values are also removed so
  * they are not written as `SET column = NULL` on the server.
  *
  * Field metadata comes from the model registry, populated when the schema is
  * registered at initialization. If a model has no registered field metadata —
- * for example a manually registered model — projection passes the serialized
- * data through unchanged apart from dropping the framework keys.
+ * for example a manually registered model — projection snapshots all serialized
+ * data apart from the framework keys.
  */
 export declare function projectCommitPayload(modelName: string, source: Record<string, unknown>, opts: {
     dropUndefined: boolean;
 }): MutationInput;
-export interface Transaction {
+export interface QueuedMutation {
     id: string;
     type: 'create' | 'update' | 'delete' | 'archive' | 'unarchive';
     modelName: string;
@@ -95,7 +96,7 @@ export interface Transaction {
      * recovers. This gives a caller one place to await the answer to "did my write
      * land?", matching the
      * `commits.create({ wait: 'confirmed' })` and
-     * {@link TransactionQueue.waitForConfirmation} vocabulary, so a failure
+     * {@link MutationQueue.waitForConfirmation} vocabulary, so a failure
      * surfaces at the call site instead of only as a silent local rollback. The
      * permanent-rejection value is the same {@link AbloError} carried on the
      * queue's `transaction:failed` event.
@@ -117,14 +118,14 @@ export declare const stripModelSuffix: (modelName: string) => string;
  * foreign-key ordering because the row already exists, so they all share the
  * configured default non-create priority.
  */
-export declare const computePriorityScore: (type: Transaction["type"], modelName: string) => number;
-export declare const TX_TYPE_TO_MUTATION_OP: Record<Transaction['type'], MutationOperationType>;
+export declare const computePriorityScore: (type: QueuedMutation["type"], modelName: string) => number;
+export declare const TX_TYPE_TO_MUTATION_OP: Record<QueuedMutation['type'], MutationOperationType>;
 export declare function hasStaleWriteOptions(options?: WriteOptions): boolean;
 /** Options whose identity/audit semantics forbid merging two caller writes. */
 export declare function hasCommitCoalescingBarrier(options?: WriteOptions): boolean;
 export interface WriteOperationFields {
     readAt?: number | null;
-    onStale?: 'reject' | 'overwrite' | 'notify' | null;
+    onStale?: OnStaleMode | null;
     fenceToken?: number | null;
     options?: Pick<MutationOptions, 'idempotencyKey' | 'label'>;
 }
@@ -135,7 +136,7 @@ export interface WriteOperationFields {
  * `mutation_log` cache key and audit tag. This is the one place caller-supplied
  * write options cross onto the wire.
  */
-export declare function applyWriteOptions<T extends object>(op: T, transaction: Transaction): T & WriteOperationFields;
+export declare function applyWriteOptions<T extends object>(op: T, transaction: QueuedMutation): T & WriteOperationFields;
 /**
  * The structural shape used to inspect transport-layer errors. It covers the
  * GraphQL-style and HTTP-style error shapes the mutation executor can surface,

package/dist/transactions/{commitPayload.js → mutations/commitPayload.js}

@@ -1,6 +1,6 @@
 /**
  * The vocabulary a local transaction uses on the wire. This module defines the
- * {@link Transaction} record and the helpers that turn a transaction into a
+ * {@link QueuedMutation} record and the helpers that turn a transaction into a
  * wire-safe commit operation: schema-field projection
  * ({@link projectCommitPayload}), write-option projection
  * ({@link applyWriteOptions}), foreign-key-aware priority scoring
@@ -8,9 +8,9 @@
  * transport errors. Nothing here holds queue state or timers, so the batched
  * queue path and the HTTP commit path share the same projection.
  */
-import { getContext } from '../context.js';
-import { getActiveRegistry } from '../ModelRegistry.js';
-import { MutationOperationType } from '../types/index.js';
+import { getContext } from '../../context.js';
+import { MutationOperationType } from '../../transaction/types/index.js';
+import { snapshotJsonValue } from '../../transaction/utils/json.js';
 /**
  * Framework-internal keys added by `Model.toJSON()` that must never
  * reach the wire. The server treats each top-level key as a target
@@ -23,20 +23,20 @@ const FRAMEWORK_KEYS = new Set(['__class', '__typename', 'clientId', 'syncStatus
  *
  *   1. Drops framework-internal keys (`__class`, `__typename`, `clientId`,
  *      `syncStatus`) and anything not declared on the model's schema.
- *   2. Passes each declared field's value through unchanged, including
- *      JSON-typed fields, which are sent as objects rather than pre-serialized
- *      strings (see the note in the body for why).
+ *   2. Takes a fresh plain JSON snapshot of the projected values. JSON-typed
+ *      fields stay objects rather than pre-serialized strings, while reactive
+ *      proxies cannot leak into persistence or the wire payload.
  *
  * For updates (`dropUndefined: true`), `undefined` values are also removed so
  * they are not written as `SET column = NULL` on the server.
  *
  * Field metadata comes from the model registry, populated when the schema is
  * registered at initialization. If a model has no registered field metadata —
- * for example a manually registered model — projection passes the serialized
- * data through unchanged apart from dropping the framework keys.
+ * for example a manually registered model — projection snapshots all serialized
+ * data apart from the framework keys.
  */
 export function projectCommitPayload(modelName, source, opts) {
-    const metadata = getActiveRegistry().getMetadata(modelName);
+    const metadata = getContext().getModelMetadata(modelName);
     const fields = metadata?.fields;
     const out = {};
     if (!fields) {
@@ -48,7 +48,7 @@ export function projectCommitPayload(modelName, source, opts) {
                 continue;
             out[k] = v;
         }
-        return out;
+        return snapshotJsonValue(out, '$.input');
     }
     for (const key of Object.keys(fields)) {
         if (!(key in source))
@@ -73,7 +73,7 @@ export function projectCommitPayload(modelName, source, opts) {
         // to jsonb correctly once the column is identified as jsonb.
         out[key] = value;
     }
-    return out;
+    return snapshotJsonValue(out, '$.input');
 }
 export const normalizeModelKey = (modelName) => modelName.replace('Model', '').toLowerCase();
 export const stripModelSuffix = (modelName) => modelName.replace('Model', '');

package/dist/transactions/{deltaConfirmation.d.ts → mutations/deltaConfirmation.d.ts}

@@ -1,16 +1,16 @@
 /**
  * Tracks whether the confirming delta for a write has arrived. It holds the
- * acknowledgement watermark (through the shared {@link SyncPosition}), the
+ * acknowledgement watermark (through the shared {@link LogPosition}), the
  * per-transaction confirmation timeouts, and the retry-with-backoff and
  * reconciliation policy for transactions in the `awaiting_delta` status. It
- * reaches back to {@link TransactionQueue} only through the small
+ * reaches back to {@link MutationQueue} only through the small
  * {@link DeltaConfirmationContext} interface, not the queue class itself, so it
  * has no cyclic dependency and can be tested on its own.
  */
-import type { SyncPosition } from '../sync/syncPosition.js';
-import type { Transaction } from './commitPayload.js';
+import type { LogPosition } from '../../transaction/logPosition.js';
+import type { QueuedMutation } from './commitPayload.js';
 /**
- * The subset of {@link TransactionQueue} that the confirmation tracker needs:
+ * The subset of {@link MutationQueue} that the confirmation tracker needs:
  * store lookups and status changes, removing optimistic entries once a write
  * confirms, the queue's event emitter (`transaction:completed`,
  * `reconciliation:needed`, and so on), a connection check (so timeouts
@@ -20,16 +20,16 @@ import type { Transaction } from './commitPayload.js';
  */
 export interface DeltaConfirmationContext {
     store: {
-        get(id: string): Transaction | undefined;
-        getByStatus(status: Transaction['status']): Transaction[];
-        updateStatus(id: string, status: Transaction['status']): void;
+        get(id: string): QueuedMutation | undefined;
+        getByStatus(status: QueuedMutation['status']): QueuedMutation[];
+        updateStatus(id: string, status: QueuedMutation['status']): void;
     };
     optimisticUpdates: {
         delete(id: string): boolean;
     };
     emit(event: string, payload?: unknown): void;
     isConnected(): boolean;
-    position: SyncPosition;
+    position: LogPosition;
 }
 export declare class DeltaConfirmationTracker {
     private readonly ctx;
@@ -48,11 +48,11 @@ export declare class DeltaConfirmationTracker {
      * @param syncId - The sync id of the received delta.
      */
     onDeltaReceived(syncId: number, correlationId?: string): void;
-    scheduleDeltaConfirmationTimeout(tx: Transaction, timeoutMs: number): void;
+    scheduleDeltaConfirmationTimeout(tx: QueuedMutation, timeoutMs: number): void;
     private cancelDeltaConfirmationTimeout;
     /**
      * Clears every armed confirmation timer, one per in-flight transaction.
-     * {@link TransactionQueue.dispose} calls this; without it a disposed queue
+     * {@link MutationQueue.dispose} calls this; without it a disposed queue
      * would keep the process alive and fire callbacks against a cleared store.
      */
     dispose(): void;

package/dist/transactions/{deltaConfirmation.js → mutations/deltaConfirmation.js}

@@ -1,13 +1,13 @@
 /**
  * Tracks whether the confirming delta for a write has arrived. It holds the
- * acknowledgement watermark (through the shared {@link SyncPosition}), the
+ * acknowledgement watermark (through the shared {@link LogPosition}), the
  * per-transaction confirmation timeouts, and the retry-with-backoff and
  * reconciliation policy for transactions in the `awaiting_delta` status. It
- * reaches back to {@link TransactionQueue} only through the small
+ * reaches back to {@link MutationQueue} only through the small
  * {@link DeltaConfirmationContext} interface, not the queue class itself, so it
  * has no cyclic dependency and can be tested on its own.
  */
-import { getContext } from '../context.js';
+import { getContext } from '../../context.js';
 export class DeltaConfirmationTracker {
     ctx;
     // Retry configuration for delta confirmation, using exponential backoff.
@@ -118,7 +118,7 @@ export class DeltaConfirmationTracker {
         // rejection instead of a catchable synchronous error.
         const timeoutHandle = setTimeout(() => {
             const currentTx = this.ctx.store.get(tx.id);
-            if (!currentTx || currentTx.status !== 'awaiting_delta') {
+            if (currentTx?.status !== 'awaiting_delta') {
                 this.deltaConfirmationRetries.delete(tx.id);
                 return; // Already confirmed or failed
             }
@@ -126,7 +126,7 @@ export class DeltaConfirmationTracker {
             if (!this.ctx.isConnected()) {
                 // Self-healing: re-schedule the confirmation wait while offline, no
                 // consumer action needed → debug.
-                getContext().logger.debug('[TransactionQueue] Timeout fired while disconnected - re-scheduling', {
+                getContext().logger.debug('[MutationQueue] Timeout fired while disconnected - re-scheduling', {
                     txId: tx.id.slice(0, 8),
                     model: tx.modelName,
                 });
@@ -165,7 +165,7 @@ export class DeltaConfirmationTracker {
                 });
                 // Self-healing retry with backoff — the server already committed; we're
                 // just waiting on the delta. No consumer action → debug.
-                getContext().logger.debug('[TransactionQueue] Re-scheduling with backoff', {
+                getContext().logger.debug('[MutationQueue] Re-scheduling with backoff', {
                     txId: tx.id.slice(0, 8),
                     model: tx.modelName,
                     nextTimeoutMs: nextTimeout,
@@ -220,7 +220,7 @@ export class DeltaConfirmationTracker {
     }
     /**
      * Clears every armed confirmation timer, one per in-flight transaction.
-     * {@link TransactionQueue.dispose} calls this; without it a disposed queue
+     * {@link MutationQueue.dispose} calls this; without it a disposed queue
      * would keep the process alive and fire callbacks against a cleared store.
      */
     dispose() {

package/dist/transactions/mutations/durableWriteStore.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The durable-write port moved to the settlement core (ADR 0016): it is a
+ * contract over commit envelopes and holds no local rows. Re-exported here so
+ * the existing `transactions/mutations/durableWriteStore` import path keeps
+ * resolving for the queue, the outbox, and the client options.
+ *
+ * The port and its config live in the core's `durableWrites` module (a behavior
+ * contract, not a persisted shape); the records that cross it are owned by
+ * `transactions/settlement/pendingWrite`.
+ */
+export { durableWriteStoreSchema, durableWritesConfigSchema, } from '../../transaction/durableWrites.js';
+export type { DurableWriteStore, DurableWritesConfig, } from '../../transaction/durableWrites.js';
+export { pendingWriteSchema } from '../../transaction/transactions/settlement/pendingWrite.js';
+export type { PendingWrite } from '../../transaction/transactions/settlement/pendingWrite.js';

package/dist/transactions/mutations/durableWriteStore.js

@@ -0,0 +1,12 @@
+/**
+ * The durable-write port moved to the settlement core (ADR 0016): it is a
+ * contract over commit envelopes and holds no local rows. Re-exported here so
+ * the existing `transactions/mutations/durableWriteStore` import path keeps
+ * resolving for the queue, the outbox, and the client options.
+ *
+ * The port and its config live in the core's `durableWrites` module (a behavior
+ * contract, not a persisted shape); the records that cross it are owned by
+ * `transactions/settlement/pendingWrite`.
+ */
+export { durableWriteStoreSchema, durableWritesConfigSchema, } from '../../transaction/durableWrites.js';
+export { pendingWriteSchema } from '../../transaction/transactions/settlement/pendingWrite.js';

package/dist/transactions/{optimisticApply.d.ts → mutations/optimisticApply.d.ts}

@@ -8,8 +8,8 @@
  * than any larger object, so the rules have no dependencies of their own and
  * can be tested in isolation.
  */
-import type { Model } from '../Model.js';
-import type { MutationInput, Transaction } from './commitPayload.js';
+import type { Model } from '../../Model.js';
+import type { MutationInput, QueuedMutation } from './commitPayload.js';
 /**
  * One tracked optimistic mutation: the live model plus the value it held
  * before the change, kept so a rollback can restore it.
@@ -17,7 +17,7 @@ import type { MutationInput, Transaction } from './commitPayload.js';
 export interface OptimisticUpdateEntry {
     model: Model;
     previousState: MutationInput | null | undefined;
-    transaction: Transaction;
+    transaction: QueuedMutation;
 }
 /**
  * The event emitter these functions use to announce each optimistic change and
@@ -30,20 +30,20 @@ export interface OptimisticEmitter {
  * Record an optimistic create and announce it. There is no prior value to
  * restore, so the rollback pre-image is `null`.
  */
-export declare function applyOptimisticCreate(optimisticUpdates: Map<string, OptimisticUpdateEntry>, emitter: OptimisticEmitter, model: Model, transaction: Transaction): void;
+export declare function applyOptimisticCreate(optimisticUpdates: Map<string, OptimisticUpdateEntry>, emitter: OptimisticEmitter, model: Model, transaction: QueuedMutation): void;
 /**
  * Record an optimistic update and announce it, keeping the row's prior value so
  * a rollback can put it back.
  */
-export declare function applyOptimisticUpdate(optimisticUpdates: Map<string, OptimisticUpdateEntry>, emitter: OptimisticEmitter, model: Model, transaction: Transaction): void;
+export declare function applyOptimisticUpdate(optimisticUpdates: Map<string, OptimisticUpdateEntry>, emitter: OptimisticEmitter, model: Model, transaction: QueuedMutation): void;
 /**
  * Record an optimistic delete and announce it, keeping the deleted row so a
  * rollback can restore it.
  */
-export declare function applyOptimisticDelete(optimisticUpdates: Map<string, OptimisticUpdateEntry>, emitter: OptimisticEmitter, model: Model, transaction: Transaction): void;
+export declare function applyOptimisticDelete(optimisticUpdates: Map<string, OptimisticUpdateEntry>, emitter: OptimisticEmitter, model: Model, transaction: QueuedMutation): void;
 /**
  * Undo an optimistic mutation by its transaction id: emit `optimistic:rollback`
  * with the saved pre-image so listeners can restore the prior value, then drop
  * the ledger entry. Does nothing if the transaction was never tracked.
  */
-export declare function rollbackOptimistic(optimisticUpdates: Map<string, OptimisticUpdateEntry>, emitter: OptimisticEmitter, transaction: Transaction, reason?: string, error?: Error): Promise<void>;
+export declare function rollbackOptimistic(optimisticUpdates: Map<string, OptimisticUpdateEntry>, emitter: OptimisticEmitter, transaction: QueuedMutation, reason?: string, error?: Error): Promise<void>;

package/dist/transactions/{replayValidation.d.ts → mutations/replayValidation.d.ts}

@@ -15,7 +15,7 @@
  * quietly rather than flagged as corruption.
  */
 import { z } from 'zod';
-import type { Transaction } from './commitPayload.js';
+import type { QueuedMutation } from './commitPayload.js';
 /**
  * The shape of a persisted transaction that can be replayed: the fields the
  * transaction queue reads when it re-enqueues the row — its id, operation type,
@@ -73,12 +73,12 @@ export type PersistedReplayableTransaction = z.infer<typeof persistedTransaction
  */
 export declare function isNonReplayablePersistedRow(row: unknown): boolean;
 /**
- * Validates one stored row and rehydrates it into a {@link Transaction} ready
+ * Validates one stored row and rehydrates it into a {@link QueuedMutation} ready
  * to replay, or returns `null` when the row fails validation. Bookkeeping
  * fields the stored row lacks — status, attempts, priority, timestamp — are
  * re-derived the same way a freshly staged transaction derives them.
  */
-export declare function deserializePersistedTransaction(row: unknown): Transaction | null;
+export declare function deserializePersistedTransaction(row: unknown): QueuedMutation | null;
 /**
  * The shape of one entry in the persisted offline mutation queue — an item of
  * the `'queue'` row's `mutations` array, carrying the fields read when the

package/dist/transactions/{replayValidation.js → mutations/replayValidation.js}

@@ -16,12 +16,13 @@
  */
 import { z } from 'zod';
 import { computePriorityScore, normalizeModelKey } from './commitPayload.js';
-import { commitEnvelopeMemberSchema, commitOutboxScopeSchema, } from './commitEnvelope.js';
+import { commitEnvelopeMemberSchema, commitOutboxScopeSchema, } from '../../transaction/transactions/settlement/commitEnvelope.js';
+import { onStaleModeSchema } from '../../transaction/coordination/schema.js';
 /** The subset of a write's options that is stored with each transaction or queued mutation. */
 const persistedWriteOptionsSchema = z
     .object({
     readAt: z.number().nullable().optional(),
-    onStale: z.enum(['reject', 'overwrite', 'notify']).nullable().optional(),
+    onStale: onStaleModeSchema.nullable().optional(),
     idempotencyKey: z.string().optional(),
     label: z.string().optional(),
     // Aligned with the `WriteOptions` type: a claimed write persisted offline
@@ -81,7 +82,7 @@ export function isNonReplayablePersistedRow(row) {
         NON_REPLAYABLE_TYPES.has(row.type));
 }
 /**
- * Validates one stored row and rehydrates it into a {@link Transaction} ready
+ * Validates one stored row and rehydrates it into a {@link QueuedMutation} ready
  * to replay, or returns `null` when the row fails validation. Bookkeeping
  * fields the stored row lacks — status, attempts, priority, timestamp — are
  * re-derived the same way a freshly staged transaction derives them.

package/dist/utils/mobxSetup.d.ts

@@ -5,7 +5,7 @@
  * each field, leaving any hand-written getter or setter in place.
  */
 import { type AnnotationMapEntry } from 'mobx';
-import { type PropertyMetadata, type ReferenceMetadata } from '../types/index.js';
+import { type PropertyMetadata, type ReferenceMetadata } from '../transaction/types/index.js';
 /**
  * The subset of a model instance that {@link M1} reads and writes. A model calls
  * {@link M1} from its constructor, where these members exist on `this`;

package/dist/utils/mobxSetup.js

@@ -5,7 +5,7 @@
  * each field, leaving any hand-written getter or setter in place.
  */
 import { observable, makeObservable, action, computed, observe, } from 'mobx';
-import { PropertyType } from '../types/index.js';
+import { PropertyType } from '../transaction/types/index.js';
 import { getContext } from '../context.js';
 /**
  * Makes a model instance's schema-defined properties observable with MobX. For
@@ -140,7 +140,10 @@ export function M1(target, propertyMetadata, referenceMetadata) {
         annotations.updatedAt = observable;
     }
     if (!hasGetter('modifiedProperties') && !hasSetter('modifiedProperties')) {
-        annotations.modifiedProperties = observable;
+        // Track map membership, but keep change payloads as plain values. These
+        // entries are replaced rather than mutated and later cross IndexedDB's
+        // structured-clone boundary, where MobX's deep proxies are invalid.
+        annotations.modifiedProperties = observable.shallow;
     }
     // Add actions only if methods exist and aren't already actions.
     // `Reflect.get` keeps the read typed without an index-signature

package/dist/webhooks/events.d.ts

@@ -7,10 +7,10 @@ export interface AbloWebhookEvent {
     /** A stable, unique event identifier equal to `String(syncId)`. Use it to
      *  deduplicate deliveries. */
     readonly id: string;
-    /** The event type, formatted as `<model>.<verb>`, such as `"slide.updated"`.
+    /** The event type, formatted as `<model>.<verb>`, such as `"report.updated"`.
      *  Branch on this to route the event. */
     readonly type: string;
-    /** The name of the model whose row changed, such as `"Slide"`. */
+    /** The name of the model whose row changed, such as `"Report"`. */
     readonly model: string;
     /** The identifier of the row that changed. */
     readonly objectId: string;

package/dist/wire/index.d.ts

@@ -1,34 +1 @@
-/**
- * The wire contract for the sync protocol: the HTTP envelope shapes and the
- * write-path frames, with no dependency on the client runtime. A server — a
- * route handler, an edge function — can import the envelope producers here
- * without pulling in the full sync client.
- *
- * It has two halves, used across every endpoint:
- *   - Error responses — {@link errorEnvelope}, {@link ErrorEnvelope}, and
- *     {@link statusForType} turn any thrown value into the uniform
- *     `{ type, code, param, message, doc_url, request_id }` body.
- *   - List responses — {@link listEnvelope} and {@link ListEnvelope} stamp the
- *     uniform `{ object: 'list', data, has_more, next_cursor }` collection.
- *
- * The {@link AbloError} hierarchy, {@link docUrlForCode}, and the wire-parsing
- * helpers are re-exported too, so a single import lets a route throw the right
- * typed error and serialize it back out.
- */
-export { errorEnvelope, statusForType } from './errorEnvelope.js';
-export type { ErrorEnvelope } from './errorEnvelope.js';
-export { listEnvelope } from './listEnvelope.js';
-export type { ListEnvelope } from './listEnvelope.js';
-export { bootstrapReasonSchema } from './bootstrapReason.js';
-export type { BootstrapReason } from './bootstrapReason.js';
-export { commitOperationSchema, commitPayloadSchema, } from './frames.js';
-export { PROTOCOL_VERSION, MIN_SUPPORTED_PROTOCOL_VERSION, DEFAULT_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, WS_CLOSE_PROTOCOL_VERSION, PROTOCOL_VERSION_HEADER, protocolVersionProblem, resolveProtocolVersion, } from './protocolVersion.js';
-export type { SupportedProtocolVersion, ProtocolVersionProblem, } from './protocolVersion.js';
-export type { CommitOperation, CommitMessage, MutationResultMessage, } from './frames.js';
-export { COMMIT_CORRELATION_ID_MAX_LENGTH, correlationIdSchema, commitStatusSchema, commitSettlementSchema, commitReceiptSchema, legacyCompatibleCommitReceiptSchema, rejectedCommitReceiptSchema, mutationResultPayloadSchema, mutationResultMessageSchema, commitAckSchema, mutationCommitResultSchema, } from './commit.js';
-export type { CorrelationId, CommitStatus, CommitSettlement, CommitReceiptWire, RejectedCommitReceiptWire, MutationResultPayload, MutationResultMessageWire, CommitAck, MutationCommitResultInput, MutationCommitResult, } from './commit.js';
-export { participantKindSchema, confirmationStateSchema, syncDeltaActionSchema, wireDeltaDataSchema, participantRefSchema, syncDeltaWireCoreSchema, clientSyncDeltaSchema, serverSyncDeltaSchema, } from './delta.js';
-export type { ParticipantKind, ConfirmationState, SyncDeltaAction, WireDeltaData, ParticipantRef, SyncDeltaWireCore, ClientSyncDelta, ServerSyncDelta, } from './delta.js';
-export { AbloError, AbloAuthenticationError, AbloPermissionError, AbloValidationError, AbloRateLimitError, AbloIdempotencyError, AbloConnectionError, AbloServerError, AbloStaleContextError, AbloClaimedError, CapabilityError, SyncSessionError, docUrlForCode, translateHttpError, errorFromWire, toAbloError, ERROR_CONTRACT_VERSION, errorCodeSpec, } from '../errors.js';
-export type { ErrorCode, WireErrorCode } from '../errors.js';
-export { PING_INTERVAL_MS, LEASE_TTL_MS, WS_BEARER_SUBPROTOCOL_PREFIX, WS_SYNC_SUBPROTOCOL, } from './protocol.js';
+export * from '../transaction/wire/index.js';