@abloatai/ablo 0.34.1 → 0.36.0

package/dist/transactions/{TransactionStore.d.ts → mutations/MutationStore.d.ts}

@@ -3,18 +3,18 @@
  * 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
+ * {@link MutationQueue} 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 {
+import type { QueuedMutation } from './commitPayload.js';
+export declare class MutationStore {
     private transactions;
     private byStatus;
-    add(transaction: Transaction): void;
-    get(id: string): Transaction | undefined;
-    updateStatus(id: string, newStatus: Transaction['status']): void;
-    getByStatus(status: Transaction['status']): Transaction[];
+    add(transaction: QueuedMutation): void;
+    get(id: string): QueuedMutation | undefined;
+    updateStatus(id: string, newStatus: QueuedMutation['status']): void;
+    getByStatus(status: QueuedMutation['status']): QueuedMutation[];
     remove(id: string): void;
     clear(): void;
-    getAll(): Transaction[];
+    getAll(): QueuedMutation[];
 }

package/dist/transactions/{TransactionStore.js → mutations/MutationStore.js}

@@ -3,10 +3,10 @@
  * 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
+ * {@link MutationQueue} owns an instance and routes every status change
  * through {@link updateStatus}, which keeps the two indexes consistent.
  */
-export class TransactionStore {
+export class MutationStore {
     transactions = new Map();
     byStatus = new Map();
     add(transaction) {

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

@@ -1,6 +1,6 @@
 /**
  * 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
+ * causal order is preserved. {@link MutationQueue} calls into these through a
  * small store-shaped interface:
  *
  *   - Create-then-delete cancellation ({@link takeUnsentCreateForModel}):
@@ -16,11 +16,11 @@
  * 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 subset of {@link TransactionStore} that the coalescing rules read. */
-export interface TransactionStoreLike {
-    get(id: string): Transaction | undefined;
-    getByStatus(status: Transaction['status']): Transaction[];
+import type { MutationInput, QueuedMutation } from './commitPayload.js';
+/** The subset of {@link MutationStore} that the coalescing rules read. */
+export interface MutationStoreLike {
+    get(id: string): QueuedMutation | undefined;
+    getByStatus(status: QueuedMutation['status']): QueuedMutation[];
 }
 export declare const entityKey: (modelName: string, modelId: string) => string;
 /**
@@ -30,25 +30,25 @@ export declare const entityKey: (modelName: string, modelId: string) => string;
  * 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;
+export declare function takeUnsentCreateForModel(staged: QueuedMutation[], queued: QueuedMutation[], store: Pick<MutationStoreLike, 'getByStatus'>, modelName: string, modelId: string): QueuedMutation | 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;
+export declare function findCreateBarrierForDelete(store: Pick<MutationStoreLike, 'getByStatus'>, modelName: string, modelId: string): QueuedMutation | 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;
+export declare function deferDeleteUntilCreateSettles(deferredDeletesByCreate: Map<string, QueuedMutation[]>, createTransaction: QueuedMutation, deleteTransaction: QueuedMutation): 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;
+export declare function releaseDeferredDeletesForCreate(deferredDeletesByCreate: Map<string, QueuedMutation[]>, store: Pick<MutationStoreLike, 'get'>, enqueue: (transaction: QueuedMutation) => void, createTransaction: QueuedMutation): 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

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

@@ -1,6 +1,6 @@
 /**
  * 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
+ * causal order is preserved. {@link MutationQueue} calls into these through a
  * small store-shaped interface:
  *
  *   - Create-then-delete cancellation ({@link takeUnsentCreateForModel}):

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

@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+/**
+ * The slice of an event emitter this module needs. Declared structurally so a
+ * plain object can stand in under test — `MutationQueue` satisfies it by
+ * extending `EventEmitter`.
+ */
+export interface CommitEventSource {
+    on(event: string, listener: (payload: unknown) => void): unknown;
+    off(event: string, listener: (payload: unknown) => void): unknown;
+}
+/** One completed commit, broken into its local and remote halves. */
+export interface CommitLatencySample {
+    /** The commit's `clientTxId`, identical to its transaction id. */
+    clientTxId: string;
+    /** Milliseconds sealing the durable envelope locally. */
+    sealMs: number;
+    /** Milliseconds from sealed envelope to acknowledgement. */
+    ackMs: number;
+    /** Milliseconds from staging to acknowledgement — `sealMs + ackMs`. */
+    totalMs: number;
+}
+/**
+ * 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 declare function observeCommitLatency(source: CommitEventSource, onSample: (sample: CommitLatencySample) => void): () => void;

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,11 @@
  * 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 type { RuntimeContext } from '../../RuntimeContext.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 +27,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 {
+}, runtime?: RuntimeContext): MutationInput;
+export interface QueuedMutation {
     id: string;
     type: 'create' | 'update' | 'delete' | 'archive' | 'unarchive';
     modelName: string;
@@ -95,7 +97,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 +119,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, runtime?: RuntimeContext) => 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 +137,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 { globalRuntime } 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);
+export function projectCommitPayload(modelName, source, opts, runtime = globalRuntime) {
+    const metadata = runtime.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', '');
@@ -90,8 +90,8 @@ export const stripModelSuffix = (modelName) => modelName.replace('Model', '');
  * foreign-key ordering because the row already exists, so they all share the
  * configured default non-create priority.
  */
-export const computePriorityScore = (type, modelName) => {
-    const { modelCreatePriority, defaultCreatePriority, defaultNonCreatePriority } = getContext().config;
+export const computePriorityScore = (type, modelName, runtime = globalRuntime) => {
+    const { modelCreatePriority, defaultCreatePriority, defaultNonCreatePriority } = runtime.config;
     if (type !== 'create')
         return defaultNonCreatePriority;
     return modelCreatePriority.get(modelName) ?? defaultCreatePriority;

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

@@ -1,16 +1,17 @@
 /**
  * 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 { RuntimeContext } from '../../RuntimeContext.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 +21,18 @@ 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;
+    /** The owning client's runtime. Defaults to the module-global bridge. */
+    runtime?: RuntimeContext;
 }
 export declare class DeltaConfirmationTracker {
     private readonly ctx;
@@ -37,6 +40,7 @@ export declare class DeltaConfirmationTracker {
     private static readonly DELTA_MAX_TIMEOUT_MS;
     private deltaConfirmationTimeouts;
     private deltaConfirmationRetries;
+    private readonly runtime;
     constructor(ctx: DeltaConfirmationContext);
     /** Applied-cursor alias, kept so the read sites below stay legible. */
     private get lastSeenSyncId();
@@ -48,11 +52,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;