@tanstack/offline-transactions 1.0.65 → 1.1.1

package/dist/cjs/api/OfflineTransaction.cjs

@@ -1,79 +1,82 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const db = require("@tanstack/db");
-const types = require("../types.cjs");
 class OfflineTransaction {
   // Will be typed properly - reference to OfflineExecutor
   constructor(options, mutationFn, persistTransaction, executor) {
     this.transaction = null;
+    this.persisting = false;
     this.offlineId = db.safeRandomUUID();
     this.mutationFnName = options.mutationFnName;
-    this.autoCommit = options.autoCommit ?? true;
+    this.autoCommit = options.autoCommit;
     this.idempotencyKey = options.idempotencyKey ?? db.safeRandomUUID();
     this.metadata = options.metadata ?? {};
     this.persistTransaction = persistTransaction;
     this.executor = executor;
   }
   mutate(callback) {
-    this.transaction = db.createTransaction({
-      id: this.offlineId,
-      autoCommit: false,
-      mutationFn: async () => {
-        const offlineTransaction = {
-          id: this.offlineId,
-          mutationFnName: this.mutationFnName,
-          mutations: this.transaction.mutations,
-          keys: this.extractKeys(this.transaction.mutations),
-          idempotencyKey: this.idempotencyKey,
-          createdAt: /* @__PURE__ */ new Date(),
-          retryCount: 0,
-          nextAttemptAt: Date.now(),
-          metadata: this.metadata,
-          spanContext: void 0,
-          version: 1
-        };
-        const completionPromise = this.executor.waitForTransactionCompletion(
-          this.offlineId
-        );
-        try {
-          await Promise.race([
-            this.persistTransaction(offlineTransaction),
-            completionPromise
-          ]);
-          await completionPromise;
-        } catch (error) {
-          const normalizedError = error instanceof Error ? error : new Error(String(error));
-          this.executor.rejectTransaction(this.offlineId, normalizedError);
-          throw error;
+    if (!this.transaction) {
+      this.transaction = db.createTransaction({
+        id: this.offlineId,
+        autoCommit: this.autoCommit,
+        mutationFn: async () => {
+          this.persisting = true;
+          const offlineTransaction = {
+            id: this.offlineId,
+            mutationFnName: this.mutationFnName,
+            mutations: this.transaction.mutations,
+            keys: this.extractKeys(this.transaction.mutations),
+            idempotencyKey: this.idempotencyKey,
+            createdAt: /* @__PURE__ */ new Date(),
+            retryCount: 0,
+            nextAttemptAt: Date.now(),
+            metadata: this.metadata,
+            spanContext: void 0,
+            version: 1
+          };
+          const completionPromise = this.executor.waitForTransactionCompletion(
+            this.offlineId
+          );
+          try {
+            await Promise.race([
+              this.persistTransaction(offlineTransaction),
+              completionPromise
+            ]);
+            await completionPromise;
+          } catch (error) {
+            const normalizedError = error instanceof Error ? error : new Error(String(error));
+            this.executor.rejectTransaction(this.offlineId, normalizedError);
+            throw error;
+          }
+          return;
+        },
+        metadata: this.metadata
+      });
+      void this.transaction.when(`settled`).then(
+        () => {
+          if (!this.persisting)
+            this.executor.resolveTransaction(this.offlineId, void 0);
+        },
+        (error) => {
+          if (!this.persisting)
+            this.executor.rejectTransaction(
+              this.offlineId,
+              error instanceof Error ? error : new Error(`Offline transaction was rolled back`)
+            );
         }
-        return;
-      },
-      metadata: this.metadata
-    });
+      );
+    }
     this.transaction.mutate(() => {
       callback();
     });
-    if (this.autoCommit) {
-      this.commit().catch((error) => {
-        console.error(`Auto-commit failed:`, error);
-        throw error;
-      });
-    }
     return this.transaction;
   }
   async commit() {
     if (!this.transaction) {
       throw new Error(`No mutations to commit. Call mutate() first.`);
     }
-    try {
-      await this.transaction.commit();
-      return this.transaction;
-    } catch (error) {
-      if (error instanceof types.NonRetriableError) {
-        this.transaction.rollback();
-      }
-      throw error;
-    }
+    await this.transaction.commit();
+    return this.transaction;
   }
   rollback() {
     if (this.transaction) {

package/dist/cjs/api/OfflineTransaction.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"OfflineTransaction.cjs","sources":["../../../src/api/OfflineTransaction.ts"],"sourcesContent":["import { createTransaction, safeRandomUUID } from '@tanstack/db'\nimport { NonRetriableError } from '../types'\nimport type { PendingMutation, Transaction } from '@tanstack/db'\nimport type {\n  CreateOfflineTransactionOptions,\n  OfflineMutationFn,\n  OfflineTransaction as OfflineTransactionType,\n} from '../types'\n\nexport class OfflineTransaction {\n  private offlineId: string\n  private mutationFnName: string\n  private autoCommit: boolean\n  private idempotencyKey: string\n  private metadata: Record<string, any>\n  private transaction: Transaction | null = null\n  private persistTransaction: (tx: OfflineTransactionType) => Promise<void>\n  private executor: any // Will be typed properly - reference to OfflineExecutor\n\n  constructor(\n    options: CreateOfflineTransactionOptions,\n    mutationFn: OfflineMutationFn,\n    persistTransaction: (tx: OfflineTransactionType) => Promise<void>,\n    executor: any,\n  ) {\n    this.offlineId = safeRandomUUID()\n    this.mutationFnName = options.mutationFnName\n    this.autoCommit = options.autoCommit ?? true\n    this.idempotencyKey = options.idempotencyKey ?? safeRandomUUID()\n    this.metadata = options.metadata ?? {}\n    this.persistTransaction = persistTransaction\n    this.executor = executor\n  }\n\n  mutate(callback: () => void): Transaction {\n    this.transaction = createTransaction({\n      id: this.offlineId,\n      autoCommit: false,\n      mutationFn: async () => {\n        // This is the blocking mutationFn that waits for the executor\n        // First persist the transaction to the outbox\n        const offlineTransaction: OfflineTransactionType = {\n          id: this.offlineId,\n          mutationFnName: this.mutationFnName,\n          mutations: this.transaction!.mutations,\n          keys: this.extractKeys(this.transaction!.mutations),\n          idempotencyKey: this.idempotencyKey,\n          createdAt: new Date(),\n          retryCount: 0,\n          nextAttemptAt: Date.now(),\n          metadata: this.metadata,\n          spanContext: undefined,\n          version: 1,\n        }\n\n        const completionPromise = this.executor.waitForTransactionCompletion(\n          this.offlineId,\n        )\n\n        try {\n          // Persistence also drives the shared queue. This transaction can finish\n          // before that queue drains; observe both promises from the outset.\n          await Promise.race([\n            this.persistTransaction(offlineTransaction),\n            completionPromise,\n          ])\n          // A queue pause (offline or retry) is not transaction completion.\n          await completionPromise\n        } catch (error) {\n          const normalizedError =\n            error instanceof Error ? error : new Error(String(error))\n          this.executor.rejectTransaction(this.offlineId, normalizedError)\n          throw error\n        }\n\n        return\n      },\n      metadata: this.metadata,\n    })\n\n    this.transaction.mutate(() => {\n      callback()\n    })\n\n    if (this.autoCommit) {\n      // Auto-commit for direct OfflineTransaction usage\n      this.commit().catch((error) => {\n        console.error(`Auto-commit failed:`, error)\n        throw error\n      })\n    }\n\n    return this.transaction\n  }\n\n  async commit(): Promise<Transaction> {\n    if (!this.transaction) {\n      throw new Error(`No mutations to commit. Call mutate() first.`)\n    }\n\n    try {\n      // Commit the TanStack DB transaction\n      // This will trigger the mutationFn which handles persistence and waiting\n      await this.transaction.commit()\n      return this.transaction\n    } catch (error) {\n      // Only rollback for NonRetriableError - other errors should allow retry\n      if (error instanceof NonRetriableError) {\n        this.transaction.rollback()\n      }\n      throw error\n    }\n  }\n\n  rollback(): void {\n    if (this.transaction) {\n      this.transaction.rollback()\n    }\n  }\n\n  private extractKeys(mutations: Array<PendingMutation>): Array<string> {\n    return mutations.map((mutation) => mutation.globalKey)\n  }\n\n  get id(): string {\n    return this.offlineId\n  }\n}\n"],"names":["safeRandomUUID","createTransaction","NonRetriableError"],"mappings":";;;;AASO,MAAM,mBAAmB;AAAA;AAAA,EAU9B,YACE,SACA,YACA,oBACA,UACA;AATF,SAAQ,cAAkC;AAUxC,SAAK,YAAYA,kBAAA;AACjB,SAAK,iBAAiB,QAAQ;AAC9B,SAAK,aAAa,QAAQ,cAAc;AACxC,SAAK,iBAAiB,QAAQ,kBAAkBA,GAAAA,eAAA;AAChD,SAAK,WAAW,QAAQ,YAAY,CAAA;AACpC,SAAK,qBAAqB;AAC1B,SAAK,WAAW;AAAA,EAClB;AAAA,EAEA,OAAO,UAAmC;AACxC,SAAK,cAAcC,qBAAkB;AAAA,MACnC,IAAI,KAAK;AAAA,MACT,YAAY;AAAA,MACZ,YAAY,YAAY;AAGtB,cAAM,qBAA6C;AAAA,UACjD,IAAI,KAAK;AAAA,UACT,gBAAgB,KAAK;AAAA,UACrB,WAAW,KAAK,YAAa;AAAA,UAC7B,MAAM,KAAK,YAAY,KAAK,YAAa,SAAS;AAAA,UAClD,gBAAgB,KAAK;AAAA,UACrB,+BAAe,KAAA;AAAA,UACf,YAAY;AAAA,UACZ,eAAe,KAAK,IAAA;AAAA,UACpB,UAAU,KAAK;AAAA,UACf,aAAa;AAAA,UACb,SAAS;AAAA,QAAA;AAGX,cAAM,oBAAoB,KAAK,SAAS;AAAA,UACtC,KAAK;AAAA,QAAA;AAGP,YAAI;AAGF,gBAAM,QAAQ,KAAK;AAAA,YACjB,KAAK,mBAAmB,kBAAkB;AAAA,YAC1C;AAAA,UAAA,CACD;AAED,gBAAM;AAAA,QACR,SAAS,OAAO;AACd,gBAAM,kBACJ,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;AAC1D,eAAK,SAAS,kBAAkB,KAAK,WAAW,eAAe;AAC/D,gBAAM;AAAA,QACR;AAEA;AAAA,MACF;AAAA,MACA,UAAU,KAAK;AAAA,IAAA,CAChB;AAED,SAAK,YAAY,OAAO,MAAM;AAC5B,eAAA;AAAA,IACF,CAAC;AAED,QAAI,KAAK,YAAY;AAEnB,WAAK,OAAA,EAAS,MAAM,CAAC,UAAU;AAC7B,gBAAQ,MAAM,uBAAuB,KAAK;AAC1C,cAAM;AAAA,MACR,CAAC;AAAA,IACH;AAEA,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,MAAM,SAA+B;AACnC,QAAI,CAAC,KAAK,aAAa;AACrB,YAAM,IAAI,MAAM,8CAA8C;AAAA,IAChE;AAEA,QAAI;AAGF,YAAM,KAAK,YAAY,OAAA;AACvB,aAAO,KAAK;AAAA,IACd,SAAS,OAAO;AAEd,UAAI,iBAAiBC,MAAAA,mBAAmB;AACtC,aAAK,YAAY,SAAA;AAAA,MACnB;AACA,YAAM;AAAA,IACR;AAAA,EACF;AAAA,EAEA,WAAiB;AACf,QAAI,KAAK,aAAa;AACpB,WAAK,YAAY,SAAA;AAAA,IACnB;AAAA,EACF;AAAA,EAEQ,YAAY,WAAkD;AACpE,WAAO,UAAU,IAAI,CAAC,aAAa,SAAS,SAAS;AAAA,EACvD;AAAA,EAEA,IAAI,KAAa;AACf,WAAO,KAAK;AAAA,EACd;AACF;;"}
+{"version":3,"file":"OfflineTransaction.cjs","sources":["../../../src/api/OfflineTransaction.ts"],"sourcesContent":["import { createTransaction, safeRandomUUID } from '@tanstack/db'\nimport type { PendingMutation, Transaction } from '@tanstack/db'\nimport type {\n  CreateOfflineTransactionOptions,\n  OfflineMutationFn,\n  OfflineTransaction as OfflineTransactionType,\n} from '../types'\n\nexport class OfflineTransaction {\n  private offlineId: string\n  private mutationFnName: string\n  private autoCommit: boolean | undefined\n  private idempotencyKey: string\n  private metadata: Record<string, any>\n  private transaction: Transaction | null = null\n  /** The mutation function ran, so the executor settles the waiter. */\n  private persisting = false\n  private persistTransaction: (tx: OfflineTransactionType) => Promise<void>\n  private executor: any // Will be typed properly - reference to OfflineExecutor\n\n  constructor(\n    options: CreateOfflineTransactionOptions,\n    mutationFn: OfflineMutationFn,\n    persistTransaction: (tx: OfflineTransactionType) => Promise<void>,\n    executor: any,\n  ) {\n    this.offlineId = safeRandomUUID()\n    this.mutationFnName = options.mutationFnName\n    // The TanStack DB transaction applies the default.\n    this.autoCommit = options.autoCommit\n    this.idempotencyKey = options.idempotencyKey ?? safeRandomUUID()\n    this.metadata = options.metadata ?? {}\n    this.persistTransaction = persistTransaction\n    this.executor = executor\n  }\n\n  mutate(callback: () => void): Transaction {\n    // One offline transaction is one transaction, and its id is unique among\n    // live transactions. Repeated calls add to it while it is pending. With\n    // autoCommit, it commits after this callback and reports a failure\n    // through `when('settled')`, so a later call throws: it is no longer pending.\n    if (!this.transaction) {\n      this.transaction = createTransaction({\n        id: this.offlineId,\n        autoCommit: this.autoCommit,\n        mutationFn: async () => {\n          this.persisting = true\n          // This is the blocking mutationFn that waits for the executor\n          // First persist the transaction to the outbox\n          const offlineTransaction: OfflineTransactionType = {\n            id: this.offlineId,\n            mutationFnName: this.mutationFnName,\n            mutations: this.transaction!.mutations,\n            keys: this.extractKeys(this.transaction!.mutations),\n            idempotencyKey: this.idempotencyKey,\n            createdAt: new Date(),\n            retryCount: 0,\n            nextAttemptAt: Date.now(),\n            metadata: this.metadata,\n            spanContext: undefined,\n            version: 1,\n          }\n\n          const completionPromise = this.executor.waitForTransactionCompletion(\n            this.offlineId,\n          )\n\n          try {\n            // Persistence also drives the shared queue. This transaction can finish\n            // before that queue drains; observe both promises from the outset.\n            await Promise.race([\n              this.persistTransaction(offlineTransaction),\n              completionPromise,\n            ])\n            // A queue pause (offline or retry) is not transaction completion.\n            await completionPromise\n          } catch (error) {\n            const normalizedError =\n              error instanceof Error ? error : new Error(String(error))\n            this.executor.rejectTransaction(this.offlineId, normalizedError)\n            throw error\n          }\n\n          return\n        },\n        metadata: this.metadata,\n      })\n      // A transaction without mutations completes, and one rolled back before\n      // it commits fails, without its mutation function, so the executor never\n      // settles its waiter. Settle that waiter here with the same outcome. Once\n      // the mutation function runs, only the executor settles it.\n      void this.transaction.when(`settled`).then(\n        () => {\n          if (!this.persisting)\n            this.executor.resolveTransaction(this.offlineId, undefined)\n        },\n        (error: unknown) => {\n          if (!this.persisting)\n            this.executor.rejectTransaction(\n              this.offlineId,\n              error instanceof Error\n                ? error\n                : new Error(`Offline transaction was rolled back`),\n            )\n        },\n      )\n    }\n\n    this.transaction.mutate(() => {\n      callback()\n    })\n\n    return this.transaction\n  }\n\n  async commit(): Promise<Transaction> {\n    if (!this.transaction) {\n      throw new Error(`No mutations to commit. Call mutate() first.`)\n    }\n\n    // The mutationFn persists the transaction and waits for the executor. A\n    // commit that rejects has already rolled the transaction back. A sibling's\n    // failure can also roll it back while it waits, and then commit() resolves,\n    // so `when('settled')` is the receipt.\n    await this.transaction.commit()\n    return this.transaction\n  }\n\n  rollback(): void {\n    if (this.transaction) {\n      this.transaction.rollback()\n    }\n  }\n\n  private extractKeys(mutations: Array<PendingMutation>): Array<string> {\n    return mutations.map((mutation) => mutation.globalKey)\n  }\n\n  get id(): string {\n    return this.offlineId\n  }\n}\n"],"names":["safeRandomUUID","createTransaction"],"mappings":";;;AAQO,MAAM,mBAAmB;AAAA;AAAA,EAY9B,YACE,SACA,YACA,oBACA,UACA;AAXF,SAAQ,cAAkC;AAE1C,SAAQ,aAAa;AAUnB,SAAK,YAAYA,kBAAA;AACjB,SAAK,iBAAiB,QAAQ;AAE9B,SAAK,aAAa,QAAQ;AAC1B,SAAK,iBAAiB,QAAQ,kBAAkBA,GAAAA,eAAA;AAChD,SAAK,WAAW,QAAQ,YAAY,CAAA;AACpC,SAAK,qBAAqB;AAC1B,SAAK,WAAW;AAAA,EAClB;AAAA,EAEA,OAAO,UAAmC;AAKxC,QAAI,CAAC,KAAK,aAAa;AACrB,WAAK,cAAcC,qBAAkB;AAAA,QACnC,IAAI,KAAK;AAAA,QACT,YAAY,KAAK;AAAA,QACjB,YAAY,YAAY;AACtB,eAAK,aAAa;AAGlB,gBAAM,qBAA6C;AAAA,YACjD,IAAI,KAAK;AAAA,YACT,gBAAgB,KAAK;AAAA,YACrB,WAAW,KAAK,YAAa;AAAA,YAC7B,MAAM,KAAK,YAAY,KAAK,YAAa,SAAS;AAAA,YAClD,gBAAgB,KAAK;AAAA,YACrB,+BAAe,KAAA;AAAA,YACf,YAAY;AAAA,YACZ,eAAe,KAAK,IAAA;AAAA,YACpB,UAAU,KAAK;AAAA,YACf,aAAa;AAAA,YACb,SAAS;AAAA,UAAA;AAGX,gBAAM,oBAAoB,KAAK,SAAS;AAAA,YACtC,KAAK;AAAA,UAAA;AAGP,cAAI;AAGF,kBAAM,QAAQ,KAAK;AAAA,cACjB,KAAK,mBAAmB,kBAAkB;AAAA,cAC1C;AAAA,YAAA,CACD;AAED,kBAAM;AAAA,UACR,SAAS,OAAO;AACd,kBAAM,kBACJ,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;AAC1D,iBAAK,SAAS,kBAAkB,KAAK,WAAW,eAAe;AAC/D,kBAAM;AAAA,UACR;AAEA;AAAA,QACF;AAAA,QACA,UAAU,KAAK;AAAA,MAAA,CAChB;AAKD,WAAK,KAAK,YAAY,KAAK,SAAS,EAAE;AAAA,QACpC,MAAM;AACJ,cAAI,CAAC,KAAK;AACR,iBAAK,SAAS,mBAAmB,KAAK,WAAW,MAAS;AAAA,QAC9D;AAAA,QACA,CAAC,UAAmB;AAClB,cAAI,CAAC,KAAK;AACR,iBAAK,SAAS;AAAA,cACZ,KAAK;AAAA,cACL,iBAAiB,QACb,QACA,IAAI,MAAM,qCAAqC;AAAA,YAAA;AAAA,QAEzD;AAAA,MAAA;AAAA,IAEJ;AAEA,SAAK,YAAY,OAAO,MAAM;AAC5B,eAAA;AAAA,IACF,CAAC;AAED,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,MAAM,SAA+B;AACnC,QAAI,CAAC,KAAK,aAAa;AACrB,YAAM,IAAI,MAAM,8CAA8C;AAAA,IAChE;AAMA,UAAM,KAAK,YAAY,OAAA;AACvB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,WAAiB;AACf,QAAI,KAAK,aAAa;AACpB,WAAK,YAAY,SAAA;AAAA,IACnB;AAAA,EACF;AAAA,EAEQ,YAAY,WAAkD;AACpE,WAAO,UAAU,IAAI,CAAC,aAAa,SAAS,SAAS;AAAA,EACvD;AAAA,EAEA,IAAI,KAAa;AACf,WAAO,KAAK;AAAA,EACd;AACF;;"}

package/dist/cjs/api/OfflineTransaction.d.cts

@@ -7,6 +7,8 @@ export declare class OfflineTransaction {
     private idempotencyKey;
     private metadata;
     private transaction;
+    /** The mutation function ran, so the executor settles the waiter. */
+    private persisting;
     private persistTransaction;
     private executor;
     constructor(options: CreateOfflineTransactionOptions, mutationFn: OfflineMutationFn, persistTransaction: (tx: OfflineTransactionType) => Promise<void>, executor: any);

package/dist/cjs/executor/KeyScheduler.cjs

@@ -1,51 +1,25 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const tracer = require("../telemetry/tracer.cjs");
 class KeyScheduler {
   constructor() {
     this.pendingTransactions = [];
   }
   schedule(transaction) {
-    return tracer.withSyncSpan(
-      `scheduler.schedule`,
-      {
-        "transaction.id": transaction.id,
-        queueLength: this.pendingTransactions.length
-      },
-      () => {
-        if (this.pendingTransactions.some(
-          (pending) => pending.id === transaction.id
-        )) {
-          return false;
-        }
-        this.pendingTransactions.push(transaction);
-        this.pendingTransactions.sort(
-          (a, b) => a.createdAt.getTime() - b.createdAt.getTime()
-        );
-        return true;
-      }
+    if (this.pendingTransactions.some((pending) => pending.id === transaction.id)) {
+      return false;
+    }
+    this.pendingTransactions.push(transaction);
+    this.pendingTransactions.sort(
+      (a, b) => a.createdAt.getTime() - b.createdAt.getTime()
     );
+    return true;
   }
   getNext() {
-    return tracer.withSyncSpan(
-      `scheduler.getNext`,
-      { pendingCount: this.pendingTransactions.length },
-      (span) => {
-        if (this.activeTransactionId !== void 0 || this.pendingTransactions.length === 0) {
-          span.setAttribute(`result`, `empty`);
-          return void 0;
-        }
-        const firstTransaction = this.pendingTransactions[0];
-        if (!this.isReadyToRun(firstTransaction)) {
-          span.setAttribute(`result`, `waiting_for_first`);
-          span.setAttribute(`transaction.id`, firstTransaction.id);
-          return void 0;
-        }
-        span.setAttribute(`result`, `found`);
-        span.setAttribute(`transaction.id`, firstTransaction.id);
-        return firstTransaction;
-      }
-    );
+    if (this.activeTransactionId !== void 0 || this.pendingTransactions.length === 0) {
+      return void 0;
+    }
+    const firstTransaction = this.pendingTransactions[0];
+    return this.isReadyToRun(firstTransaction) ? firstTransaction : void 0;
   }
   isReadyToRun(transaction) {
     return Date.now() >= transaction.nextAttemptAt;

package/dist/cjs/executor/KeyScheduler.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"KeyScheduler.cjs","sources":["../../../src/executor/KeyScheduler.ts"],"sourcesContent":["import { withSyncSpan } from '../telemetry/tracer'\nimport type { OfflineTransaction } from '../types'\n\nexport class KeyScheduler {\n  private pendingTransactions: Array<OfflineTransaction> = []\n  private activeTransactionId: string | undefined\n\n  schedule(transaction: OfflineTransaction): boolean {\n    return withSyncSpan(\n      `scheduler.schedule`,\n      {\n        'transaction.id': transaction.id,\n        queueLength: this.pendingTransactions.length,\n      },\n      () => {\n        if (\n          this.pendingTransactions.some(\n            (pending) => pending.id === transaction.id,\n          )\n        ) {\n          return false\n        }\n        this.pendingTransactions.push(transaction)\n        // Sort by creation time to maintain FIFO order\n        this.pendingTransactions.sort(\n          (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),\n        )\n        return true\n      },\n    )\n  }\n\n  getNext(): OfflineTransaction | undefined {\n    return withSyncSpan(\n      `scheduler.getNext`,\n      { pendingCount: this.pendingTransactions.length },\n      (span) => {\n        if (\n          this.activeTransactionId !== undefined ||\n          this.pendingTransactions.length === 0\n        ) {\n          span.setAttribute(`result`, `empty`)\n          return undefined\n        }\n\n        const firstTransaction = this.pendingTransactions[0]!\n\n        if (!this.isReadyToRun(firstTransaction)) {\n          span.setAttribute(`result`, `waiting_for_first`)\n          span.setAttribute(`transaction.id`, firstTransaction.id)\n          return undefined\n        }\n\n        span.setAttribute(`result`, `found`)\n        span.setAttribute(`transaction.id`, firstTransaction.id)\n        return firstTransaction\n      },\n    )\n  }\n\n  private isReadyToRun(transaction: OfflineTransaction): boolean {\n    return Date.now() >= transaction.nextAttemptAt\n  }\n\n  markStarted(transaction: OfflineTransaction): void {\n    this.activeTransactionId = transaction.id\n  }\n\n  markCompleted(transaction: OfflineTransaction): void {\n    this.removeTransaction(transaction)\n    this.activeTransactionId = undefined\n  }\n\n  markFailed(_transaction: OfflineTransaction): void {\n    this.activeTransactionId = undefined\n  }\n\n  private removeTransaction(transaction: OfflineTransaction): void {\n    const index = this.pendingTransactions.findIndex(\n      (tx) => tx.id === transaction.id,\n    )\n    if (index >= 0) {\n      this.pendingTransactions.splice(index, 1)\n    }\n  }\n\n  updateTransaction(transaction: OfflineTransaction): void {\n    this.updateTransactions([transaction])\n  }\n\n  getPendingCount(): number {\n    return this.pendingTransactions.length\n  }\n\n  getRunningCount(): number {\n    return this.activeTransactionId === undefined ? 0 : 1\n  }\n\n  clear(): void {\n    this.pendingTransactions = []\n    this.activeTransactionId = undefined\n  }\n\n  /** @internal Reconcile one replay snapshot without canceling issued work. */\n  removePendingTransactions(transactionIds: Iterable<string>): Array<string> {\n    const ids = new Set(transactionIds)\n    if (this.activeTransactionId !== undefined)\n      ids.delete(this.activeTransactionId)\n    this.pendingTransactions = this.pendingTransactions.filter(\n      ({ id }) => !ids.has(id),\n    )\n    return [...ids]\n  }\n\n  getAllPendingTransactions(): Array<OfflineTransaction> {\n    return [...this.pendingTransactions]\n  }\n\n  updateTransactions(updatedTransactions: Array<OfflineTransaction>): void {\n    const updatedById = new Map(\n      updatedTransactions.map((transaction) => [transaction.id, transaction]),\n    )\n    this.pendingTransactions = this.pendingTransactions.map(\n      (transaction) => updatedById.get(transaction.id) ?? transaction,\n    )\n    // Re-sort to maintain FIFO order after updates\n    this.pendingTransactions.sort(\n      (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),\n    )\n  }\n}\n"],"names":["withSyncSpan"],"mappings":"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"}
+{"version":3,"file":"KeyScheduler.cjs","sources":["../../../src/executor/KeyScheduler.ts"],"sourcesContent":["import type { OfflineTransaction } from '../types'\n\nexport class KeyScheduler {\n  private pendingTransactions: Array<OfflineTransaction> = []\n  private activeTransactionId: string | undefined\n\n  schedule(transaction: OfflineTransaction): boolean {\n    if (\n      this.pendingTransactions.some((pending) => pending.id === transaction.id)\n    ) {\n      return false\n    }\n    this.pendingTransactions.push(transaction)\n    // Sort by creation time to maintain FIFO order\n    this.pendingTransactions.sort(\n      (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),\n    )\n    return true\n  }\n\n  getNext(): OfflineTransaction | undefined {\n    if (\n      this.activeTransactionId !== undefined ||\n      this.pendingTransactions.length === 0\n    ) {\n      return undefined\n    }\n    const firstTransaction = this.pendingTransactions[0]!\n    return this.isReadyToRun(firstTransaction) ? firstTransaction : undefined\n  }\n\n  private isReadyToRun(transaction: OfflineTransaction): boolean {\n    return Date.now() >= transaction.nextAttemptAt\n  }\n\n  markStarted(transaction: OfflineTransaction): void {\n    this.activeTransactionId = transaction.id\n  }\n\n  markCompleted(transaction: OfflineTransaction): void {\n    this.removeTransaction(transaction)\n    this.activeTransactionId = undefined\n  }\n\n  markFailed(_transaction: OfflineTransaction): void {\n    this.activeTransactionId = undefined\n  }\n\n  private removeTransaction(transaction: OfflineTransaction): void {\n    const index = this.pendingTransactions.findIndex(\n      (tx) => tx.id === transaction.id,\n    )\n    if (index >= 0) {\n      this.pendingTransactions.splice(index, 1)\n    }\n  }\n\n  updateTransaction(transaction: OfflineTransaction): void {\n    this.updateTransactions([transaction])\n  }\n\n  getPendingCount(): number {\n    return this.pendingTransactions.length\n  }\n\n  getRunningCount(): number {\n    return this.activeTransactionId === undefined ? 0 : 1\n  }\n\n  clear(): void {\n    this.pendingTransactions = []\n    this.activeTransactionId = undefined\n  }\n\n  /** @internal Reconcile one replay snapshot without canceling issued work. */\n  removePendingTransactions(transactionIds: Iterable<string>): Array<string> {\n    const ids = new Set(transactionIds)\n    if (this.activeTransactionId !== undefined)\n      ids.delete(this.activeTransactionId)\n    this.pendingTransactions = this.pendingTransactions.filter(\n      ({ id }) => !ids.has(id),\n    )\n    return [...ids]\n  }\n\n  getAllPendingTransactions(): Array<OfflineTransaction> {\n    return [...this.pendingTransactions]\n  }\n\n  updateTransactions(updatedTransactions: Array<OfflineTransaction>): void {\n    const updatedById = new Map(\n      updatedTransactions.map((transaction) => [transaction.id, transaction]),\n    )\n    this.pendingTransactions = this.pendingTransactions.map(\n      (transaction) => updatedById.get(transaction.id) ?? transaction,\n    )\n    // Re-sort to maintain FIFO order after updates\n    this.pendingTransactions.sort(\n      (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),\n    )\n  }\n}\n"],"names":[],"mappings":";;AAEO,MAAM,aAAa;AAAA,EAAnB,cAAA;AACL,SAAQ,sBAAiD,CAAA;AAAA,EAAC;AAAA,EAG1D,SAAS,aAA0C;AACjD,QACE,KAAK,oBAAoB,KAAK,CAAC,YAAY,QAAQ,OAAO,YAAY,EAAE,GACxE;AACA,aAAO;AAAA,IACT;AACA,SAAK,oBAAoB,KAAK,WAAW;AAEzC,SAAK,oBAAoB;AAAA,MACvB,CAAC,GAAG,MAAM,EAAE,UAAU,YAAY,EAAE,UAAU,QAAA;AAAA,IAAQ;AAExD,WAAO;AAAA,EACT;AAAA,EAEA,UAA0C;AACxC,QACE,KAAK,wBAAwB,UAC7B,KAAK,oBAAoB,WAAW,GACpC;AACA,aAAO;AAAA,IACT;AACA,UAAM,mBAAmB,KAAK,oBAAoB,CAAC;AACnD,WAAO,KAAK,aAAa,gBAAgB,IAAI,mBAAmB;AAAA,EAClE;AAAA,EAEQ,aAAa,aAA0C;AAC7D,WAAO,KAAK,SAAS,YAAY;AAAA,EACnC;AAAA,EAEA,YAAY,aAAuC;AACjD,SAAK,sBAAsB,YAAY;AAAA,EACzC;AAAA,EAEA,cAAc,aAAuC;AACnD,SAAK,kBAAkB,WAAW;AAClC,SAAK,sBAAsB;AAAA,EAC7B;AAAA,EAEA,WAAW,cAAwC;AACjD,SAAK,sBAAsB;AAAA,EAC7B;AAAA,EAEQ,kBAAkB,aAAuC;AAC/D,UAAM,QAAQ,KAAK,oBAAoB;AAAA,MACrC,CAAC,OAAO,GAAG,OAAO,YAAY;AAAA,IAAA;AAEhC,QAAI,SAAS,GAAG;AACd,WAAK,oBAAoB,OAAO,OAAO,CAAC;AAAA,IAC1C;AAAA,EACF;AAAA,EAEA,kBAAkB,aAAuC;AACvD,SAAK,mBAAmB,CAAC,WAAW,CAAC;AAAA,EACvC;AAAA,EAEA,kBAA0B;AACxB,WAAO,KAAK,oBAAoB;AAAA,EAClC;AAAA,EAEA,kBAA0B;AACxB,WAAO,KAAK,wBAAwB,SAAY,IAAI;AAAA,EACtD;AAAA,EAEA,QAAc;AACZ,SAAK,sBAAsB,CAAA;AAC3B,SAAK,sBAAsB;AAAA,EAC7B;AAAA;AAAA,EAGA,0BAA0B,gBAAiD;AACzE,UAAM,MAAM,IAAI,IAAI,cAAc;AAClC,QAAI,KAAK,wBAAwB;AAC/B,UAAI,OAAO,KAAK,mBAAmB;AACrC,SAAK,sBAAsB,KAAK,oBAAoB;AAAA,MAClD,CAAC,EAAE,GAAA,MAAS,CAAC,IAAI,IAAI,EAAE;AAAA,IAAA;AAEzB,WAAO,CAAC,GAAG,GAAG;AAAA,EAChB;AAAA,EAEA,4BAAuD;AACrD,WAAO,CAAC,GAAG,KAAK,mBAAmB;AAAA,EACrC;AAAA,EAEA,mBAAmB,qBAAsD;AACvE,UAAM,cAAc,IAAI;AAAA,MACtB,oBAAoB,IAAI,CAAC,gBAAgB,CAAC,YAAY,IAAI,WAAW,CAAC;AAAA,IAAA;AAExE,SAAK,sBAAsB,KAAK,oBAAoB;AAAA,MAClD,CAAC,gBAAgB,YAAY,IAAI,YAAY,EAAE,KAAK;AAAA,IAAA;AAGtD,SAAK,oBAAoB;AAAA,MACvB,CAAC,GAAG,MAAM,EAAE,UAAU,YAAY,EAAE,UAAU,QAAA;AAAA,IAAQ;AAAA,EAE1D;AACF;;"}

package/dist/cjs/executor/TransactionExecutor.cjs

@@ -4,8 +4,10 @@ const db = require("@tanstack/db");
 const OutboxManager = require("../outbox/OutboxManager.cjs");
 const RetryPolicy = require("../retry/RetryPolicy.cjs");
 const types = require("../types.cjs");
-const tracer = require("../telemetry/tracer.cjs");
 const HANDLED_EXECUTION_ERROR = /* @__PURE__ */ Symbol(`HandledExecutionError`);
+function toError(value) {
+  return value instanceof Error || Object.prototype.toString.call(value) === `[object Error]` ? value : new Error(String(value));
+}
 class TransactionExecutor {
   constructor(scheduler, outbox, config, offlineExecutor) {
     this.isExecuting = false;
@@ -55,61 +57,39 @@ class TransactionExecutor {
   }
   async executeTransaction(transaction) {
     try {
-      await tracer.withNestedSpan(
-        `transaction.execute`,
-        {
-          "transaction.id": transaction.id,
-          "transaction.mutationFnName": transaction.mutationFnName,
-          "transaction.retryCount": transaction.retryCount,
-          "transaction.keyCount": transaction.keys.length
-        },
-        async (span) => {
-          const terminalError = transaction.outboxPhase === `rejection-pending` ? this.getTerminalError(transaction) : void 0;
-          this.scheduler.markStarted(transaction);
-          if (transaction.retryCount > 0) {
-            span.setAttribute(`retry.attempt`, transaction.retryCount);
-          }
-          if (!transaction.outboxPhase) {
-            try {
-              await this.runMutationFn(transaction);
-            } 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;
-            }
-          }
-          const deletionPending = transaction.outboxPhase ? transaction : { ...transaction, outboxPhase: `deletion-pending` };
-          try {
-            await this.removeSettledTransaction(
-              deletionPending,
-              !transaction.outboxPhase
-            );
-          } catch (error) {
-            const storageError = error;
-            span.recordException(storageError);
-            span.setAttribute(`result`, `outbox_failure`);
-            this.offlineExecutor.rejectTransaction(
-              transaction.id,
-              terminalError ?? storageError
-            );
-            throw storageError;
-          }
-          if (terminalError) {
-            span.setAttribute(`result`, `permanent_failure`);
-            this.offlineExecutor.rejectTransaction(
-              transaction.id,
-              terminalError
-            );
-          } else {
-            span.setAttribute(`result`, `success`);
-            this.offlineExecutor.resolveTransaction(transaction.id, void 0);
-          }
+      const terminalError = transaction.outboxPhase === `rejection-pending` ? this.getTerminalError(transaction) : void 0;
+      this.scheduler.markStarted(transaction);
+      if (!transaction.outboxPhase) {
+        try {
+          await this.runMutationFn(transaction);
+        } catch (error) {
+          const err = toError(error);
+          await this.handleError(transaction, err);
+          err[HANDLED_EXECUTION_ERROR] = true;
+          throw err;
         }
-      );
+      }
+      const deletionPending = transaction.outboxPhase ? transaction : { ...transaction, outboxPhase: `deletion-pending` };
+      try {
+        await this.removeSettledTransaction(
+          deletionPending,
+          !transaction.outboxPhase
+        );
+      } catch (error) {
+        const storageError = error;
+        this.offlineExecutor.rejectTransaction(
+          transaction.id,
+          terminalError ?? storageError
+        );
+        throw storageError;
+      }
+      if (terminalError) {
+        this.offlineExecutor.rejectTransaction(transaction.id, terminalError);
+      } else {
+        this.offlineExecutor.resolveTransaction(transaction.id, void 0);
+      }
     } catch (error) {
-      if (error instanceof Error && error[HANDLED_EXECUTION_ERROR] === true) {
+      if (error !== null && typeof error === `object` && error[HANDLED_EXECUTION_ERROR] === true) {
         return;
       }
       throw error;
@@ -135,74 +115,87 @@ class TransactionExecutor {
     });
   }
   async handleError(transaction, error) {
-    return tracer.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) {
-          const rejectionPending = {
-            ...transaction,
-            outboxPhase: `rejection-pending`,
-            lastError: {
-              name: error.name,
-              message: error.message,
-              stack: error.stack
-            }
-          };
-          console.warn(
-            `Transaction ${transaction.id} failed permanently:`,
-            error
+    let shouldRetry;
+    let hookFailure;
+    if (error instanceof types.NonRetriableError) {
+      shouldRetry = false;
+    } else {
+      let decision;
+      try {
+        decision = this.config.shouldRetry?.(error, transaction.retryCount);
+        if (decision !== void 0 && typeof decision !== `boolean`) {
+          void Promise.resolve(decision).catch(() => {
+          });
+          throw new TypeError(
+            `OfflineConfig.shouldRetry must return true, false, or undefined`
           );
-          try {
-            await this.removeSettledTransaction(rejectionPending, true);
-          } catch (storageError) {
-            span.recordException(storageError);
-            span.setAttribute(`result`, `outbox_failure`);
-            this.offlineExecutor.rejectTransaction(transaction.id, error);
-            throw storageError;
-          }
-          span.setAttribute(`result`, `permanent_failure`);
-          this.offlineExecutor.rejectTransaction(transaction.id, error);
-          return;
         }
-        const delay = Math.max(
-          0,
-          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.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;
-        } finally {
-          this.scheduler.markFailed(transaction);
+      } catch (hookError) {
+        hookFailure = toError(hookError);
+      }
+      if (hookFailure) {
+        shouldRetry = false;
+      } else {
+        shouldRetry = decision ?? this.retryPolicy.shouldRetry(error, transaction.retryCount);
+      }
+    }
+    if (!shouldRetry) {
+      const terminalError = hookFailure ?? error;
+      const rejectionPending = {
+        ...transaction,
+        outboxPhase: `rejection-pending`,
+        lastError: {
+          name: terminalError.name,
+          message: terminalError.message,
+          stack: terminalError.stack
         }
+      };
+      if (hookFailure) {
+        console.warn(
+          `Retry decision failed for transaction ${transaction.id}:`,
+          hookFailure,
+          `Named mutation function error:`,
+          error
+        );
+      } else {
+        console.warn(`Transaction ${transaction.id} failed permanently:`, error);
       }
+      try {
+        await this.removeSettledTransaction(rejectionPending, true);
+      } catch (storageError) {
+        this.offlineExecutor.rejectTransaction(transaction.id, terminalError);
+        throw storageError;
+      }
+      this.offlineExecutor.rejectTransaction(transaction.id, terminalError);
+      return;
+    }
+    const delay = Math.max(
+      0,
+      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
+      }
+    };
+    this.scheduler.updateTransaction(updatedTransaction);
+    try {
+      await this.outbox.update(transaction.id, updatedTransaction);
+    } catch (persistError) {
+      if (persistError instanceof OutboxManager.OutboxTransactionNotFoundError) {
+        this.scheduler.markCompleted(transaction);
+        this.offlineExecutor.rejectTransaction(transaction.id, error);
+        return;
+      }
+      throw persistError;
+    } finally {
+      this.scheduler.markFailed(transaction);
+    }
   }
   async removeSettledTransaction(transaction, persistMarker) {
     try {
@@ -216,7 +209,7 @@ class TransactionExecutor {
       await this.outbox.remove(transaction.id);
       this.scheduler.markCompleted(transaction);
     } catch (error) {
-      const storageError = error instanceof Error ? error : new Error(String(error));
+      const storageError = toError(error);
       this.fatalError = storageError;
       this.scheduler.markFailed(transaction);
       this.clearRetryTimer();
@@ -299,30 +292,22 @@ class TransactionExecutor {
           mutationFn: async () => {
           }
         });
-        restorationTx.isPersisted.promise.catch(() => {
-        });
         restorationTx.applyMutations(offlineTx.mutations);
-        const touchedCollections = /* @__PURE__ */ new Set();
-        for (const mutation of offlineTx.mutations) {
-          if (!mutation.collection) {
-            continue;
-          }
-          const collectionId = mutation.collection.id;
-          if (touchedCollections.has(collectionId)) {
-            continue;
+        try {
+          for (const mutation of offlineTx.mutations) {
+            if (mutation.collection._state.trackTransaction(restorationTx))
+              mutation.collection._state.recomputeOptimisticState(true);
           }
-          touchedCollections.add(collectionId);
-          mutation.collection._state.transactions.set(
-            restorationTx.id,
-            restorationTx
-          );
-          mutation.collection._state.recomputeOptimisticState(true);
+        } catch (error) {
+          restorationTx.rollback({ isSecondaryRollback: true });
+          throw error;
         }
         this.offlineExecutor.registerRestorationTransaction(
           offlineTx.id,
           restorationTx
         );
       } catch (error) {
+        if (error instanceof db.DuplicateTransactionIdError) continue;
         console.warn(
           `Failed to restore optimistic state for transaction ${offlineTx.id}:`,
           error