@matter/general 0.13.1-alpha.0-20250520-d699cd56d → 0.14.0-alpha.0-20250521-979eda05d

package/dist/cjs/polyfills/index.d.ts

@@ -4,4 +4,5 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import "./disposable.js";
+import "./suppressed-error.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/polyfills/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/polyfills/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/polyfills/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,iBAAiB,CAAC;AACzB,OAAO,uBAAuB,CAAC"}

package/dist/cjs/polyfills/index.js

@@ -1,5 +1,6 @@
 "use strict";
 var import_disposable = require("./disposable.js");
+var import_suppressed_error = require("./suppressed-error.js");
 /**
  * @license
  * Copyright 2022-2025 Matter.js Authors

package/dist/cjs/polyfills/index.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/polyfills/index.ts"],
-  "mappings": ";AAMA,wBAAO;AANP;AAAA;AAAA;AAAA;AAAA;",
+  "mappings": ";AAMA,wBAAO;AACP,8BAAO;AAPP;AAAA;AAAA;AAAA;AAAA;",
   "names": []
 }

package/dist/cjs/polyfills/suppressed-error.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2022-2025 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};
+//# sourceMappingURL=suppressed-error.d.ts.map

package/dist/cjs/polyfills/suppressed-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suppressed-error.d.ts","sourceRoot":"","sources":["../../../src/polyfills/suppressed-error.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/cjs/polyfills/suppressed-error.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022-2025 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+if (globalThis.SuppressedError === void 0) {
+  class SuppressedError extends Error {
+    error;
+    suppressed;
+    constructor(error, suppressed, message) {
+      super(message);
+      this.error = error;
+      this.suppressed = suppressed;
+    }
+  }
+  const factory = (error, suppressed, message) => new SuppressedError(error, suppressed, message);
+  factory.prototype = SuppressedError.prototype;
+  globalThis.SuppressedError = factory;
+}
+//# sourceMappingURL=suppressed-error.js.map

package/dist/cjs/polyfills/suppressed-error.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/polyfills/suppressed-error.ts"],
+  "mappings": ";AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,IAAI,WAAW,oBAAoB,QAAW;AAAA,EAI1C,MAAM,wBAAwB,MAAM;AAAA,IAChC;AAAA,IACA;AAAA,IAEA,YAAY,OAAY,YAAiB,SAAkB;AACvD,YAAM,OAAO;AAEb,WAAK,QAAQ;AACb,WAAK,aAAa;AAAA,IACtB;AAAA,EACJ;AAEA,QAAM,UAAU,CAAC,OAAY,YAAiB,YAAqB,IAAI,gBAAgB,OAAO,YAAY,OAAO;AACjH,UAAQ,YAAY,gBAAgB;AAEpC,aAAW,kBAAkB;AACjC;",
+  "names": []
+}

package/dist/cjs/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,6 +144,14 @@ 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>;
@@ -153,7 +163,6 @@ export declare const Transaction: {
         "__#15458@#closed"?: import("../index.js").Observable<[]>;
         "__#15458@#isAsync": boolean;
         "__#15458@#reportingLocks": boolean;
-        close(): void;
         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>;
+        "__#15458@#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@#reset"(why: string): void;
+        "__#15458@#createPreCommitExecutor"(): () => MaybePromise<void>;
         "__#15458@#executeCommit"(): MaybePromise;
         "__#15458@#executeCommit1"(): MaybePromise;
         "__#15458@#executeCommit2"(): Promise<void> | undefined;
-        "__#15458@#executePostCommit"(participants: Participant[]): MaybePromise;
+        "__#15458@#createPostCommitExecutor"(participants: Participant[]): () => MaybePromise;
         "__#15458@#executeRollback"(): Promise<void> | undefined;
         "__#15458@#locksChanged"(resources: Set<Resource>, how?: string): void;
         "__#15458@#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/cjs/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":"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;;;;;;;;;OASG;QACC,CAAC,OAAO,MAAM,SAAS,CAAC,WAAW,EAAE,WAAW,KAAK,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;IAa1F;;;;;;OAMG;cACO,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYnB,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;IAE1C,UAAiB,UAAW,SAAQ,WAAW,EAAE,eAAe;QAC5D,KAAK,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;KAC/B;IAED,UAAiB,YAAY;QACzB;;WAEG;QACH,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;QAEhD;;WAEG;QACH,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;KAC/C;CACJ"}

package/dist/cjs/transaction/Transaction.js

@@ -31,7 +31,9 @@ var import_Tx = require("./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.
    *
@@ -39,12 +41,29 @@ const Transaction = {
    * destroyed.
    */
   act(via, actor) {
-    return (0, import_Tx.act)(via, actor);
+    const tx = (0, import_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 (0, import_Tx.open)(via);
   },
   ReadOnly: import_Tx.ReadOnlyTransaction,
   Status: import_Status.Status,
   Resource: import_Resource.Resource,
   [Symbol.toStringTag]: "Transaction"
 };
-Transaction.act = import_Tx.act;
+Transaction.open = import_Tx.open;
 //# sourceMappingURL=Transaction.js.map

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

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/transaction/Transaction.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,sBAAyB;AAEzB,oBAAuB;AACvB,gBAAyC;AAXzC;AAAA;AAAA;AAAA;AAAA;AA0JO,MAAM,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASvB,IAAO,KAAa,OAAuE;AAEvF,eAAO,eAAI,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,sBAAyB;AAEzB,oBAAuB;AACvB,gBAA0C;AAX1C;AAAA;AAAA;AAAA;AAAA;AA0JO,MAAM,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWvB,IAAO,KAAa,OAAuE;AACvF,UAAM,SAAK,gBAAK,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,eAAO,gBAAK,GAAG;AAAA,EACnB;AAAA,EAEA,UAAU;AAAA,EAEV;AAAA,EAEA;AAAA,EAEA,CAAC,OAAO,WAAW,GAAG;AAC1B;AAGA,YAAY,OAAO;",
   "names": []
 }

package/dist/cjs/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/cjs/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/cjs/transaction/Tx.js

@@ -19,13 +19,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var Tx_exports = {};
 __export(Tx_exports, {
   ReadOnlyTransaction: () => ReadOnlyTransaction,
-  act: () => act
+  open: () => open
 });
 module.exports = __toCommonJS(Tx_exports);
 var import_Diagnostic = require("#log/Diagnostic.js");
 var import_Logger = require("#log/Logger.js");
 var import_MatterError = require("#MatterError.js");
 var import_Time = require("#time/Time.js");
+var import_Error = require("#util/Error.js");
 var import_Observable = require("#util/Observable.js");
 var import_Promises = require("#util/Promises.js");
 var import_String = require("#util/String.js");
@@ -40,74 +41,8 @@ var import_Status = require("./Status.js");
 const logger = import_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 import_errors.TransactionFlowError(
-        `Transaction commits have cascaded ${MAX_CHAINED_COMMITS} times which likely indicates an infinite loop`
-      );
-    }
-    const result = tx.commit();
-    if (import_Promises.MaybePromise.is(result)) {
-      return result.then(() => {
-        if (tx.status === import_Status.Status.Exclusive) {
-          return commitTransaction(finalResult);
-        }
-        return finalResult;
-      });
-    } else if (tx.status === import_Status.Status.Exclusive) {
-      return commitTransaction(finalResult);
-    }
-    return finalResult;
-  }
-  const handleTransactionError = (error) => {
-    if (commits) {
-      throw error;
-    }
-    logger.error("Rolling back", tx.via, "due to error:", import_Diagnostic.Diagnostic.weak(error?.message || `${error}`));
-    try {
-      const result = tx.rollback();
-      if (import_Promises.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 (import_Promises.MaybePromise.is(actorResult)) {
-      isAsync = tx.isAsync = true;
-      return Promise.resolve(actorResult).then(commitTransaction, handleTransactionError).finally(closeTransaction);
-    }
-    const commitResult = commitTransaction(actorResult);
-    if (import_Promises.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();
@@ -128,12 +63,9 @@ class Tx {
       this.#status = import_Status.Status.Shared;
     }
   }
-  close() {
-    Monitor.delete(this);
+  [Symbol.dispose]() {
+    this.#reset("dropped");
     this.#status = import_Status.Status.Destroyed;
-    this.#resources.clear();
-    this.#roles.clear();
-    this.#participants.clear();
     this.#closed?.emit();
   }
   get via() {
@@ -154,6 +86,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);
@@ -263,28 +198,97 @@ class Tx {
     return this.#roles.get(role);
   }
   commit() {
-    this.#assertAvailable();
-    if (this.#status === import_Status.Status.Shared) {
+    if (this.status === import_Status.Status.Shared) {
       return this.rollback();
     }
-    const performCommit = () => {
-      const participants = [...this.#participants];
-      const result2 = this.#finalize(import_Status.Status.CommittingPhaseOne, "committed", this.#executeCommit.bind(this));
-      if (import_Promises.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 (import_Promises.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 (import_Promises.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(import_Status.Status.RollingBack, "rolled back", () => this.#executeRollback());
   }
+  reject(cause) {
+    if (this.#status === import_Status.Status.Shared) {
+      this.#reset("released");
+      throw cause;
+    }
+    logger.error("Rolling back", this.via, "due to error:", import_Diagnostic.Diagnostic.weak((0, import_Error.asError)(cause).message));
+    try {
+      const result = this.rollback();
+      if (import_Promises.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 import_errors.TransactionFlowError(
+        `Transaction commits have cascaded ${count} times which likely indicates an infinite loop`
+      );
+    }
+    let result = this.#createPreCommitExecutor()();
+    if (import_Promises.MaybePromise.is(result)) {
+      result = result.then(this.#executeCommit.bind(this));
+    } else {
+      result = this.#executeCommit();
+    }
+    if (import_Promises.MaybePromise.is(result)) {
+      return result.then(() => {
+        if (this.#status === import_Status.Status.Exclusive) {
+          return this.#executeCommitCycle(count);
+        }
+      });
+    } else if (this.#status === import_Status.Status.Exclusive) {
+      return this.#executeCommitCycle(count);
+    }
+  }
   waitFor(others) {
     this.#assertAvailable();
     if (this.waitingOn) {
@@ -330,34 +334,39 @@ class Tx {
         `Illegal attempt to enter status ${status} when transaction is ${this.#status}`
       );
     }
-    const cleanup = () => {
-      const set = new import_ResourceSet.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 = import_Status.Status.Shared;
-      this.#shared?.emit();
-    };
     let isAsync = false;
     try {
       this.#status = status;
       const result = finalizer();
       if (import_Promises.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 import_ResourceSet.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 = import_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]();
@@ -389,7 +398,7 @@ class Tx {
       mayHaveMutated = false;
       iterator = this.participants[Symbol.iterator]();
     };
-    const nextPreCommit = (previousResult) => {
+    const executePreCommit = (previousResult) => {
       if (abortedDueToError) {
         return;
       }
@@ -416,7 +425,7 @@ class Tx {
         try {
           const result = participant.preCommit?.();
           if (import_Promises.MaybePromise.is(result)) {
-            return Promise.resolve(result).catch(handleError).then(nextPreCommit);
+            return Promise.resolve(result).catch(handleError).then(executePreCommit);
           }
           if (result) {
             mayHaveMutated = true;
@@ -426,17 +435,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 (import_Promises.MaybePromise.is(result2)) {
+        return Promise.resolve(result2).then(this.#executeCommit2.bind(this));
+      }
+      return this.#executeCommit2();
+    };
+    const result = this.#finalize(import_Status.Status.CommittingPhaseOne, "committed", executeCommit);
+    const executePostCommit = this.#createPostCommitExecutor(participants);
     if (import_Promises.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;
@@ -506,23 +524,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 import_Promises.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 (import_Promises.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.