@tanstack/offline-transactions 0.0.0

package/dist/esm/executor/TransactionExecutor.js

@@ -0,0 +1,236 @@
+import { createTraceState } from "@opentelemetry/api";
+import { DefaultRetryPolicy } from "../retry/RetryPolicy.js";
+import { NonRetriableError } from "../types.js";
+import { withNestedSpan } from "../telemetry/tracer.js";
+const HANDLED_EXECUTION_ERROR = Symbol(`HandledExecutionError`);
+function toSpanContext(serialized) {
+  if (!serialized) {
+    return void 0;
+  }
+  return {
+    traceId: serialized.traceId,
+    spanId: serialized.spanId,
+    traceFlags: serialized.traceFlags,
+    traceState: serialized.traceState ? createTraceState(serialized.traceState) : void 0
+  };
+}
+class TransactionExecutor {
+  constructor(scheduler, outbox, config, offlineExecutor) {
+    this.isExecuting = false;
+    this.executionPromise = null;
+    this.retryTimer = null;
+    this.scheduler = scheduler;
+    this.outbox = outbox;
+    this.config = config;
+    this.retryPolicy = new DefaultRetryPolicy(10, config.jitter ?? true);
+    this.offlineExecutor = offlineExecutor;
+  }
+  async execute(transaction) {
+    this.scheduler.schedule(transaction);
+    await this.executeAll();
+  }
+  async executeAll() {
+    if (this.isExecuting) {
+      return this.executionPromise;
+    }
+    this.isExecuting = true;
+    this.executionPromise = this.runExecution();
+    try {
+      await this.executionPromise;
+    } finally {
+      this.isExecuting = false;
+      this.executionPromise = null;
+    }
+  }
+  async runExecution() {
+    const maxConcurrency = this.config.maxConcurrency ?? 3;
+    while (this.scheduler.getPendingCount() > 0) {
+      const batch = this.scheduler.getNextBatch(maxConcurrency);
+      if (batch.length === 0) {
+        break;
+      }
+      const executions = batch.map(
+        (transaction) => this.executeTransaction(transaction)
+      );
+      await Promise.allSettled(executions);
+    }
+    this.scheduleNextRetry();
+  }
+  async executeTransaction(transaction) {
+    try {
+      await withNestedSpan(
+        `transaction.execute`,
+        {
+          "transaction.id": transaction.id,
+          "transaction.mutationFnName": transaction.mutationFnName,
+          "transaction.retryCount": transaction.retryCount,
+          "transaction.keyCount": transaction.keys.length
+        },
+        async (span) => {
+          this.scheduler.markStarted(transaction);
+          if (transaction.retryCount > 0) {
+            span.setAttribute(`retry.attempt`, transaction.retryCount);
+          }
+          try {
+            const result = await this.runMutationFn(transaction);
+            this.scheduler.markCompleted(transaction);
+            await this.outbox.remove(transaction.id);
+            span.setAttribute(`result`, `success`);
+            this.offlineExecutor.resolveTransaction(transaction.id, result);
+          } catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            span.setAttribute(`result`, `error`);
+            await this.handleError(transaction, err);
+            err[HANDLED_EXECUTION_ERROR] = true;
+            throw err;
+          }
+        },
+        {
+          parentContext: toSpanContext(transaction.spanContext)
+        }
+      );
+    } catch (error) {
+      if (error instanceof Error && error[HANDLED_EXECUTION_ERROR] === true) {
+        return;
+      }
+      throw error;
+    }
+  }
+  async runMutationFn(transaction) {
+    const mutationFn = this.config.mutationFns[transaction.mutationFnName];
+    if (!mutationFn) {
+      const errorMessage = `Unknown mutation function: ${transaction.mutationFnName}`;
+      if (this.config.onUnknownMutationFn) {
+        this.config.onUnknownMutationFn(transaction.mutationFnName, transaction);
+      }
+      throw new NonRetriableError(errorMessage);
+    }
+    const transactionWithMutations = {
+      id: transaction.id,
+      mutations: transaction.mutations,
+      metadata: transaction.metadata ?? {}
+    };
+    await mutationFn({
+      transaction: transactionWithMutations,
+      idempotencyKey: transaction.idempotencyKey
+    });
+  }
+  async handleError(transaction, error) {
+    return withNestedSpan(
+      `transaction.handleError`,
+      {
+        "transaction.id": transaction.id,
+        "error.name": error.name,
+        "error.message": error.message
+      },
+      async (span) => {
+        const shouldRetry = this.retryPolicy.shouldRetry(
+          error,
+          transaction.retryCount
+        );
+        span.setAttribute(`shouldRetry`, shouldRetry);
+        if (!shouldRetry) {
+          this.scheduler.markCompleted(transaction);
+          await this.outbox.remove(transaction.id);
+          console.warn(
+            `Transaction ${transaction.id} failed permanently:`,
+            error
+          );
+          span.setAttribute(`result`, `permanent_failure`);
+          this.offlineExecutor.rejectTransaction(transaction.id, error);
+          return;
+        }
+        const delay = this.retryPolicy.calculateDelay(transaction.retryCount);
+        const updatedTransaction = {
+          ...transaction,
+          retryCount: transaction.retryCount + 1,
+          nextAttemptAt: Date.now() + delay,
+          lastError: {
+            name: error.name,
+            message: error.message,
+            stack: error.stack
+          }
+        };
+        span.setAttribute(`retryDelay`, delay);
+        span.setAttribute(`nextRetryCount`, updatedTransaction.retryCount);
+        this.scheduler.markFailed(transaction);
+        this.scheduler.updateTransaction(updatedTransaction);
+        try {
+          await this.outbox.update(transaction.id, updatedTransaction);
+          span.setAttribute(`result`, `scheduled_retry`);
+        } catch (persistError) {
+          span.recordException(persistError);
+          span.setAttribute(`result`, `persist_failed`);
+          throw persistError;
+        }
+        this.scheduleNextRetry();
+      }
+    );
+  }
+  async loadPendingTransactions() {
+    const transactions = await this.outbox.getAll();
+    let filteredTransactions = transactions;
+    if (this.config.beforeRetry) {
+      filteredTransactions = this.config.beforeRetry(transactions);
+    }
+    for (const transaction of filteredTransactions) {
+      this.scheduler.schedule(transaction);
+    }
+    this.resetRetryDelays();
+    this.scheduleNextRetry();
+    const removedTransactions = transactions.filter(
+      (tx) => !filteredTransactions.some((filtered) => filtered.id === tx.id)
+    );
+    if (removedTransactions.length > 0) {
+      await this.outbox.removeMany(removedTransactions.map((tx) => tx.id));
+    }
+  }
+  clear() {
+    this.scheduler.clear();
+    this.clearRetryTimer();
+  }
+  getPendingCount() {
+    return this.scheduler.getPendingCount();
+  }
+  scheduleNextRetry() {
+    this.clearRetryTimer();
+    const earliestRetryTime = this.getEarliestRetryTime();
+    if (earliestRetryTime === null) {
+      return;
+    }
+    const delay = Math.max(0, earliestRetryTime - Date.now());
+    this.retryTimer = setTimeout(() => {
+      this.executeAll().catch((error) => {
+        console.warn(`Failed to execute retry batch:`, error);
+      });
+    }, delay);
+  }
+  getEarliestRetryTime() {
+    const allTransactions = this.scheduler.getAllPendingTransactions();
+    if (allTransactions.length === 0) {
+      return null;
+    }
+    return Math.min(...allTransactions.map((tx) => tx.nextAttemptAt));
+  }
+  clearRetryTimer() {
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+  }
+  getRunningCount() {
+    return this.scheduler.getRunningCount();
+  }
+  resetRetryDelays() {
+    const allTransactions = this.scheduler.getAllPendingTransactions();
+    const updatedTransactions = allTransactions.map((transaction) => ({
+      ...transaction,
+      nextAttemptAt: Date.now()
+    }));
+    this.scheduler.updateTransactions(updatedTransactions);
+  }
+}
+export {
+  TransactionExecutor
+};
+//# sourceMappingURL=TransactionExecutor.js.map

package/dist/esm/executor/TransactionExecutor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionExecutor.js","sources":["../../../src/executor/TransactionExecutor.ts"],"sourcesContent":["import { createTraceState } from \"@opentelemetry/api\"\nimport { DefaultRetryPolicy } from \"../retry/RetryPolicy\"\nimport { NonRetriableError } from \"../types\"\nimport { withNestedSpan } from \"../telemetry/tracer\"\nimport type { SpanContext } from \"@opentelemetry/api\"\nimport type { KeyScheduler } from \"./KeyScheduler\"\nimport type { OutboxManager } from \"../outbox/OutboxManager\"\nimport type {\n  OfflineConfig,\n  OfflineTransaction,\n  SerializedSpanContext,\n} from \"../types\"\n\nconst HANDLED_EXECUTION_ERROR = Symbol(`HandledExecutionError`)\n\nfunction toSpanContext(\n  serialized?: SerializedSpanContext\n): SpanContext | undefined {\n  if (!serialized) {\n    return undefined\n  }\n\n  return {\n    traceId: serialized.traceId,\n    spanId: serialized.spanId,\n    traceFlags: serialized.traceFlags,\n    traceState: serialized.traceState\n      ? createTraceState(serialized.traceState)\n      : undefined,\n  }\n}\n\nexport class TransactionExecutor {\n  private scheduler: KeyScheduler\n  private outbox: OutboxManager\n  private config: OfflineConfig\n  private retryPolicy: DefaultRetryPolicy\n  private isExecuting = false\n  private executionPromise: Promise<void> | null = null\n  private offlineExecutor: any // Reference to OfflineExecutor for signaling\n  private retryTimer: ReturnType<typeof setTimeout> | null = null\n\n  constructor(\n    scheduler: KeyScheduler,\n    outbox: OutboxManager,\n    config: OfflineConfig,\n    offlineExecutor: any\n  ) {\n    this.scheduler = scheduler\n    this.outbox = outbox\n    this.config = config\n    this.retryPolicy = new DefaultRetryPolicy(10, config.jitter ?? true)\n    this.offlineExecutor = offlineExecutor\n  }\n\n  async execute(transaction: OfflineTransaction): Promise<void> {\n    this.scheduler.schedule(transaction)\n    await this.executeAll()\n  }\n\n  async executeAll(): Promise<void> {\n    if (this.isExecuting) {\n      return this.executionPromise!\n    }\n\n    this.isExecuting = true\n    this.executionPromise = this.runExecution()\n\n    try {\n      await this.executionPromise\n    } finally {\n      this.isExecuting = false\n      this.executionPromise = null\n    }\n  }\n\n  private async runExecution(): Promise<void> {\n    const maxConcurrency = this.config.maxConcurrency ?? 3\n\n    while (this.scheduler.getPendingCount() > 0) {\n      const batch = this.scheduler.getNextBatch(maxConcurrency)\n\n      if (batch.length === 0) {\n        break\n      }\n\n      const executions = batch.map((transaction) =>\n        this.executeTransaction(transaction)\n      )\n      await Promise.allSettled(executions)\n    }\n\n    // Schedule next retry after execution completes\n    this.scheduleNextRetry()\n  }\n\n  private async executeTransaction(\n    transaction: OfflineTransaction\n  ): Promise<void> {\n    try {\n      await withNestedSpan(\n        `transaction.execute`,\n        {\n          \"transaction.id\": transaction.id,\n          \"transaction.mutationFnName\": transaction.mutationFnName,\n          \"transaction.retryCount\": transaction.retryCount,\n          \"transaction.keyCount\": transaction.keys.length,\n        },\n        async (span) => {\n          this.scheduler.markStarted(transaction)\n\n          if (transaction.retryCount > 0) {\n            span.setAttribute(`retry.attempt`, transaction.retryCount)\n          }\n\n          try {\n            const result = await this.runMutationFn(transaction)\n\n            this.scheduler.markCompleted(transaction)\n            await this.outbox.remove(transaction.id)\n\n            span.setAttribute(`result`, `success`)\n            this.offlineExecutor.resolveTransaction(transaction.id, result)\n          } catch (error) {\n            const err =\n              error instanceof Error ? error : new Error(String(error))\n\n            span.setAttribute(`result`, `error`)\n\n            await this.handleError(transaction, err)\n            ;(err as any)[HANDLED_EXECUTION_ERROR] = true\n            throw err\n          }\n        },\n        {\n          parentContext: toSpanContext(transaction.spanContext),\n        }\n      )\n    } catch (error) {\n      if (\n        error instanceof Error &&\n        (error as any)[HANDLED_EXECUTION_ERROR] === true\n      ) {\n        return\n      }\n\n      throw error\n    }\n  }\n\n  private async runMutationFn(transaction: OfflineTransaction): Promise<void> {\n    const mutationFn = this.config.mutationFns[transaction.mutationFnName]\n\n    if (!mutationFn) {\n      const errorMessage = `Unknown mutation function: ${transaction.mutationFnName}`\n\n      if (this.config.onUnknownMutationFn) {\n        this.config.onUnknownMutationFn(transaction.mutationFnName, transaction)\n      }\n\n      throw new NonRetriableError(errorMessage)\n    }\n\n    // Mutations are already PendingMutation objects with collections attached\n    // from the deserializer, so we can use them directly\n    const transactionWithMutations = {\n      id: transaction.id,\n      mutations: transaction.mutations,\n      metadata: transaction.metadata ?? {},\n    }\n\n    await mutationFn({\n      transaction: transactionWithMutations as any,\n      idempotencyKey: transaction.idempotencyKey,\n    })\n  }\n\n  private async handleError(\n    transaction: OfflineTransaction,\n    error: Error\n  ): Promise<void> {\n    return withNestedSpan(\n      `transaction.handleError`,\n      {\n        \"transaction.id\": transaction.id,\n        \"error.name\": error.name,\n        \"error.message\": error.message,\n      },\n      async (span) => {\n        const shouldRetry = this.retryPolicy.shouldRetry(\n          error,\n          transaction.retryCount\n        )\n\n        span.setAttribute(`shouldRetry`, shouldRetry)\n\n        if (!shouldRetry) {\n          this.scheduler.markCompleted(transaction)\n          await this.outbox.remove(transaction.id)\n          console.warn(\n            `Transaction ${transaction.id} failed permanently:`,\n            error\n          )\n\n          span.setAttribute(`result`, `permanent_failure`)\n          // Signal permanent failure to the waiting transaction\n          this.offlineExecutor.rejectTransaction(transaction.id, error)\n          return\n        }\n\n        const delay = this.retryPolicy.calculateDelay(transaction.retryCount)\n        const updatedTransaction: OfflineTransaction = {\n          ...transaction,\n          retryCount: transaction.retryCount + 1,\n          nextAttemptAt: Date.now() + delay,\n          lastError: {\n            name: error.name,\n            message: error.message,\n            stack: error.stack,\n          },\n        }\n\n        span.setAttribute(`retryDelay`, delay)\n        span.setAttribute(`nextRetryCount`, updatedTransaction.retryCount)\n\n        this.scheduler.markFailed(transaction)\n        this.scheduler.updateTransaction(updatedTransaction)\n\n        try {\n          await this.outbox.update(transaction.id, updatedTransaction)\n          span.setAttribute(`result`, `scheduled_retry`)\n        } catch (persistError) {\n          span.recordException(persistError as Error)\n          span.setAttribute(`result`, `persist_failed`)\n          throw persistError\n        }\n\n        // Schedule retry timer\n        this.scheduleNextRetry()\n      }\n    )\n  }\n\n  async loadPendingTransactions(): Promise<void> {\n    const transactions = await this.outbox.getAll()\n    let filteredTransactions = transactions\n\n    if (this.config.beforeRetry) {\n      filteredTransactions = this.config.beforeRetry(transactions)\n    }\n\n    for (const transaction of filteredTransactions) {\n      this.scheduler.schedule(transaction)\n    }\n\n    // Reset retry delays for all loaded transactions so they can run immediately\n    this.resetRetryDelays()\n\n    // Schedule retry timer for loaded transactions\n    this.scheduleNextRetry()\n\n    const removedTransactions = transactions.filter(\n      (tx) => !filteredTransactions.some((filtered) => filtered.id === tx.id)\n    )\n\n    if (removedTransactions.length > 0) {\n      await this.outbox.removeMany(removedTransactions.map((tx) => tx.id))\n    }\n  }\n\n  clear(): void {\n    this.scheduler.clear()\n    this.clearRetryTimer()\n  }\n\n  getPendingCount(): number {\n    return this.scheduler.getPendingCount()\n  }\n\n  private scheduleNextRetry(): void {\n    // Clear existing timer\n    this.clearRetryTimer()\n\n    // Find the earliest retry time among pending transactions\n    const earliestRetryTime = this.getEarliestRetryTime()\n\n    if (earliestRetryTime === null) {\n      return // No transactions pending retry\n    }\n\n    const delay = Math.max(0, earliestRetryTime - Date.now())\n\n    this.retryTimer = setTimeout(() => {\n      this.executeAll().catch((error) => {\n        console.warn(`Failed to execute retry batch:`, error)\n      })\n    }, delay)\n  }\n\n  private getEarliestRetryTime(): number | null {\n    const allTransactions = this.scheduler.getAllPendingTransactions()\n\n    if (allTransactions.length === 0) {\n      return null\n    }\n\n    return Math.min(...allTransactions.map((tx) => tx.nextAttemptAt))\n  }\n\n  private clearRetryTimer(): void {\n    if (this.retryTimer) {\n      clearTimeout(this.retryTimer)\n      this.retryTimer = null\n    }\n  }\n\n  getRunningCount(): number {\n    return this.scheduler.getRunningCount()\n  }\n\n  resetRetryDelays(): void {\n    const allTransactions = this.scheduler.getAllPendingTransactions()\n    const updatedTransactions = allTransactions.map((transaction) => ({\n      ...transaction,\n      nextAttemptAt: Date.now(),\n    }))\n\n    this.scheduler.updateTransactions(updatedTransactions)\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/index.d.ts

@@ -0,0 +1,16 @@
+export { OfflineExecutor, startOfflineExecutor } from './OfflineExecutor.js';
+export type { OfflineTransaction, OfflineConfig, StorageAdapter, RetryPolicy, LeaderElection, OnlineDetector, CreateOfflineTransactionOptions, CreateOfflineActionOptions, SerializedError, SerializedMutation, } from './types.js';
+export { NonRetriableError } from './types.js';
+export { IndexedDBAdapter } from './storage/IndexedDBAdapter.js';
+export { LocalStorageAdapter } from './storage/LocalStorageAdapter.js';
+export { DefaultRetryPolicy } from './retry/RetryPolicy.js';
+export { BackoffCalculator } from './retry/BackoffCalculator.js';
+export { WebLocksLeader } from './coordination/WebLocksLeader.js';
+export { BroadcastChannelLeader } from './coordination/BroadcastChannelLeader.js';
+export { DefaultOnlineDetector } from './connectivity/OnlineDetector.js';
+export { OfflineTransaction as OfflineTransactionAPI } from './api/OfflineTransaction.js';
+export { createOfflineAction } from './api/OfflineAction.js';
+export { OutboxManager } from './outbox/OutboxManager.js';
+export { TransactionSerializer } from './outbox/TransactionSerializer.js';
+export { KeyScheduler } from './executor/KeyScheduler.js';
+export { TransactionExecutor } from './executor/TransactionExecutor.js';

package/dist/esm/index.js

@@ -0,0 +1,34 @@
+import { OfflineExecutor, startOfflineExecutor } from "./OfflineExecutor.js";
+import { NonRetriableError } from "./types.js";
+import { IndexedDBAdapter } from "./storage/IndexedDBAdapter.js";
+import { LocalStorageAdapter } from "./storage/LocalStorageAdapter.js";
+import { DefaultRetryPolicy } from "./retry/RetryPolicy.js";
+import { BackoffCalculator } from "./retry/BackoffCalculator.js";
+import { WebLocksLeader } from "./coordination/WebLocksLeader.js";
+import { BroadcastChannelLeader } from "./coordination/BroadcastChannelLeader.js";
+import { DefaultOnlineDetector } from "./connectivity/OnlineDetector.js";
+import { OfflineTransaction } from "./api/OfflineTransaction.js";
+import { createOfflineAction } from "./api/OfflineAction.js";
+import { OutboxManager } from "./outbox/OutboxManager.js";
+import { TransactionSerializer } from "./outbox/TransactionSerializer.js";
+import { KeyScheduler } from "./executor/KeyScheduler.js";
+import { TransactionExecutor } from "./executor/TransactionExecutor.js";
+export {
+  BackoffCalculator,
+  BroadcastChannelLeader,
+  DefaultOnlineDetector,
+  DefaultRetryPolicy,
+  IndexedDBAdapter,
+  KeyScheduler,
+  LocalStorageAdapter,
+  NonRetriableError,
+  OfflineExecutor,
+  OfflineTransaction as OfflineTransactionAPI,
+  OutboxManager,
+  TransactionExecutor,
+  TransactionSerializer,
+  WebLocksLeader,
+  createOfflineAction,
+  startOfflineExecutor
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;"}

package/dist/esm/outbox/OutboxManager.d.ts

@@ -0,0 +1,18 @@
+import { OfflineTransaction, StorageAdapter } from '../types.js';
+import { Collection } from '@tanstack/db';
+export declare class OutboxManager {
+    private storage;
+    private serializer;
+    private keyPrefix;
+    constructor(storage: StorageAdapter, collections: Record<string, Collection>);
+    private getStorageKey;
+    add(transaction: OfflineTransaction): Promise<void>;
+    get(id: string): Promise<OfflineTransaction | null>;
+    getAll(): Promise<Array<OfflineTransaction>>;
+    getByKeys(keys: Array<string>): Promise<Array<OfflineTransaction>>;
+    update(id: string, updates: Partial<OfflineTransaction>): Promise<void>;
+    remove(id: string): Promise<void>;
+    removeMany(ids: Array<string>): Promise<void>;
+    clear(): Promise<void>;
+    count(): Promise<number>;
+}

package/dist/esm/outbox/OutboxManager.js

@@ -0,0 +1,114 @@
+import { withSpan } from "../telemetry/tracer.js";
+import { TransactionSerializer } from "./TransactionSerializer.js";
+class OutboxManager {
+  constructor(storage, collections) {
+    this.keyPrefix = `tx:`;
+    this.storage = storage;
+    this.serializer = new TransactionSerializer(collections);
+  }
+  getStorageKey(id) {
+    return `${this.keyPrefix}${id}`;
+  }
+  async add(transaction) {
+    return withSpan(
+      `outbox.add`,
+      {
+        "transaction.id": transaction.id,
+        "transaction.mutationFnName": transaction.mutationFnName,
+        "transaction.keyCount": transaction.keys.length
+      },
+      async () => {
+        const key = this.getStorageKey(transaction.id);
+        const serialized = this.serializer.serialize(transaction);
+        await this.storage.set(key, serialized);
+      }
+    );
+  }
+  async get(id) {
+    return withSpan(`outbox.get`, { "transaction.id": id }, async (span) => {
+      const key = this.getStorageKey(id);
+      const data = await this.storage.get(key);
+      if (!data) {
+        span.setAttribute(`result`, `not_found`);
+        return null;
+      }
+      try {
+        const transaction = this.serializer.deserialize(data);
+        span.setAttribute(`result`, `found`);
+        return transaction;
+      } catch (error) {
+        console.warn(`Failed to deserialize transaction ${id}:`, error);
+        span.setAttribute(`result`, `deserialize_error`);
+        return null;
+      }
+    });
+  }
+  async getAll() {
+    return withSpan(`outbox.getAll`, {}, async (span) => {
+      const keys = await this.storage.keys();
+      const transactionKeys = keys.filter(
+        (key) => key.startsWith(this.keyPrefix)
+      );
+      span.setAttribute(`transactionCount`, transactionKeys.length);
+      const transactions = [];
+      for (const key of transactionKeys) {
+        const data = await this.storage.get(key);
+        if (data) {
+          try {
+            const transaction = this.serializer.deserialize(data);
+            transactions.push(transaction);
+          } catch (error) {
+            console.warn(
+              `Failed to deserialize transaction from key ${key}:`,
+              error
+            );
+          }
+        }
+      }
+      return transactions.sort(
+        (a, b) => a.createdAt.getTime() - b.createdAt.getTime()
+      );
+    });
+  }
+  async getByKeys(keys) {
+    const allTransactions = await this.getAll();
+    const keySet = new Set(keys);
+    return allTransactions.filter(
+      (transaction) => transaction.keys.some((key) => keySet.has(key))
+    );
+  }
+  async update(id, updates) {
+    return withSpan(`outbox.update`, { "transaction.id": id }, async () => {
+      const existing = await this.get(id);
+      if (!existing) {
+        throw new Error(`Transaction ${id} not found`);
+      }
+      const updated = { ...existing, ...updates };
+      await this.add(updated);
+    });
+  }
+  async remove(id) {
+    return withSpan(`outbox.remove`, { "transaction.id": id }, async () => {
+      const key = this.getStorageKey(id);
+      await this.storage.delete(key);
+    });
+  }
+  async removeMany(ids) {
+    return withSpan(`outbox.removeMany`, { count: ids.length }, async () => {
+      await Promise.all(ids.map((id) => this.remove(id)));
+    });
+  }
+  async clear() {
+    const keys = await this.storage.keys();
+    const transactionKeys = keys.filter((key) => key.startsWith(this.keyPrefix));
+    await Promise.all(transactionKeys.map((key) => this.storage.delete(key)));
+  }
+  async count() {
+    const keys = await this.storage.keys();
+    return keys.filter((key) => key.startsWith(this.keyPrefix)).length;
+  }
+}
+export {
+  OutboxManager
+};
+//# sourceMappingURL=OutboxManager.js.map

package/dist/esm/outbox/OutboxManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OutboxManager.js","sources":["../../../src/outbox/OutboxManager.ts"],"sourcesContent":["import { withSpan } from \"../telemetry/tracer\"\nimport { TransactionSerializer } from \"./TransactionSerializer\"\nimport type { OfflineTransaction, StorageAdapter } from \"../types\"\nimport type { Collection } from \"@tanstack/db\"\n\nexport class OutboxManager {\n  private storage: StorageAdapter\n  private serializer: TransactionSerializer\n  private keyPrefix = `tx:`\n\n  constructor(\n    storage: StorageAdapter,\n    collections: Record<string, Collection>\n  ) {\n    this.storage = storage\n    this.serializer = new TransactionSerializer(collections)\n  }\n\n  private getStorageKey(id: string): string {\n    return `${this.keyPrefix}${id}`\n  }\n\n  async add(transaction: OfflineTransaction): Promise<void> {\n    return withSpan(\n      `outbox.add`,\n      {\n        \"transaction.id\": transaction.id,\n        \"transaction.mutationFnName\": transaction.mutationFnName,\n        \"transaction.keyCount\": transaction.keys.length,\n      },\n      async () => {\n        const key = this.getStorageKey(transaction.id)\n        const serialized = this.serializer.serialize(transaction)\n        await this.storage.set(key, serialized)\n      }\n    )\n  }\n\n  async get(id: string): Promise<OfflineTransaction | null> {\n    return withSpan(`outbox.get`, { \"transaction.id\": id }, async (span) => {\n      const key = this.getStorageKey(id)\n      const data = await this.storage.get(key)\n\n      if (!data) {\n        span.setAttribute(`result`, `not_found`)\n        return null\n      }\n\n      try {\n        const transaction = this.serializer.deserialize(data)\n        span.setAttribute(`result`, `found`)\n        return transaction\n      } catch (error) {\n        console.warn(`Failed to deserialize transaction ${id}:`, error)\n        span.setAttribute(`result`, `deserialize_error`)\n        return null\n      }\n    })\n  }\n\n  async getAll(): Promise<Array<OfflineTransaction>> {\n    return withSpan(`outbox.getAll`, {}, async (span) => {\n      const keys = await this.storage.keys()\n      const transactionKeys = keys.filter((key) =>\n        key.startsWith(this.keyPrefix)\n      )\n\n      span.setAttribute(`transactionCount`, transactionKeys.length)\n\n      const transactions: Array<OfflineTransaction> = []\n\n      for (const key of transactionKeys) {\n        const data = await this.storage.get(key)\n        if (data) {\n          try {\n            const transaction = this.serializer.deserialize(data)\n            transactions.push(transaction)\n          } catch (error) {\n            console.warn(\n              `Failed to deserialize transaction from key ${key}:`,\n              error\n            )\n          }\n        }\n      }\n\n      return transactions.sort(\n        (a, b) => a.createdAt.getTime() - b.createdAt.getTime()\n      )\n    })\n  }\n\n  async getByKeys(keys: Array<string>): Promise<Array<OfflineTransaction>> {\n    const allTransactions = await this.getAll()\n    const keySet = new Set(keys)\n\n    return allTransactions.filter((transaction) =>\n      transaction.keys.some((key) => keySet.has(key))\n    )\n  }\n\n  async update(\n    id: string,\n    updates: Partial<OfflineTransaction>\n  ): Promise<void> {\n    return withSpan(`outbox.update`, { \"transaction.id\": id }, async () => {\n      const existing = await this.get(id)\n      if (!existing) {\n        throw new Error(`Transaction ${id} not found`)\n      }\n\n      const updated = { ...existing, ...updates }\n      await this.add(updated)\n    })\n  }\n\n  async remove(id: string): Promise<void> {\n    return withSpan(`outbox.remove`, { \"transaction.id\": id }, async () => {\n      const key = this.getStorageKey(id)\n      await this.storage.delete(key)\n    })\n  }\n\n  async removeMany(ids: Array<string>): Promise<void> {\n    return withSpan(`outbox.removeMany`, { count: ids.length }, async () => {\n      await Promise.all(ids.map((id) => this.remove(id)))\n    })\n  }\n\n  async clear(): Promise<void> {\n    const keys = await this.storage.keys()\n    const transactionKeys = keys.filter((key) => key.startsWith(this.keyPrefix))\n\n    await Promise.all(transactionKeys.map((key) => this.storage.delete(key)))\n  }\n\n  async count(): Promise<number> {\n    const keys = await this.storage.keys()\n    return keys.filter((key) => key.startsWith(this.keyPrefix)).length\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/outbox/TransactionSerializer.d.ts

@@ -0,0 +1,15 @@
+import { OfflineTransaction, SerializedError } from '../types.js';
+import { Collection } from '@tanstack/db';
+export declare class TransactionSerializer {
+    private collections;
+    private collectionIdToKey;
+    constructor(collections: Record<string, Collection>);
+    serialize(transaction: OfflineTransaction): string;
+    deserialize(data: string): OfflineTransaction;
+    private serializeMutation;
+    private deserializeMutation;
+    private serializeValue;
+    private deserializeValue;
+    serializeError(error: Error): SerializedError;
+    deserializeError(data: SerializedError): Error;
+}

package/dist/esm/outbox/TransactionSerializer.js

@@ -0,0 +1,135 @@
+class TransactionSerializer {
+  constructor(collections) {
+    this.collections = collections;
+    this.collectionIdToKey = /* @__PURE__ */ new Map();
+    for (const [key, collection] of Object.entries(collections)) {
+      this.collectionIdToKey.set(collection.id, key);
+    }
+  }
+  serialize(transaction) {
+    const serialized = {
+      ...transaction,
+      createdAt: transaction.createdAt,
+      mutations: transaction.mutations.map(
+        (mutation) => this.serializeMutation(mutation)
+      )
+    };
+    return JSON.stringify(serialized, (key, value) => {
+      if (value instanceof Date) {
+        return value.toISOString();
+      }
+      return value;
+    });
+  }
+  deserialize(data) {
+    const parsed = JSON.parse(
+      data,
+      (key, value) => {
+        if (typeof value === `string` && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
+          return new Date(value);
+        }
+        return value;
+      }
+    );
+    return {
+      ...parsed,
+      mutations: parsed.mutations.map(
+        (mutationData) => this.deserializeMutation(mutationData)
+      )
+    };
+  }
+  serializeMutation(mutation) {
+    const registryKey = this.collectionIdToKey.get(mutation.collection.id);
+    if (!registryKey) {
+      throw new Error(
+        `Collection with id ${mutation.collection.id} not found in registry`
+      );
+    }
+    return {
+      globalKey: mutation.globalKey,
+      type: mutation.type,
+      modified: this.serializeValue(mutation.modified),
+      original: this.serializeValue(mutation.original),
+      collectionId: registryKey
+      // Store registry key instead of collection.id
+    };
+  }
+  deserializeMutation(data) {
+    const collection = this.collections[data.collectionId];
+    if (!collection) {
+      throw new Error(`Collection with id ${data.collectionId} not found`);
+    }
+    return {
+      globalKey: data.globalKey,
+      type: data.type,
+      modified: this.deserializeValue(data.modified),
+      original: this.deserializeValue(data.original),
+      collection,
+      // These fields would need to be reconstructed by the executor
+      mutationId: ``,
+      // Will be regenerated
+      key: null,
+      // Will be extracted from the data
+      changes: {},
+      // Will be recalculated
+      metadata: void 0,
+      syncMetadata: {},
+      optimistic: true,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  serializeValue(value) {
+    if (value === null || value === void 0) {
+      return value;
+    }
+    if (value instanceof Date) {
+      return { __type: `Date`, value: value.toISOString() };
+    }
+    if (typeof value === `object`) {
+      const result = Array.isArray(value) ? [] : {};
+      for (const key in value) {
+        if (value.hasOwnProperty(key)) {
+          result[key] = this.serializeValue(value[key]);
+        }
+      }
+      return result;
+    }
+    return value;
+  }
+  deserializeValue(value) {
+    if (value === null || value === void 0) {
+      return value;
+    }
+    if (typeof value === `object` && value.__type === `Date`) {
+      return new Date(value.value);
+    }
+    if (typeof value === `object`) {
+      const result = Array.isArray(value) ? [] : {};
+      for (const key in value) {
+        if (value.hasOwnProperty(key)) {
+          result[key] = this.deserializeValue(value[key]);
+        }
+      }
+      return result;
+    }
+    return value;
+  }
+  serializeError(error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    };
+  }
+  deserializeError(data) {
+    const error = new Error(data.message);
+    error.name = data.name;
+    error.stack = data.stack;
+    return error;
+  }
+}
+export {
+  TransactionSerializer
+};
+//# sourceMappingURL=TransactionSerializer.js.map

package/dist/esm/outbox/TransactionSerializer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionSerializer.js","sources":["../../../src/outbox/TransactionSerializer.ts"],"sourcesContent":["import type {\n  OfflineTransaction,\n  SerializedError,\n  SerializedMutation,\n  SerializedOfflineTransaction,\n} from \"../types\"\nimport type { Collection, PendingMutation } from \"@tanstack/db\"\n\nexport class TransactionSerializer {\n  private collections: Record<string, Collection>\n  private collectionIdToKey: Map<string, string>\n\n  constructor(collections: Record<string, Collection>) {\n    this.collections = collections\n    // Create reverse lookup from collection.id to registry key\n    this.collectionIdToKey = new Map()\n    for (const [key, collection] of Object.entries(collections)) {\n      this.collectionIdToKey.set(collection.id, key)\n    }\n  }\n\n  serialize(transaction: OfflineTransaction): string {\n    const serialized: SerializedOfflineTransaction = {\n      ...transaction,\n      createdAt: transaction.createdAt,\n      mutations: transaction.mutations.map((mutation) =>\n        this.serializeMutation(mutation)\n      ),\n    }\n    // Convert the whole object to JSON, handling dates\n    return JSON.stringify(serialized, (key, value) => {\n      if (value instanceof Date) {\n        return value.toISOString()\n      }\n      return value\n    })\n  }\n\n  deserialize(data: string): OfflineTransaction {\n    const parsed: SerializedOfflineTransaction = JSON.parse(\n      data,\n      (key, value) => {\n        // Parse ISO date strings back to Date objects\n        if (\n          typeof value === `string` &&\n          /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}/.test(value)\n        ) {\n          return new Date(value)\n        }\n        return value\n      }\n    )\n\n    return {\n      ...parsed,\n      mutations: parsed.mutations.map((mutationData) =>\n        this.deserializeMutation(mutationData)\n      ),\n    }\n  }\n\n  private serializeMutation(mutation: PendingMutation): SerializedMutation {\n    const registryKey = this.collectionIdToKey.get(mutation.collection.id)\n    if (!registryKey) {\n      throw new Error(\n        `Collection with id ${mutation.collection.id} not found in registry`\n      )\n    }\n\n    return {\n      globalKey: mutation.globalKey,\n      type: mutation.type,\n      modified: this.serializeValue(mutation.modified),\n      original: this.serializeValue(mutation.original),\n      collectionId: registryKey, // Store registry key instead of collection.id\n    }\n  }\n\n  private deserializeMutation(data: SerializedMutation): PendingMutation {\n    const collection = this.collections[data.collectionId]\n    if (!collection) {\n      throw new Error(`Collection with id ${data.collectionId} not found`)\n    }\n\n    // Create a partial PendingMutation - we can't fully reconstruct it but\n    // we provide what we can. The executor will need to handle the rest.\n    return {\n      globalKey: data.globalKey,\n      type: data.type as any,\n      modified: this.deserializeValue(data.modified),\n      original: this.deserializeValue(data.original),\n      collection,\n      // These fields would need to be reconstructed by the executor\n      mutationId: ``, // Will be regenerated\n      key: null, // Will be extracted from the data\n      changes: {}, // Will be recalculated\n      metadata: undefined,\n      syncMetadata: {},\n      optimistic: true,\n      createdAt: new Date(),\n      updatedAt: new Date(),\n    } as PendingMutation\n  }\n\n  private serializeValue(value: any): any {\n    if (value === null || value === undefined) {\n      return value\n    }\n\n    if (value instanceof Date) {\n      return { __type: `Date`, value: value.toISOString() }\n    }\n\n    if (typeof value === `object`) {\n      const result: any = Array.isArray(value) ? [] : {}\n      for (const key in value) {\n        if (value.hasOwnProperty(key)) {\n          result[key] = this.serializeValue(value[key])\n        }\n      }\n      return result\n    }\n\n    return value\n  }\n\n  private deserializeValue(value: any): any {\n    if (value === null || value === undefined) {\n      return value\n    }\n\n    if (typeof value === `object` && value.__type === `Date`) {\n      return new Date(value.value)\n    }\n\n    if (typeof value === `object`) {\n      const result: any = Array.isArray(value) ? [] : {}\n      for (const key in value) {\n        if (value.hasOwnProperty(key)) {\n          result[key] = this.deserializeValue(value[key])\n        }\n      }\n      return result\n    }\n\n    return value\n  }\n\n  serializeError(error: Error): SerializedError {\n    return {\n      name: error.name,\n      message: error.message,\n      stack: error.stack,\n    }\n  }\n\n  deserializeError(data: SerializedError): Error {\n    const error = new Error(data.message)\n    error.name = data.name\n    error.stack = data.stack\n    return error\n  }\n}\n"],"names":[],"mappings":"AAQO,MAAM,sBAAsB;AAAA,EAIjC,YAAY,aAAyC;AACnD,SAAK,cAAc;AAEnB,SAAK,wCAAwB,IAAA;AAC7B,eAAW,CAAC,KAAK,UAAU,KAAK,OAAO,QAAQ,WAAW,GAAG;AAC3D,WAAK,kBAAkB,IAAI,WAAW,IAAI,GAAG;AAAA,IAC/C;AAAA,EACF;AAAA,EAEA,UAAU,aAAyC;AACjD,UAAM,aAA2C;AAAA,MAC/C,GAAG;AAAA,MACH,WAAW,YAAY;AAAA,MACvB,WAAW,YAAY,UAAU;AAAA,QAAI,CAAC,aACpC,KAAK,kBAAkB,QAAQ;AAAA,MAAA;AAAA,IACjC;AAGF,WAAO,KAAK,UAAU,YAAY,CAAC,KAAK,UAAU;AAChD,UAAI,iBAAiB,MAAM;AACzB,eAAO,MAAM,YAAA;AAAA,MACf;AACA,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAAA,EAEA,YAAY,MAAkC;AAC5C,UAAM,SAAuC,KAAK;AAAA,MAChD;AAAA,MACA,CAAC,KAAK,UAAU;AAEd,YACE,OAAO,UAAU,YACjB,uCAAuC,KAAK,KAAK,GACjD;AACA,iBAAO,IAAI,KAAK,KAAK;AAAA,QACvB;AACA,eAAO;AAAA,MACT;AAAA,IAAA;AAGF,WAAO;AAAA,MACL,GAAG;AAAA,MACH,WAAW,OAAO,UAAU;AAAA,QAAI,CAAC,iBAC/B,KAAK,oBAAoB,YAAY;AAAA,MAAA;AAAA,IACvC;AAAA,EAEJ;AAAA,EAEQ,kBAAkB,UAA+C;AACvE,UAAM,cAAc,KAAK,kBAAkB,IAAI,SAAS,WAAW,EAAE;AACrE,QAAI,CAAC,aAAa;AAChB,YAAM,IAAI;AAAA,QACR,sBAAsB,SAAS,WAAW,EAAE;AAAA,MAAA;AAAA,IAEhD;AAEA,WAAO;AAAA,MACL,WAAW,SAAS;AAAA,MACpB,MAAM,SAAS;AAAA,MACf,UAAU,KAAK,eAAe,SAAS,QAAQ;AAAA,MAC/C,UAAU,KAAK,eAAe,SAAS,QAAQ;AAAA,MAC/C,cAAc;AAAA;AAAA,IAAA;AAAA,EAElB;AAAA,EAEQ,oBAAoB,MAA2C;AACrE,UAAM,aAAa,KAAK,YAAY,KAAK,YAAY;AACrD,QAAI,CAAC,YAAY;AACf,YAAM,IAAI,MAAM,sBAAsB,KAAK,YAAY,YAAY;AAAA,IACrE;AAIA,WAAO;AAAA,MACL,WAAW,KAAK;AAAA,MAChB,MAAM,KAAK;AAAA,MACX,UAAU,KAAK,iBAAiB,KAAK,QAAQ;AAAA,MAC7C,UAAU,KAAK,iBAAiB,KAAK,QAAQ;AAAA,MAC7C;AAAA;AAAA,MAEA,YAAY;AAAA;AAAA,MACZ,KAAK;AAAA;AAAA,MACL,SAAS,CAAA;AAAA;AAAA,MACT,UAAU;AAAA,MACV,cAAc,CAAA;AAAA,MACd,YAAY;AAAA,MACZ,+BAAe,KAAA;AAAA,MACf,+BAAe,KAAA;AAAA,IAAK;AAAA,EAExB;AAAA,EAEQ,eAAe,OAAiB;AACtC,QAAI,UAAU,QAAQ,UAAU,QAAW;AACzC,aAAO;AAAA,IACT;AAEA,QAAI,iBAAiB,MAAM;AACzB,aAAO,EAAE,QAAQ,QAAQ,OAAO,MAAM,cAAY;AAAA,IACpD;AAEA,QAAI,OAAO,UAAU,UAAU;AAC7B,YAAM,SAAc,MAAM,QAAQ,KAAK,IAAI,CAAA,IAAK,CAAA;AAChD,iBAAW,OAAO,OAAO;AACvB,YAAI,MAAM,eAAe,GAAG,GAAG;AAC7B,iBAAO,GAAG,IAAI,KAAK,eAAe,MAAM,GAAG,CAAC;AAAA,QAC9C;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT;AAAA,EAEQ,iBAAiB,OAAiB;AACxC,QAAI,UAAU,QAAQ,UAAU,QAAW;AACzC,aAAO;AAAA,IACT;AAEA,QAAI,OAAO,UAAU,YAAY,MAAM,WAAW,QAAQ;AACxD,aAAO,IAAI,KAAK,MAAM,KAAK;AAAA,IAC7B;AAEA,QAAI,OAAO,UAAU,UAAU;AAC7B,YAAM,SAAc,MAAM,QAAQ,KAAK,IAAI,CAAA,IAAK,CAAA;AAChD,iBAAW,OAAO,OAAO;AACvB,YAAI,MAAM,eAAe,GAAG,GAAG;AAC7B,iBAAO,GAAG,IAAI,KAAK,iBAAiB,MAAM,GAAG,CAAC;AAAA,QAChD;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,eAAe,OAA+B;AAC5C,WAAO;AAAA,MACL,MAAM,MAAM;AAAA,MACZ,SAAS,MAAM;AAAA,MACf,OAAO,MAAM;AAAA,IAAA;AAAA,EAEjB;AAAA,EAEA,iBAAiB,MAA8B;AAC7C,UAAM,QAAQ,IAAI,MAAM,KAAK,OAAO;AACpC,UAAM,OAAO,KAAK;AAClB,UAAM,QAAQ,KAAK;AACnB,WAAO;AAAA,EACT;AACF;"}

package/dist/esm/retry/BackoffCalculator.d.ts

@@ -0,0 +1,5 @@
+export declare class BackoffCalculator {
+    private jitter;
+    constructor(jitter?: boolean);
+    calculate(retryCount: number): number;
+}

package/dist/esm/retry/BackoffCalculator.js

@@ -0,0 +1,14 @@
+class BackoffCalculator {
+  constructor(jitter = true) {
+    this.jitter = jitter;
+  }
+  calculate(retryCount) {
+    const baseDelay = Math.min(1e3 * Math.pow(2, retryCount), 6e4);
+    const jitterMultiplier = this.jitter ? Math.random() * 0.3 : 0;
+    return Math.floor(baseDelay * (1 + jitterMultiplier));
+  }
+}
+export {
+  BackoffCalculator
+};
+//# sourceMappingURL=BackoffCalculator.js.map

package/dist/esm/retry/BackoffCalculator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BackoffCalculator.js","sources":["../../../src/retry/BackoffCalculator.ts"],"sourcesContent":["export class BackoffCalculator {\n  private jitter: boolean\n\n  constructor(jitter = true) {\n    this.jitter = jitter\n  }\n\n  calculate(retryCount: number): number {\n    const baseDelay = Math.min(1000 * Math.pow(2, retryCount), 60000)\n    const jitterMultiplier = this.jitter ? Math.random() * 0.3 : 0\n    return Math.floor(baseDelay * (1 + jitterMultiplier))\n  }\n}\n"],"names":[],"mappings":"AAAO,MAAM,kBAAkB;AAAA,EAG7B,YAAY,SAAS,MAAM;AACzB,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,UAAU,YAA4B;AACpC,UAAM,YAAY,KAAK,IAAI,MAAO,KAAK,IAAI,GAAG,UAAU,GAAG,GAAK;AAChE,UAAM,mBAAmB,KAAK,SAAS,KAAK,OAAA,IAAW,MAAM;AAC7D,WAAO,KAAK,MAAM,aAAa,IAAI,iBAAiB;AAAA,EACtD;AACF;"}