@abloatai/ablo 0.35.0 → 0.37.0

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

@@ -1,20 +0,0 @@
-/**
- * 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 MutationQueue} owns an instance and routes every status change
- * through {@link updateStatus}, which keeps the two indexes consistent.
- */
-import type { QueuedMutation } from './commitPayload.js';
-export declare class MutationStore {
-    private transactions;
-    private byStatus;
-    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(): QueuedMutation[];
-}

package/dist/transactions/mutations/MutationStore.js

@@ -1,53 +0,0 @@
-/**
- * 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 MutationQueue} owns an instance and routes every status change
- * through {@link updateStatus}, which keeps the two indexes consistent.
- */
-export class MutationStore {
-    transactions = new Map();
-    byStatus = new Map();
-    add(transaction) {
-        this.transactions.set(transaction.id, transaction);
-        if (!this.byStatus.has(transaction.status)) {
-            this.byStatus.set(transaction.status, new Set());
-        }
-        this.byStatus.get(transaction.status).add(transaction.id);
-    }
-    get(id) {
-        return this.transactions.get(id);
-    }
-    updateStatus(id, newStatus) {
-        const tx = this.transactions.get(id);
-        if (!tx)
-            return;
-        this.byStatus.get(tx.status)?.delete(id);
-        tx.status = newStatus;
-        if (!this.byStatus.has(newStatus)) {
-            this.byStatus.set(newStatus, new Set());
-        }
-        this.byStatus.get(newStatus).add(id);
-    }
-    getByStatus(status) {
-        const ids = this.byStatus.get(status) || new Set();
-        return Array.from(ids)
-            .map((id) => this.transactions.get(id))
-            .filter(Boolean);
-    }
-    remove(id) {
-        const tx = this.transactions.get(id);
-        if (!tx)
-            return;
-        this.transactions.delete(id);
-        this.byStatus.get(tx.status)?.delete(id);
-    }
-    clear() {
-        this.transactions.clear();
-        this.byStatus.clear();
-    }
-    getAll() {
-        return Array.from(this.transactions.values());
-    }
-}

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

@@ -1,82 +0,0 @@
-/**
- * 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/mutations/UnconfirmedWrites.js

@@ -1,104 +0,0 @@
-/**
- * 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/mutations/coalesceRules.d.ts

@@ -1,58 +0,0 @@
-/**
- * The queue's rules for coalescing operations that touch the same row, so their
- * causal order is preserved. {@link MutationQueue} calls into these through a
- * small store-shaped interface:
- *
- *   - 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 keeps the `enqueue` and `delete` methods that orchestrate optimistic
- * state and events; these functions hold only the coalescing rules.
- */
-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;
-/**
- * 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: 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<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, 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, 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
- * 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/mutations/coalesceRules.js

@@ -1,140 +0,0 @@
-/**
- * The queue's rules for coalescing operations that touch the same row, so their
- * causal order is preserved. {@link MutationQueue} calls into these through a
- * small store-shaped interface:
- *
- *   - 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 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;
-/**
- * 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' &&
-        tx.status === 'pending' &&
-        tx.attempts === 0 &&
-        isTransactionForModel(tx, modelName, modelId);
-    const stagedIndex = staged.findIndex(isUnsentCreate);
-    if (stagedIndex >= 0) {
-        return staged.splice(stagedIndex, 1)[0];
-    }
-    const queuedIndex = queued.findIndex(isUnsentCreate);
-    if (queuedIndex >= 0) {
-        return queued.splice(queuedIndex, 1)[0];
-    }
-    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'),
-        ...store.getByStatus('executing'),
-        ...store.getByStatus('awaiting_delta'),
-    ].filter((tx) => tx.type === 'create' &&
-        isTransactionForModel(tx, modelName, modelId) &&
-        // A never-attempted pending create can be cancelled instead. Once the
-        // create has been sent, even a retry-pending state is a causal barrier:
-        // the server may already have applied it and only the response was lost.
-        (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);
-    if (!deferred || deferred.length === 0)
-        return;
-    deferredDeletesByCreate.delete(key);
-    for (const deleteTransaction of deferred) {
-        if (store.get(deleteTransaction.id)?.status !== 'pending')
-            continue;
-        enqueue(deleteTransaction);
-    }
-}
-/**
- * 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 || {};
-    for (const key of Object.keys(src)) {
-        // Special case: metadata payloads may be JSON strings; merge objects instead of clobbering
-        if (key === 'metadata') {
-            const l = out.metadata;
-            const r = src.metadata;
-            // If both sides undefined/null, continue
-            if (l == null && r == null) {
-                continue;
-            }
-            // Normalize to objects
-            const toObj = (v) => {
-                if (v == null)
-                    return {};
-                if (typeof v === 'string') {
-                    try {
-                        return JSON.parse(v);
-                    }
-                    catch {
-                        return {};
-                    }
-                }
-                if (typeof v === 'object')
-                    return v;
-                return {};
-            };
-            const lobj = toObj(l);
-            const robj = toObj(r);
-            const merged = { ...lobj, ...robj };
-            // Re-stringify to match schema input type
-            try {
-                out.metadata = JSON.stringify(merged);
-            }
-            catch {
-                // Fallback to right-hand side if stringify fails
-                out.metadata = typeof r === 'string' ? r : JSON.stringify(robj || {});
-            }
-            continue;
-        }
-        // Default: shallow overwrite with right-hand value
-        out[key] = src[key];
-    }
-    return out;
-}

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

@@ -1,52 +0,0 @@
-/**
- * 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

@@ -1,130 +0,0 @@
-/**
- * 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/mutations/commitOutboxStore.d.ts

@@ -1,28 +0,0 @@
-/**
- * Narrow persistence port for crash-durable commit envelopes.
- *
- * Browser clients use {@link DatabaseCommitOutboxStore}. Agent/Node hosts can
- * inject a workflow-, SQLite-, or filesystem-backed implementation without
- * coupling MutationQueue to the browser database/cache implementation.
- */
-import type { DurableWriteStore, PendingWrite } from './durableWriteStore.js';
-/**
- * The exact subset of the browser `Database` that {@link DatabaseCommitOutboxStore}
- * drives. Typing the adapter to this narrow port instead of importing the
- * concrete `Database` class keeps the outbox store off the
- * `Database → DatabaseManager → ModelRegistry → BaseSyncedStore` import cycle;
- * the real `Database` still satisfies it structurally, so callers are unchanged.
- */
-export interface CommitOutboxDatabase {
-    sealTransactionRecord(record: PendingWrite, consumedRecordIds: readonly string[]): Promise<unknown>;
-    getPersistedTransactions(): Promise<readonly unknown[]>;
-    removeTransaction(id: string): Promise<void>;
-}
-/** Strict IndexedDB adapter backed by Database's `__transactions` store. */
-export declare class DatabaseCommitOutboxStore implements DurableWriteStore {
-    private readonly database;
-    constructor(database: CommitOutboxDatabase);
-    seal(envelope: PendingWrite, consumedRecordIds: readonly string[]): Promise<void>;
-    list(): Promise<readonly unknown[]>;
-    remove(envelopeRecordId: string): Promise<void>;
-}