@abloatai/ablo 0.24.0 → 0.26.0

package/dist/transactions/TransactionStore.d.ts

@@ -0,0 +1,18 @@
+/**
+ * In-memory transaction index — id map plus a by-status secondary index so
+ * the queue's hot paths (`getByStatus('pending')` on every batch/coalesce
+ * decision) stay O(status bucket) instead of O(all transactions). Lifted out
+ * of `TransactionQueue.ts` as a stateful leaf with no queue coupling.
+ */
+import type { Transaction } from './commitPayload.js';
+export declare class TransactionStore {
+    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[];
+    remove(id: string): void;
+    clear(): void;
+    getAll(): Transaction[];
+}

package/dist/transactions/TransactionStore.js

@@ -0,0 +1,51 @@
+/**
+ * In-memory transaction index — id map plus a by-status secondary index so
+ * the queue's hot paths (`getByStatus('pending')` on every batch/coalesce
+ * decision) stay O(status bucket) instead of O(all transactions). Lifted out
+ * of `TransactionQueue.ts` as a stateful leaf with no queue coupling.
+ */
+export class TransactionStore {
+    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/coalesceRules.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Coalescing rules — the queue's same-entity causality guards, lifted out of
+ * `TransactionQueue.ts` as a leaf over a minimal store-shaped interface:
+ *
+ *   • create-then-delete cancellation (`takeUnsentCreateForModel`): a delete
+ *     of a row whose create never left the client cancels both locally;
+ *   • the create barrier (`findCreateBarrierForDelete`) + deferred-delete
+ *     parking (`deferDeleteUntilCreateSettles` / `release…`): once a create
+ *     HAS been sent, a delete must wait for it to settle or the server could
+ *     see DELETE-before-CREATE;
+ *   • update-payload merging (`mergeUpdateData`): collapses rapid same-entity
+ *     updates into one wire op.
+ *
+ * The queue's `enqueue`/`delete` verbs stay in the host (they orchestrate
+ * optimistic state + events); the RULES live here.
+ */
+import type { MutationInput, Transaction } from './commitPayload.js';
+/** The slice of `TransactionStore` the coalescing rules read. */
+export interface TransactionStoreLike {
+    get(id: string): Transaction | undefined;
+    getByStatus(status: Transaction['status']): Transaction[];
+}
+export declare const entityKey: (modelName: string, modelId: string) => string;
+/**
+ * Find-and-remove a create for (model, id) that has never been sent —
+ * checking the microtask staging area, the execution queue, and the store's
+ * pending bucket, in that order. Splices the winner out of whichever queue
+ * held it so the caller can cancel it instead of shipping create+delete.
+ */
+export declare function takeUnsentCreateForModel(staged: Transaction[], queued: Transaction[], store: Pick<TransactionStoreLike, 'getByStatus'>, modelName: string, modelId: string): Transaction | undefined;
+export declare function findCreateBarrierForDelete(store: Pick<TransactionStoreLike, 'getByStatus'>, modelName: string, modelId: string): Transaction | undefined;
+export declare function deferDeleteUntilCreateSettles(deferredDeletesByCreate: Map<string, Transaction[]>, createTransaction: Transaction, deleteTransaction: Transaction): void;
+export declare function releaseDeferredDeletesForCreate(deferredDeletesByCreate: Map<string, Transaction[]>, store: Pick<TransactionStoreLike, 'get'>, enqueue: (transaction: Transaction) => void, createTransaction: Transaction): void;
+export declare function mergeUpdateData(left: MutationInput | undefined, right: MutationInput | undefined, _modelName?: string): MutationInput;

package/dist/transactions/coalesceRules.js

@@ -0,0 +1,117 @@
+/**
+ * Coalescing rules — the queue's same-entity causality guards, lifted out of
+ * `TransactionQueue.ts` as a leaf over a minimal store-shaped interface:
+ *
+ *   • create-then-delete cancellation (`takeUnsentCreateForModel`): a delete
+ *     of a row whose create never left the client cancels both locally;
+ *   • the create barrier (`findCreateBarrierForDelete`) + deferred-delete
+ *     parking (`deferDeleteUntilCreateSettles` / `release…`): once a create
+ *     HAS been sent, a delete must wait for it to settle or the server could
+ *     see DELETE-before-CREATE;
+ *   • update-payload merging (`mergeUpdateData`): collapses rapid same-entity
+ *     updates into one wire op.
+ *
+ * The queue's `enqueue`/`delete` verbs stay in the host (they orchestrate
+ * optimistic state + events); the RULES live here.
+ */
+export const entityKey = (modelName, modelId) => `${modelName}:${modelId}`;
+const isTransactionForModel = (transaction, modelName, modelId) => transaction.modelName === modelName && transaction.modelId === modelId;
+/**
+ * Find-and-remove a create for (model, id) that has never been sent —
+ * checking the microtask staging area, the execution queue, and the store's
+ * pending bucket, in that order. Splices the winner out of whichever queue
+ * held it so the caller can cancel it instead of shipping create+delete.
+ */
+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);
+}
+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];
+}
+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);
+}
+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);
+    }
+}
+// Merge two GraphQL update payloads with special handling for metadata fields
+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/commitPayload.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Commit-payload projection — the queue's wire vocabulary, lifted out of
+ * `TransactionQueue.ts` as a pure leaf (no queue state, no timers).
+ *
+ * Owns the `Transaction` record shape plus every helper that turns a local
+ * transaction into a wire-safe commit operation: schema-field projection
+ * (`projectCommitPayload`), write-option projection (`applyWriteOptions`),
+ * FK-aware priority scoring, and the transport-error duck-typing used to
+ * classify server rejections. Because nothing here touches the queue's
+ * runtime, the HTTP commit path can share this projection too.
+ */
+import { MutationOperationType } from '../types/index.js';
+import type { MutationOptions, WriteOptions } from '../interfaces/index.js';
+export interface UserContext {
+    userId: string;
+    organizationId: string;
+    role?: string;
+    teamIds?: string[];
+}
+/** Wire-format mutation payload (post-projection). */
+export type MutationInput = Record<string, unknown>;
+/**
+ * Project a Model's serialized data onto its schema-declared fields
+ * and return a wire-safe commit payload. Two jobs:
+ *
+ *   1. Drop framework internals (`__class`, `__typename`, `clientId`,
+ *      `syncStatus`) and anything not declared on the model's schema.
+ *   2. JSON.stringify values typed as `field.json()` — TEXT columns
+ *      storing JSON need explicit stringification; postgres.js won't
+ *      auto-serialize for non-JSONB columns.
+ *
+ * For updates (`dropUndefined: true`), `undefined` values are also
+ * stripped so they don't translate to `SET column = NULL` on the
+ * server side.
+ *
+ * Fields are read from `ModelRegistry`, populated by
+ * `registerModelsFromSchema` at SDK initialization. If the model
+ * isn't registered with field metadata (edge case — e.g., tests or
+ * manually registered models), projection falls back to identity and
+ * the caller gets whatever the Model serialized.
+ */
+export declare function projectCommitPayload(modelName: string, source: Record<string, unknown>, opts: {
+    dropUndefined: boolean;
+}): MutationInput;
+export interface Transaction {
+    id: string;
+    type: 'create' | 'update' | 'delete' | 'archive' | 'unarchive';
+    modelName: string;
+    modelId: string;
+    modelKey: string;
+    data?: MutationInput;
+    previousData?: MutationInput | null;
+    context: UserContext;
+    status: 'pending' | 'executing' | 'awaiting_delta' | 'completed' | 'failed' | 'rolled_back';
+    createdAt: number;
+    attempts: number;
+    priority: 'normal' | 'high';
+    priorityScore: number;
+    writeOptions?: WriteOptions;
+    batchId?: string;
+    /** Completed locally without a server operation; no sync echo will arrive. */
+    localOnly?: boolean;
+    /** LINEAR PATTERN: syncId threshold - transaction confirms when delta.id >= this value */
+    syncIdNeededForCompletion?: number;
+    /**
+     * Resolves when the server has confirmed this transaction (delta arrived
+     * or HTTP ack). Rejects with the originating error if the transaction is
+     * permanently rolled back. Name matches the queue's existing `'confirmed'`
+     * status vocabulary (`commits.create({wait:'confirmed'})`,
+     * `waitForConfirmation`) — gives call sites a single `await` point for
+     * "did my write land?", so failures surface at the source instead of
+     * leaking via silent pool rollback. The rejection error is the same
+     * `AbloError` recorded on the queue's `transaction:failed` event.
+     */
+    confirmation?: Promise<void>;
+}
+export declare const normalizeModelKey: (modelName: string) => string;
+export declare const stripModelSuffix: (modelName: string) => string;
+/**
+ * FK-ordered create priority.
+ *
+ * Reads `config.modelCreatePriority` out of the runtime SyncEngineContext —
+ * this map is populated once at `createSyncEngine(...)` time by walking the
+ * schema's `belongsTo` graph (see `computeFKDepthPriority` in
+ * `client/createSyncEngine.ts`). The queue stays schema-agnostic: no model
+ * names appear here, and consumer applications can override specific
+ * priorities via `configOverrides.modelCreatePriority` without touching the
+ * SDK.
+ *
+ * Non-create ops (update/delete/archive/unarchive) don't need FK ordering
+ * because the row already exists, so they all share
+ * `config.defaultNonCreatePriority`.
+ */
+export declare const computePriorityScore: (type: Transaction["type"], modelName: string) => number;
+export declare const TX_TYPE_TO_MUTATION_OP: Record<Transaction['type'], MutationOperationType>;
+export declare function hasStaleWriteOptions(options?: WriteOptions): boolean;
+export interface WriteOperationFields {
+    readAt?: number | null;
+    onStale?: 'reject' | 'overwrite' | 'notify' | null;
+    options?: Pick<MutationOptions, 'idempotencyKey' | 'label'>;
+}
+/**
+ * Project a transaction's `writeOptions` onto the wire operation. Stale
+ * guards (`readAt`/`onStale`) ride at the op root; `idempotencyKey`/`label`
+ * ride in the op's `options` slot (`MutationOperation.options` — the
+ * mutation_log cache key + audit tag). This is the single place the
+ * caller-supplied write vocabulary crosses onto the wire.
+ */
+export declare function applyWriteOptions<T extends object>(op: T, transaction: Transaction): T & WriteOperationFields;
+/**
+ * Structural shape we duck-type against for transport-layer errors.
+ * Captures the union of GraphQL-style and HTTP-style error shapes the
+ * mutation executor surfaces — kept narrow on purpose so we don't
+ * pretend to know fields the runtime won't always supply.
+ */
+export interface TransportError {
+    message?: string;
+    code?: string | number;
+    extensions?: Record<string, unknown>;
+    locations?: readonly unknown[];
+    path?: readonly (string | number)[];
+    response?: {
+        status?: number;
+        errors?: readonly {
+            extensions?: {
+                code?: string;
+            };
+            message?: string;
+        }[];
+    };
+    error?: string;
+}
+export declare function asTransportError(value: unknown): TransportError;
+export declare function extractStatusCode(error: unknown): number | undefined;

package/dist/transactions/commitPayload.js

@@ -0,0 +1,152 @@
+/**
+ * Commit-payload projection — the queue's wire vocabulary, lifted out of
+ * `TransactionQueue.ts` as a pure leaf (no queue state, no timers).
+ *
+ * Owns the `Transaction` record shape plus every helper that turns a local
+ * transaction into a wire-safe commit operation: schema-field projection
+ * (`projectCommitPayload`), write-option projection (`applyWriteOptions`),
+ * FK-aware priority scoring, and the transport-error duck-typing used to
+ * classify server rejections. Because nothing here touches the queue's
+ * runtime, the HTTP commit path can share this projection too.
+ */
+import { getContext } from '../context.js';
+import { getActiveRegistry } from '../ModelRegistry.js';
+import { MutationOperationType } from '../types/index.js';
+/**
+ * Framework-internal keys added by `Model.toJSON()` that must never
+ * reach the wire. The server treats each top-level key as a target
+ * column, so shipping these would blow up the INSERT/UPDATE.
+ */
+const FRAMEWORK_KEYS = new Set(['__class', '__typename', 'clientId', 'syncStatus']);
+/**
+ * Project a Model's serialized data onto its schema-declared fields
+ * and return a wire-safe commit payload. Two jobs:
+ *
+ *   1. Drop framework internals (`__class`, `__typename`, `clientId`,
+ *      `syncStatus`) and anything not declared on the model's schema.
+ *   2. JSON.stringify values typed as `field.json()` — TEXT columns
+ *      storing JSON need explicit stringification; postgres.js won't
+ *      auto-serialize for non-JSONB columns.
+ *
+ * For updates (`dropUndefined: true`), `undefined` values are also
+ * stripped so they don't translate to `SET column = NULL` on the
+ * server side.
+ *
+ * Fields are read from `ModelRegistry`, populated by
+ * `registerModelsFromSchema` at SDK initialization. If the model
+ * isn't registered with field metadata (edge case — e.g., tests or
+ * manually registered models), projection falls back to identity and
+ * the caller gets whatever the Model serialized.
+ */
+export function projectCommitPayload(modelName, source, opts) {
+    const metadata = getActiveRegistry().getMetadata(modelName);
+    const fields = metadata?.fields;
+    const out = {};
+    if (!fields) {
+        // Unknown registration — strip framework keys and ship the rest.
+        for (const [k, v] of Object.entries(source)) {
+            if (FRAMEWORK_KEYS.has(k))
+                continue;
+            if (opts.dropUndefined && v === undefined)
+                continue;
+            out[k] = v;
+        }
+        return out;
+    }
+    for (const [key, meta] of Object.entries(fields)) {
+        if (!(key in source))
+            continue;
+        const value = source[key];
+        if (opts.dropUndefined && value === undefined)
+            continue;
+        // JSON-typed fields (`jsonb` on the server): ship as OBJECTS over
+        // the wire, not pre-stringified strings. Previously we stringified
+        // here, which round-tripped incorrectly:
+        //
+        //   1. Client stringifies `position: {x, y}` → `'{"x":...}'`
+        //   2. Server writes to jsonb column (parses string → jsonb object, fine)
+        //   3. Server's delta echoes `data: JSON.stringify(op.input)` where
+        //      `op.input.position` is still the STRING from step 1
+        //   4. Client merges delta → `model.position = "{...}"` (STRING)
+        //   5. Next drag: `{ ...layer.position, x, y }` spreads the STRING
+        //      char-by-char, producing corrupted char-indexed objects like
+        //      `{"0":"{","1":"\"","2":"x",...,"x":null,"y":null,...}`
+        //   6. That corrupt object lands in the next commit, stored in jsonb.
+        //
+        // Sending objects avoids the round-trip mismatch: the wire carries
+        // the object through delta + commit unchanged, and `postgres-js`
+        // serializes JS objects to jsonb correctly via its own
+        // `json.serialize` (triggered by Postgres's ParameterDescription
+        // response identifying the column as type 3802 / jsonb).
+        out[key] = value;
+    }
+    return out;
+}
+export const normalizeModelKey = (modelName) => modelName.replace('Model', '').toLowerCase();
+export const stripModelSuffix = (modelName) => modelName.replace('Model', '');
+/**
+ * FK-ordered create priority.
+ *
+ * Reads `config.modelCreatePriority` out of the runtime SyncEngineContext —
+ * this map is populated once at `createSyncEngine(...)` time by walking the
+ * schema's `belongsTo` graph (see `computeFKDepthPriority` in
+ * `client/createSyncEngine.ts`). The queue stays schema-agnostic: no model
+ * names appear here, and consumer applications can override specific
+ * priorities via `configOverrides.modelCreatePriority` without touching the
+ * SDK.
+ *
+ * Non-create ops (update/delete/archive/unarchive) don't need FK ordering
+ * because the row already exists, so they all share
+ * `config.defaultNonCreatePriority`.
+ */
+export const computePriorityScore = (type, modelName) => {
+    const { modelCreatePriority, defaultCreatePriority, defaultNonCreatePriority } = getContext().config;
+    if (type !== 'create')
+        return defaultNonCreatePriority;
+    return modelCreatePriority.get(modelName) ?? defaultCreatePriority;
+};
+export const TX_TYPE_TO_MUTATION_OP = {
+    create: MutationOperationType.CREATE,
+    update: MutationOperationType.UPDATE,
+    delete: MutationOperationType.DELETE,
+    archive: MutationOperationType.ARCHIVE,
+    unarchive: MutationOperationType.UNARCHIVE,
+};
+export function hasStaleWriteOptions(options) {
+    return (options?.readAt !== undefined ||
+        options?.onStale !== undefined);
+}
+/**
+ * Project a transaction's `writeOptions` onto the wire operation. Stale
+ * guards (`readAt`/`onStale`) ride at the op root; `idempotencyKey`/`label`
+ * ride in the op's `options` slot (`MutationOperation.options` — the
+ * mutation_log cache key + audit tag). This is the single place the
+ * caller-supplied write vocabulary crosses onto the wire.
+ */
+export function applyWriteOptions(op, transaction) {
+    const operation = op;
+    const writeOptions = transaction.writeOptions;
+    if (!writeOptions)
+        return operation;
+    if (writeOptions.readAt !== undefined) {
+        operation.readAt = writeOptions.readAt;
+    }
+    if (writeOptions.onStale !== undefined) {
+        operation.onStale = writeOptions.onStale;
+    }
+    if (writeOptions.idempotencyKey != null || writeOptions.label !== undefined) {
+        operation.options = {
+            ...(writeOptions.idempotencyKey != null
+                ? { idempotencyKey: writeOptions.idempotencyKey }
+                : {}),
+            ...(writeOptions.label !== undefined ? { label: writeOptions.label } : {}),
+        };
+    }
+    return operation;
+}
+export function asTransportError(value) {
+    return (value && typeof value === 'object' ? value : {});
+}
+export function extractStatusCode(error) {
+    return asTransportError(error).response?.status;
+}

package/dist/transactions/deltaConfirmation.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Delta-confirmation tracking — the queue's "did my write's echo arrive?"
+ * machinery, lifted out of `TransactionQueue.ts` as a stateful leaf.
+ *
+ * Owns the ack watermark (via the shared `SyncPosition`), the per-transaction
+ * confirmation timeout map, and the retry-with-backoff/reconciliation policy
+ * for `awaiting_delta` transactions. Talks back to the queue through the
+ * minimal `DeltaConfirmationContext` interface (never the host class type),
+ * so the leaf stays cycle-free and testable in isolation.
+ */
+import type { SyncPosition } from '../sync/syncPosition.js';
+import type { Transaction } from './commitPayload.js';
+/**
+ * The slice of the queue a confirmation tracker needs: store lookups +
+ * status flips, dropping optimistic entries on confirm, the host's event
+ * surface (`transaction:completed`, `reconciliation:needed`, …), the
+ * connection check (timeouts re-schedule instead of escalating while
+ * offline), and the shared client position (`noteAck` advances `acked`;
+ * diagnostics read `applied`).
+ */
+export interface DeltaConfirmationContext {
+    store: {
+        get(id: string): Transaction | undefined;
+        getByStatus(status: Transaction['status']): Transaction[];
+        updateStatus(id: string, status: Transaction['status']): void;
+    };
+    optimisticUpdates: {
+        delete(id: string): boolean;
+    };
+    emit(event: string, payload?: unknown): void;
+    isConnected(): boolean;
+    position: SyncPosition;
+}
+export declare class DeltaConfirmationTracker {
+    private readonly ctx;
+    private static readonly DELTA_MAX_RETRIES;
+    private static readonly DELTA_INITIAL_TIMEOUT_MS;
+    private static readonly DELTA_MAX_TIMEOUT_MS;
+    private deltaConfirmationTimeouts;
+    private deltaConfirmationRetries;
+    constructor(ctx: DeltaConfirmationContext);
+    /** Applied-cursor alias, kept so the read sites below stay legible. */
+    private get lastSeenSyncId();
+    noteAck(lastSyncId: number | undefined): void;
+    /**
+     * LINEAR PATTERN: Confirm all awaiting transactions when delta with syncId >= threshold arrives.
+     * This replaces clientMutationId echoing - transactions are confirmed by sync ID threshold.
+     * @param syncId - The sync ID of the received delta
+     */
+    onDeltaReceived(syncId: number): void;
+    scheduleDeltaConfirmationTimeout(tx: Transaction, timeoutMs: number): void;
+    private cancelDeltaConfirmationTimeout;
+    /**
+     * Tear down every armed confirmation timer (30–120s each, one per
+     * in-flight transaction). Called from `TransactionQueue.dispose()` —
+     * without it a disposed queue kept the Node process alive and fired
+     * callbacks against an already-cleared store (T1.19).
+     */
+    dispose(): void;
+}