@matter/general 0.13.1-alpha.0-20250520-d699cd56d → 0.14.0-alpha.0-20250524-51a7e1721

package/dist/esm/transaction/Transaction.d.ts

@@ -134,7 +134,9 @@ type ResourceSetType = ResourceSet;
 type ParticipantType = Participant;
 export declare const Transaction: {
     /**
-     * Perform a transactional operation.  This is the only way to obtain a read/write transaction.
+     * Perform a transactional operation.
+     *
+     * This creates a read/write transaction scoped to the life of an optionally async function call.
      *
      * The transaction will commit automatically if it is exclusive (write mode) after the actor returns.
      *
@@ -142,18 +144,25 @@ export declare const Transaction: {
      * destroyed.
      */
     act<T>(via: string, actor: (transaction: Transaction) => MaybePromise<T>): MaybePromise<T>;
+    /**
+     * Create a transaction.
+     *
+     * Transactions must be closed using {@link Finalization#resolve} or {@link Finalization#reject}.
+     *
+     * When closed the transaction commits automatically if exclusive.
+     */
+    open(via: string): Transaction & Transaction.Finalization;
     ReadOnly: {
-        "__#15458@#participants": Set<Participant>;
-        "__#15458@#roles": Map<{}, Participant>;
-        "__#15458@#resources": Set<Resource>;
-        "__#15458@#status": Status;
-        "__#15458@#waitingOn"?: Iterable<Transaction>;
-        "__#15458@#via": string;
-        "__#15458@#shared"?: import("../index.js").Observable<[]>;
-        "__#15458@#closed"?: import("../index.js").Observable<[]>;
-        "__#15458@#isAsync": boolean;
-        "__#15458@#reportingLocks": boolean;
-        close(): void;
+        "__#15463@#participants": Set<Participant>;
+        "__#15463@#roles": Map<{}, Participant>;
+        "__#15463@#resources": Set<Resource>;
+        "__#15463@#status": Status;
+        "__#15463@#waitingOn"?: Iterable<Transaction>;
+        "__#15463@#via": string;
+        "__#15463@#shared"?: import("../index.js").Observable<[]>;
+        "__#15463@#closed"?: import("../index.js").Observable<[]>;
+        "__#15463@#isAsync": boolean;
+        "__#15463@#reportingLocks": boolean;
         readonly via: string;
         readonly status: Status;
         readonly participants: Set<Participant>;
@@ -169,20 +178,25 @@ export declare const Transaction: {
         beginSync(): void;
         addParticipants(...participants: Participant[]): void;
         getParticipant(role: {}): Participant | undefined;
-        commit(): MaybePromise;
+        commit(): MaybePromise<void>;
+        resolve<T>(result: T): MaybePromise<Awaited<T>>;
         rollback(): Promise<void> | undefined;
+        reject(cause: unknown): MaybePromise<never>;
+        "__#15463@#executeCommitCycle"(count: number): MaybePromise<void>;
         waitFor(others: Set<Transaction>): Promise<void>;
         toString(): string;
         treatAsSlow(): void;
-        "__#15458@#finalize"(status: Status, why: string, finalizer: () => MaybePromise): Promise<void> | undefined;
-        "__#15458@#executePreCommit"(): MaybePromise<void>;
-        "__#15458@#executeCommit"(): MaybePromise;
-        "__#15458@#executeCommit1"(): MaybePromise;
-        "__#15458@#executeCommit2"(): Promise<void> | undefined;
-        "__#15458@#executePostCommit"(participants: Participant[]): MaybePromise;
-        "__#15458@#executeRollback"(): Promise<void> | undefined;
-        "__#15458@#locksChanged"(resources: Set<Resource>, how?: string): void;
-        "__#15458@#assertAvailable"(): void;
+        "__#15463@#finalize"(status: Status, why: string, finalizer: () => MaybePromise): Promise<void> | undefined;
+        "__#15463@#reset"(why: string): void;
+        "__#15463@#createPreCommitExecutor"(): () => MaybePromise<void>;
+        "__#15463@#executeCommit"(): MaybePromise;
+        "__#15463@#executeCommit1"(): MaybePromise;
+        "__#15463@#executeCommit2"(): Promise<void> | undefined;
+        "__#15463@#createPostCommitExecutor"(participants: Participant[]): () => MaybePromise;
+        "__#15463@#executeRollback"(): Promise<void> | undefined;
+        "__#15463@#locksChanged"(resources: Set<Resource>, how?: string): void;
+        "__#15463@#assertAvailable"(): void;
+        [Symbol.dispose](): void;
     };
     Status: typeof Status;
     Resource: typeof Resource;
@@ -193,6 +207,19 @@ export declare namespace Transaction {
     type Resource = ResourceType;
     type ResourceSet = ResourceSetType;
     type Participant = ParticipantType;
+    interface Disposable extends Transaction, AsyncDisposable {
+        close(): MaybePromise<void>;
+    }
+    interface Finalization {
+        /**
+         * Finish the transaction.  If {@link result} is a promise this may result on commit or rollback.
+         */
+        resolve<T>(result: T): MaybePromise<Awaited<T>>;
+        /**
+         * Roll back, close the transaction and throw an error.
+         */
+        reject(cause: unknown): MaybePromise<never>;
+    }
 }
 export {};
 //# sourceMappingURL=Transaction.d.ts.map

package/dist/esm/transaction/Transaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Transaction.d.ts","sourceRoot":"","sources":["../../../src/transaction/Transaction.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAGrC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,WAAW;IACxB;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC;IAExC;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC;IAElC;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,SAAS,CAAC;IAEtD;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAElD;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IAEjC;;;;;OAKG;IACH,YAAY,CAAC,GAAG,SAAS,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtD;;;;;OAKG;IACH,gBAAgB,CAAC,GAAG,SAAS,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;IAEjD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;;;;OAKG;IACH,SAAS,IAAI,IAAI,CAAC;IAElB;;OAEG;IACH,eAAe,CAAC,GAAG,YAAY,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC;IAEtD;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,EAAE,GAAG,WAAW,GAAG,SAAS,CAAC;IAElD;;;;;;;OAOG;IACH,MAAM,IAAI,YAAY,CAAC;IAEvB;;;;;;;OAOG;IACH,QAAQ,IAAI,YAAY,CAAC;IAEzB;;;;OAIG;IACH,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD;AAED,KAAK,UAAU,GAAG,MAAM,CAAC;AACzB,KAAK,YAAY,GAAG,QAAQ,CAAC;AAC7B,KAAK,eAAe,GAAG,WAAW,CAAC;AACnC,KAAK,eAAe,GAAG,WAAW,CAAC;AAEnC,eAAO,MAAM,WAAW;IACpB;;;;;;;OAOG;QACC,CAAC,OAAO,MAAM,SAAS,CAAC,WAAW,EAAE,WAAW,KAAK,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAY7F,CAAC;AAKF,yBAAiB,WAAW,CAAC;IACzB,KAAY,MAAM,GAAG,UAAU,CAAC;IAEhC,KAAY,QAAQ,GAAG,YAAY,CAAC;IAEpC,KAAY,WAAW,GAAG,eAAe,CAAC;IAE1C,KAAY,WAAW,GAAG,eAAe,CAAC;CAC7C"}
+{"version":3,"file":"Transaction.d.ts","sourceRoot":"","sources":["../../../src/transaction/Transaction.ts"],"names":[],"mappings":"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"}

package/dist/esm/transaction/Transaction.js

@@ -5,10 +5,12 @@
  */
 import { Resource } from "./Resource.js";
 import { Status } from "./Status.js";
-import { ReadOnlyTransaction, act } from "./Tx.js";
+import { ReadOnlyTransaction, open } from "./Tx.js";
 const Transaction = {
   /**
-   * Perform a transactional operation.  This is the only way to obtain a read/write transaction.
+   * Perform a transactional operation.
+   *
+   * This creates a read/write transaction scoped to the life of an optionally async function call.
    *
    * The transaction will commit automatically if it is exclusive (write mode) after the actor returns.
    *
@@ -16,14 +18,31 @@ const Transaction = {
    * destroyed.
    */
   act(via, actor) {
-    return act(via, actor);
+    const tx = open(via);
+    let result;
+    try {
+      result = actor(tx);
+    } catch (e) {
+      return tx.reject(e);
+    }
+    return tx.resolve(result);
+  },
+  /**
+   * Create a transaction.
+   *
+   * Transactions must be closed using {@link Finalization#resolve} or {@link Finalization#reject}.
+   *
+   * When closed the transaction commits automatically if exclusive.
+   */
+  open(via) {
+    return open(via);
   },
   ReadOnly: ReadOnlyTransaction,
   Status,
   Resource,
   [Symbol.toStringTag]: "Transaction"
 };
-Transaction.act = act;
+Transaction.open = open;
 export {
   Transaction
 };

package/dist/esm/transaction/Transaction.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/transaction/Transaction.ts"],
-  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,SAAS,gBAAgB;AAEzB,SAAS,cAAc;AACvB,SAAS,qBAAqB,WAAW;AA+IlC,MAAM,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASvB,IAAO,KAAa,OAAuE;AAEvF,WAAO,IAAI,KAAK,KAAK;AAAA,EACzB;AAAA,EAEA,UAAU;AAAA,EAEV;AAAA,EAEA;AAAA,EAEA,CAAC,OAAO,WAAW,GAAG;AAC1B;AAGA,YAAY,MAAM;",
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,SAAS,gBAAgB;AAEzB,SAAS,cAAc;AACvB,SAAS,qBAAqB,YAAY;AA+InC,MAAM,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWvB,IAAO,KAAa,OAAuE;AACvF,UAAM,KAAK,KAAK,GAAG;AAEnB,QAAI;AACJ,QAAI;AACA,eAAS,MAAM,EAAE;AAAA,IACrB,SAAS,GAAG;AACR,aAAO,GAAG,OAAO,CAAC;AAAA,IACtB;AAEA,WAAO,GAAG,QAAQ,MAAM;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,KAAK,KAAa;AAEd,WAAO,KAAK,GAAG;AAAA,EACnB;AAAA,EAEA,UAAU;AAAA,EAEV;AAAA,EAEA;AAAA,EAEA,CAAC,OAAO,WAAW,GAAG;AAC1B;AAGA,YAAY,OAAO;",
   "names": []
 }

package/dist/esm/transaction/Tx.d.ts

@@ -11,20 +11,23 @@ import type { Transaction } from "./Transaction.js";
 /**
  * This is the only public interface to this file.
  */
-export declare function act<T>(via: string, actor: (transaction: Transaction) => T): T;
+export declare function open(via: string): Transaction & Transaction.Finalization;
 /**
  * The concrete implementation of the Transaction interface.
  */
-declare class Tx implements Transaction {
+declare class Tx implements Transaction, Transaction.Finalization {
     #private;
     constructor(via: string, readonly?: boolean);
-    close(): void;
+    [Symbol.dispose](): void;
     get via(): string;
     get status(): Status;
     get participants(): Set<Participant>;
     get resources(): Set<Resource>;
     get waitingOn(): Iterable<Transaction> | undefined;
     get isAsync(): boolean;
+    /**
+     * We set this during async processing.  This enables the lock reporting when too much time ellapses.
+     */
     set isAsync(isAsync: true);
     onShared(listener: () => void, once?: boolean): void;
     onClose(listener: () => void): void;
@@ -34,8 +37,10 @@ declare class Tx implements Transaction {
     beginSync(): void;
     addParticipants(...participants: Participant[]): void;
     getParticipant(role: {}): Participant | undefined;
-    commit(): MaybePromise;
+    commit(): MaybePromise<void>;
+    resolve<T>(result: T): MaybePromise<Awaited<T>>;
     rollback(): Promise<void> | undefined;
+    reject(cause: unknown): MaybePromise<never>;
     waitFor(others: Set<Transaction>): Promise<void>;
     toString(): string;
     treatAsSlow(): void;

package/dist/esm/transaction/Tx.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Tx.d.ts","sourceRoot":"","sources":["../../../src/transaction/Tx.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAUpD;;GAEG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,CAAC,GAAG,CAAC,CA8F7E;AAED;;GAEG;AACH,cAAM,EAAG,YAAW,WAAW;;gBAYf,GAAG,EAAE,MAAM,EAAE,QAAQ,UAAQ;IASzC,KAAK;IASL,IAAI,GAAG,WAEN;IAED,IAAI,MAAM,WAET;IAED,IAAI,YAAY,qBAEf;IAED,IAAI,SAAS,kBAEZ;IAED,IAAI,SAAS,sCAEZ;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,IAAI,OAAO,CAAC,OAAO,EAAE,IAAI,EAOxB;IAED,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,IAAI,CAAC,EAAE,OAAO;IAW7C,OAAO,CAAC,QAAQ,EAAE,MAAM,IAAI;IAatB,YAAY,CAAC,GAAG,SAAS,EAAE,QAAQ,EAAE;IAY3C,gBAAgB,CAAC,GAAG,SAAS,EAAE,QAAQ,EAAE;IAgBnC,KAAK;IAsBX,SAAS;IAqBT,eAAe,CAAC,GAAG,YAAY,EAAE,WAAW,EAAE;IAyB9C,cAAc,CAAC,IAAI,EAAE,EAAE;IAMvB,MAAM;IAyBN,QAAQ;IAMR,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,WAAW,CAAC;IA6BhC,QAAQ;IAIR,WAAW;CAuWd;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,IAA2B,CAAC"}
+{"version":3,"file":"Tx.d.ts","sourceRoot":"","sources":["../../../src/transaction/Tx.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAUpD;;GAEG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAAC,YAAY,CAExE;AAED;;GAEG;AACH,cAAM,EAAG,YAAW,WAAW,EAAE,WAAW,CAAC,YAAY;;gBAYzC,GAAG,EAAE,MAAM,EAAE,QAAQ,UAAQ;IASzC,CAAC,MAAM,CAAC,OAAO,CAAC;IAMhB,IAAI,GAAG,WAEN;IAED,IAAI,MAAM,WAET;IAED,IAAI,YAAY,qBAEf;IAED,IAAI,SAAS,kBAEZ;IAED,IAAI,SAAS,sCAEZ;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;OAEG;IACH,IAAI,OAAO,CAAC,OAAO,EAAE,IAAI,EAOxB;IAED,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,IAAI,CAAC,EAAE,OAAO;IAW7C,OAAO,CAAC,QAAQ,EAAE,MAAM,IAAI;IAatB,YAAY,CAAC,GAAG,SAAS,EAAE,QAAQ,EAAE;IAY3C,gBAAgB,CAAC,GAAG,SAAS,EAAE,QAAQ,EAAE;IAgBnC,KAAK;IAsBX,SAAS;IAqBT,eAAe,CAAC,GAAG,YAAY,EAAE,WAAW,EAAE;IAyB9C,cAAc,CAAC,IAAI,EAAE,EAAE;IAMvB,MAAM;IAeN,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAiC/C,QAAQ;IAMR,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,CAAC,KAAK,CAAC;IAyE3C,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,WAAW,CAAC;IA6BhC,QAAQ;IAIR,WAAW;CAuYd;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,IAA2B,CAAC"}

package/dist/esm/transaction/Tx.js

@@ -7,6 +7,7 @@ import { Diagnostic } from "#log/Diagnostic.js";
 import { Logger } from "#log/Logger.js";
 import { ImplementationError, ReadOnlyError } from "#MatterError.js";
 import { Time } from "#time/Time.js";
+import { asError } from "#util/Error.js";
 import { Observable } from "#util/Observable.js";
 import { MaybePromise } from "#util/Promises.js";
 import { describeList } from "#util/String.js";
@@ -16,74 +17,8 @@ import { Status } from "./Status.js";
 const logger = Logger.get("Transaction");
 const MAX_PRECOMMIT_CYCLES = 5;
 const MAX_CHAINED_COMMITS = 5;
-function act(via, actor) {
-  const tx = new Tx(via);
-  let commits = 0;
-  function commitTransaction(finalResult) {
-    commits++;
-    if (commits > MAX_CHAINED_COMMITS) {
-      throw new TransactionFlowError(
-        `Transaction commits have cascaded ${MAX_CHAINED_COMMITS} times which likely indicates an infinite loop`
-      );
-    }
-    const result = tx.commit();
-    if (MaybePromise.is(result)) {
-      return result.then(() => {
-        if (tx.status === Status.Exclusive) {
-          return commitTransaction(finalResult);
-        }
-        return finalResult;
-      });
-    } else if (tx.status === Status.Exclusive) {
-      return commitTransaction(finalResult);
-    }
-    return finalResult;
-  }
-  const handleTransactionError = (error) => {
-    if (commits) {
-      throw error;
-    }
-    logger.error("Rolling back", tx.via, "due to error:", Diagnostic.weak(error?.message || `${error}`));
-    try {
-      const result = tx.rollback();
-      if (MaybePromise.is(result)) {
-        return Promise.resolve(result).catch((error2) => {
-          if (error2 !== error) {
-            logger.error("Secondary error in", tx.via, "rollback:", error2);
-          }
-          throw error;
-        });
-      }
-    } catch (error2) {
-      if (error2 !== error) {
-        logger.error("Secondary error in", tx.via, "rollback:", error2);
-      }
-    }
-    throw error;
-  };
-  const closeTransaction = tx.close.bind(tx);
-  let isAsync = false;
-  try {
-    const actorResult = actor(tx);
-    if (MaybePromise.is(actorResult)) {
-      isAsync = tx.isAsync = true;
-      return Promise.resolve(actorResult).then(commitTransaction, handleTransactionError).finally(closeTransaction);
-    }
-    const commitResult = commitTransaction(actorResult);
-    if (MaybePromise.is(commitResult)) {
-      isAsync = true;
-      return Promise.resolve(commitResult).catch(handleTransactionError).finally(closeTransaction);
-    }
-    return commitResult;
-  } catch (e) {
-    const result = handleTransactionError(e);
-    isAsync = true;
-    return Promise.resolve(result).finally(closeTransaction);
-  } finally {
-    if (!isAsync) {
-      tx.close();
-    }
-  }
+function open(via) {
+  return new Tx(via);
 }
 class Tx {
   #participants = /* @__PURE__ */ new Set();
@@ -104,12 +39,9 @@ class Tx {
       this.#status = Status.Shared;
     }
   }
-  close() {
-    Monitor.delete(this);
+  [Symbol.dispose]() {
+    this.#reset("dropped");
     this.#status = Status.Destroyed;
-    this.#resources.clear();
-    this.#roles.clear();
-    this.#participants.clear();
     this.#closed?.emit();
   }
   get via() {
@@ -130,6 +62,9 @@ class Tx {
   get isAsync() {
     return this.#isAsync;
   }
+  /**
+   * We set this during async processing.  This enables the lock reporting when too much time ellapses.
+   */
   set isAsync(isAsync) {
     if (!this.#isAsync) {
       this.#locksChanged(this.#resources);
@@ -239,28 +174,97 @@ class Tx {
     return this.#roles.get(role);
   }
   commit() {
-    this.#assertAvailable();
-    if (this.#status === Status.Shared) {
+    if (this.status === Status.Shared) {
       return this.rollback();
     }
-    const performCommit = () => {
-      const participants = [...this.#participants];
-      const result2 = this.#finalize(Status.CommittingPhaseOne, "committed", this.#executeCommit.bind(this));
-      if (MaybePromise.is(result2)) {
-        return result2.then(() => this.#executePostCommit(participants));
-      }
-      return this.#executePostCommit(participants);
-    };
-    const result = this.#executePreCommit();
+    this.#assertAvailable();
+    const result = this.#executeCommitCycle(0);
+    if (result) {
+      this.isAsync = true;
+    }
+    return result;
+  }
+  resolve(result) {
     if (MaybePromise.is(result)) {
-      return result.then(performCommit);
+      this.isAsync = true;
+      return result.then(this.resolve.bind(this), this.reject.bind(this));
+    }
+    let promise;
+    try {
+      promise = this.commit();
+    } catch (e) {
+      return this.reject(e);
     }
-    return performCommit();
+    if (MaybePromise.is(promise)) {
+      this.isAsync = true;
+      return Promise.resolve(promise).then(() => {
+        this[Symbol.dispose]();
+        return result;
+      }, this.reject.bind(this)).finally(this[Symbol.dispose].bind(this));
+    }
+    this[Symbol.dispose]();
+    return result;
   }
   rollback() {
     this.#assertAvailable();
     return this.#finalize(Status.RollingBack, "rolled back", () => this.#executeRollback());
   }
+  reject(cause) {
+    if (this.#status === Status.Shared) {
+      this.#reset("released");
+      throw cause;
+    }
+    logger.error("Rolling back", this.via, "due to error:", Diagnostic.weak(asError(cause).message));
+    try {
+      const result = this.rollback();
+      if (MaybePromise.is(result)) {
+        return Promise.resolve(result).catch((cause2) => {
+          if (cause2 === cause) {
+            return;
+          }
+          logger.error("Secondary error in", this.via, "rollback:", cause2);
+        }).finally(() => {
+          this[Symbol.dispose]();
+          throw cause;
+        });
+      }
+    } catch (cause2) {
+      if (cause2 !== cause) {
+        logger.error("Secondary error in", this.via, "rollback:", cause2);
+      }
+    }
+    this[Symbol.dispose]();
+    throw cause;
+  }
+  /**
+   * Execute commit logic for a single commit cycle.
+   *
+   * A "cycle" performs all commit logic and normally brings us back to shared state.  But we allow post-commit
+   * handlers to re-enter exclusive state.  If that happens, we trigger another commit cycle.
+   */
+  #executeCommitCycle(count) {
+    count++;
+    if (count > MAX_CHAINED_COMMITS) {
+      throw new TransactionFlowError(
+        `Transaction commits have cascaded ${count} times which likely indicates an infinite loop`
+      );
+    }
+    let result = this.#createPreCommitExecutor()();
+    if (MaybePromise.is(result)) {
+      result = result.then(this.#executeCommit.bind(this));
+    } else {
+      result = this.#executeCommit();
+    }
+    if (MaybePromise.is(result)) {
+      return result.then(() => {
+        if (this.#status === Status.Exclusive) {
+          return this.#executeCommitCycle(count);
+        }
+      });
+    } else if (this.#status === Status.Exclusive) {
+      return this.#executeCommitCycle(count);
+    }
+  }
   waitFor(others) {
     this.#assertAvailable();
     if (this.waitingOn) {
@@ -306,34 +310,39 @@ class Tx {
         `Illegal attempt to enter status ${status} when transaction is ${this.#status}`
       );
     }
-    const cleanup = () => {
-      const set = new ResourceSet(this, this.#resources);
-      const unlocked = set.releaseLocks();
-      this.#locksChanged(unlocked, `${why} and unlocked`);
-      Monitor.delete(this);
-      this.#reportingLocks = false;
-      this.#participants.clear();
-      this.#status = Status.Shared;
-      this.#shared?.emit();
-    };
     let isAsync = false;
     try {
       this.#status = status;
       const result = finalizer();
       if (MaybePromise.is(result)) {
         isAsync = true;
-        return Promise.resolve(result).finally(cleanup);
+        return Promise.resolve(result).finally(() => this.#reset(why));
       }
     } finally {
       if (!isAsync) {
-        cleanup();
+        this.#reset(why);
       }
     }
   }
+  /**
+   * Reset state to shared with no resources or participants.
+   */
+  #reset(why) {
+    const set = new ResourceSet(this, this.#resources);
+    const unlocked = set.releaseLocks();
+    this.#locksChanged(unlocked, `${why} and unlocked`);
+    this.#resources.clear();
+    Monitor.delete(this);
+    this.#reportingLocks = false;
+    this.#participants.clear();
+    this.#roles.clear();
+    this.#status = Status.Shared;
+    this.#shared?.emit();
+  }
   /**
    * Iteratively execute pre-commit until all participants "settle" and report no possible mutation.
    */
-  #executePreCommit() {
+  #createPreCommitExecutor() {
     let mayHaveMutated = false;
     let abortedDueToError = false;
     let iterator = this.participants[Symbol.iterator]();
@@ -365,7 +374,7 @@ class Tx {
       mayHaveMutated = false;
       iterator = this.participants[Symbol.iterator]();
     };
-    const nextPreCommit = (previousResult) => {
+    const executePreCommit = (previousResult) => {
       if (abortedDueToError) {
         return;
       }
@@ -392,7 +401,7 @@ class Tx {
         try {
           const result = participant.preCommit?.();
           if (MaybePromise.is(result)) {
-            return Promise.resolve(result).catch(handleError).then(nextPreCommit);
+            return Promise.resolve(result).catch(handleError).then(executePreCommit);
           }
           if (result) {
             mayHaveMutated = true;
@@ -402,17 +411,26 @@ class Tx {
         }
       }
     };
-    return nextPreCommit();
+    return executePreCommit;
   }
   /**
-   * Commit logic passed to #finalize.
+   * Handle actual commit and post-commit.
    */
   #executeCommit() {
-    const result = this.#executeCommit1();
+    const participants = [...this.#participants];
+    const executeCommit = () => {
+      const result2 = this.#executeCommit1();
+      if (MaybePromise.is(result2)) {
+        return Promise.resolve(result2).then(this.#executeCommit2.bind(this));
+      }
+      return this.#executeCommit2();
+    };
+    const result = this.#finalize(Status.CommittingPhaseOne, "committed", executeCommit);
+    const executePostCommit = this.#createPostCommitExecutor(participants);
     if (MaybePromise.is(result)) {
-      return Promise.resolve(result).then(this.#executeCommit2.bind(this));
+      return result.then(executePostCommit);
     }
-    return this.#executeCommit2();
+    return executePostCommit();
   }
   #executeCommit1() {
     let needRollback = false;
@@ -482,23 +500,35 @@ class Tx {
       throwIfErrored(errored, "in commit phase 2");
     }
   }
-  #executePostCommit(participants) {
-    const participantIterator = participants[Symbol.iterator]();
-    const postCommitNextParticipant = () => {
-      const next = participantIterator.next();
-      if (next.done) {
-        return;
-      }
-      const participant = next.value;
-      return MaybePromise.then(
-        () => participant.postCommit?.(),
-        () => postCommitNextParticipant(),
-        (error) => {
-          logger.error(`Error post-commit of ${participant}:`, error);
+  /**
+   * Execute post-commit phase.
+   *
+   * We notify each participant sequentially.  If a participant throws, we log the error and move on to the next
+   * participant.
+   */
+  #createPostCommitExecutor(participants) {
+    let i = 0;
+    const executePostCommit = () => {
+      for (; i < participants.length; i++) {
+        let reportParticipantError2 = function(e) {
+          logger.error(`Error post-commit of ${participant}:`, e);
+        };
+        var reportParticipantError = reportParticipantError2;
+        const participant = participants[i];
+        try {
+          const promise = participant.postCommit?.();
+          if (MaybePromise.is(promise)) {
+            return Promise.resolve(promise).then(executePostCommit, (e) => {
+              reportParticipantError2(e);
+              executePostCommit();
+            });
+          }
+        } catch (e) {
+          reportParticipantError2(e);
         }
-      );
+      }
     };
-    return postCommitNextParticipant();
+    return executePostCommit;
   }
   /**
    * Rollback logic passed to #finish.
@@ -622,6 +652,6 @@ const Monitor = /* @__PURE__ */ function() {
 }();
 export {
   ReadOnlyTransaction,
-  act
+  open
 };
 //# sourceMappingURL=Tx.js.map