velocious 1.0.618 → 1.0.620

package/build/src/testing/test-transaction-session.js

@@ -0,0 +1,255 @@
+// @ts-check
+import SharedTransactionBroker from "./shared-transaction-broker.js";
+import { runWithSharedTransactionBrokerConfig, sharedTransactionBrokerContextMatches } from "./shared-transaction-proxy-driver.js";
+/** @typedef {{connection: import("../database/drivers/base.js").default, databaseIdentifier: string, release: () => Promise<void>, reuseKey: string}} Enrollment */
+/**
+ * Backend-owned, capability-scoped transaction set for long-lived test services.
+ * Join coordinates are intentionally obtainable only as a live control message.
+ */
+export default class TestTransactionSession {
+    /**
+     * Creates an unstarted transaction session.
+     * @param {import("../configuration.js").default} [configuration] - Backend configuration owning enrolled pools.
+     */
+    constructor(configuration) {
+        this.configuration = configuration;
+        /** @type {SharedTransactionBroker | undefined} */
+        this.broker = undefined;
+        /** @type {Map<string, Enrollment>} */
+        this.enrollments = new Map();
+        /** @type {Map<string, {pool: import("../database/pool/base.js").default, registration: import("../database/pool/base.js").TestSharedConnectionRegistration}>} */
+        this.sharedConnectionRegistrations = new Map();
+        /** @type {Promise<void> | undefined} */
+        this.cleanupPromise = undefined;
+        /** @type {Promise<void> | undefined} */
+        this.rollbackPromise = undefined;
+    }
+    /**
+     * Begins a test transaction session.
+     * @param {{configuration?: import("../configuration.js").default}} [args] - Backend owner.
+     * @returns {Promise<TestTransactionSession>} - Begun session.
+     */
+    static async begin({ configuration } = {}) {
+        const session = new TestTransactionSession(configuration);
+        session.broker = await SharedTransactionBroker.start({ connections: {} });
+        return session;
+    }
+    /**
+     * Joins one request/job callback from a live backend control message.
+     * @template T
+     * @param {{address: string, capability: string}} message - Ephemeral coordinates received over live IPC.
+     * @param {() => T} callback - Backend request or worker work.
+     * @returns {T} - Callback result.
+     */
+    static join(message, callback) {
+        return runWithSharedTransactionBrokerConfig({ ...message, allowDynamicIdentities: true, databaseIdentifiers: [], expected: true }, callback);
+    }
+    /**
+     * Lazily adds an exact physical connection to the common rollback set.
+     * @param {Enrollment} enrollment - Checked-out physical connection and owner release hook.
+     */
+    async enroll(enrollment) {
+        const broker = this.requiredBroker();
+        const identity = `${enrollment.databaseIdentifier}\0${enrollment.reuseKey}`;
+        const existing = this.enrollments.get(identity);
+        if (existing) {
+            if (existing.connection !== enrollment.connection)
+                await enrollment.release();
+            return;
+        }
+        try {
+            await enrollment.connection.startTransaction();
+        }
+        catch (error) {
+            /** @type {Error | undefined} */
+            let releaseFailure;
+            try {
+                await enrollment.release();
+            }
+            catch (releaseError) {
+                releaseFailure = this.normalizeError(releaseError);
+            }
+            if (releaseFailure) {
+                throw new AggregateError([this.normalizeError(error), releaseFailure], "Test transaction enrollment start and release failed", { cause: error });
+            }
+            throw error;
+        }
+        try {
+            broker.enrollConnection(enrollment);
+            this.enrollments.set(identity, enrollment);
+        }
+        catch (error) {
+            await this.rollbackAndRelease(enrollment);
+            throw error;
+        }
+    }
+    /**
+     * Lazily checks out and enrolls the physical database selected by a tenant descriptor.
+     * @param {{databaseIdentifier: string, tenant?: object}} args - Logical and tenant identity.
+     */
+    async enrollDatabase({ databaseIdentifier, tenant }) {
+        if (!this.configuration)
+            throw new Error("Test transaction session requires a configuration to enroll a database");
+        const pool = this.configuration.getDatabasePool(databaseIdentifier);
+        const databaseConfiguration = this.configuration.resolveDatabaseConfiguration(databaseIdentifier, tenant);
+        const reuseKey = pool.getConfigurationReuseKey(databaseConfiguration);
+        const identity = `${databaseIdentifier}\0${reuseKey}`;
+        if (this.enrollments.has(identity))
+            return;
+        const connection = await this.configuration.runWithTenant(tenant, async () => {
+            return await pool.checkout({ name: "Test transaction session" });
+        });
+        await this.enroll({
+            connection,
+            databaseIdentifier,
+            release: async () => { await pool.checkin(connection); },
+            reuseKey
+        });
+        this.installSharedConnectionProvider(databaseIdentifier, pool);
+    }
+    /**
+     * Makes in-process request/Scoundrel checkouts resolve by current physical identity.
+     * @param {string} databaseIdentifier - Logical database identifier.
+     * @param {import("../database/pool/base.js").default} pool - Owning pool.
+     */
+    installSharedConnectionProvider(databaseIdentifier, pool) {
+        if (this.sharedConnectionRegistrations.has(databaseIdentifier))
+            return;
+        const broker = this.requiredBroker();
+        const sessionIdentity = { address: broker.address(), capability: broker.capability() };
+        const registration = pool.registerTestSharedConnectionProvider({
+            matches: () => sharedTransactionBrokerContextMatches(sessionIdentity),
+            provider: () => {
+                if (!broker.accepting)
+                    throw new Error("Test transaction session capability has been revoked");
+                const reuseKey = pool.getConfigurationReuseKey();
+                const connection = this.enrollments.get(`${databaseIdentifier}\0${reuseKey}`)?.connection;
+                if (!connection)
+                    throw new Error(`Test transaction physical identity is not enrolled: ${databaseIdentifier}`);
+                return connection;
+            }
+        });
+        if (registration)
+            this.sharedConnectionRegistrations.set(databaseIdentifier, { pool, registration });
+    }
+    /**
+     * Returns ephemeral coordinates for one live IPC/control message.
+     * @returns {{address: string, capability: string}} - Non-durable join coordinates.
+     */
+    joinMessage() {
+        const broker = this.requiredBroker();
+        if (!broker.accepting)
+            throw new Error("Test transaction session capability has been revoked");
+        return { address: broker.address(), capability: broker.capability() };
+    }
+    /** Stops admission to the capability. */
+    revoke() { this.requiredBroker().revoke(); }
+    /** Drains work accepted before revocation. */
+    async drain() { await this.requiredBroker().drain(); }
+    /**
+     * Rolls back and releases the complete enrolled set after admission stops.
+     * @returns {Promise<void>} - Resolves after rollback and release.
+     */
+    async rollback() {
+        if (this.rollbackPromise)
+            return await this.rollbackPromise;
+        this.rollbackPromise = this.rollbackActual();
+        return await this.rollbackPromise;
+    }
+    /**
+     * Performs rollback and release once.
+     * @returns {Promise<void>} - Resolves after actual rollback and release.
+     */
+    async rollbackActual() {
+        const broker = this.requiredBroker();
+        if (broker.accepting)
+            throw new Error("Test transaction session must be revoked before rollback");
+        /** @type {Array<Error>} */
+        const errors = [];
+        try {
+            await broker.close();
+        }
+        catch (error) {
+            errors.push(this.normalizeError(error));
+        }
+        for (const { pool, registration } of this.sharedConnectionRegistrations.values()) {
+            pool.clearTestSharedConnection(registration);
+        }
+        this.sharedConnectionRegistrations.clear();
+        for (const enrollment of this.enrollments.values()) {
+            try {
+                await this.rollbackAndRelease(enrollment);
+            }
+            catch (error) {
+                errors.push(this.normalizeError(error));
+            }
+        }
+        this.enrollments.clear();
+        if (errors.length > 0)
+            throw new AggregateError(errors, "Test transaction session rollback failed");
+    }
+    /**
+     * Revokes, drains, rolls back, and releases every enrolled physical connection exactly once.
+     * @returns {Promise<void>} - Resolves after idempotent cleanup.
+     */
+    async cleanup() {
+        if (this.cleanupPromise)
+            return await this.cleanupPromise;
+        this.cleanupPromise = this.cleanupActual();
+        return await this.cleanupPromise;
+    }
+    /**
+     * Performs idempotent cleanup once.
+     * @returns {Promise<void>} - Resolves after actual cleanup.
+     */
+    async cleanupActual() {
+        this.revoke();
+        await this.rollback();
+    }
+    /**
+     * Returns capability-free session diagnostics.
+     * @returns {{accepting: boolean, enrollmentCount: number}} - Capability-free diagnostics.
+     */
+    debugSnapshot() {
+        return { accepting: this.broker?.accepting === true, enrollmentCount: this.enrollments.size };
+    }
+    /**
+     * Returns the begun broker.
+     * @returns {SharedTransactionBroker} - Begun broker.
+     */
+    requiredBroker() {
+        if (!this.broker)
+            throw new Error("Test transaction session has not begun");
+        return this.broker;
+    }
+    /**
+     * Rolls back and releases one owned physical connection.
+     * @param {Enrollment} enrollment - Owned physical connection.
+     * @returns {Promise<void>} - Resolves after rollback and release.
+     */
+    async rollbackAndRelease(enrollment) {
+        /** @type {Array<Error>} */
+        const errors = [];
+        try {
+            await enrollment.connection.rollbackTransaction();
+        }
+        catch (error) {
+            errors.push(this.normalizeError(error));
+        }
+        try {
+            await enrollment.release();
+        }
+        catch (error) {
+            errors.push(this.normalizeError(error));
+        }
+        if (errors.length > 0)
+            throw new AggregateError(errors, "Test transaction enrollment cleanup failed");
+    }
+    /**
+     * Normalizes a thrown cleanup value.
+     * @param {unknown} error - Opaque thrown cleanup value narrowed at this boundary.
+     * @returns {Error} - Error instance.
+     */
+    normalizeError(error) { return error instanceof Error ? error : new Error(String(error)); }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-transaction-session.js","sourceRoot":"","sources":["../../../src/testing/test-transaction-session.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport SharedTransactionBroker from \"./shared-transaction-broker.js\"\nimport { runWithSharedTransactionBrokerConfig, sharedTransactionBrokerContextMatches } from \"./shared-transaction-proxy-driver.js\"\n\n/** @typedef {{connection: import(\"../database/drivers/base.js\").default, databaseIdentifier: string, release: () => Promise<void>, reuseKey: string}} Enrollment */\n\n/**\n * Backend-owned, capability-scoped transaction set for long-lived test services.\n * Join coordinates are intentionally obtainable only as a live control message.\n */\nexport default class TestTransactionSession {\n  /**\n   * Creates an unstarted transaction session.\n   * @param {import(\"../configuration.js\").default} [configuration] - Backend configuration owning enrolled pools.\n   */\n  constructor(configuration) {\n    this.configuration = configuration\n    /** @type {SharedTransactionBroker | undefined} */\n    this.broker = undefined\n    /** @type {Map<string, Enrollment>} */\n    this.enrollments = new Map()\n    /** @type {Map<string, {pool: import(\"../database/pool/base.js\").default, registration: import(\"../database/pool/base.js\").TestSharedConnectionRegistration}>} */\n    this.sharedConnectionRegistrations = new Map()\n    /** @type {Promise<void> | undefined} */\n    this.cleanupPromise = undefined\n    /** @type {Promise<void> | undefined} */\n    this.rollbackPromise = undefined\n  }\n\n  /**\n   * Begins a test transaction session.\n   * @param {{configuration?: import(\"../configuration.js\").default}} [args] - Backend owner.\n   * @returns {Promise<TestTransactionSession>} - Begun session.\n   */\n  static async begin({configuration} = {}) {\n    const session = new TestTransactionSession(configuration)\n    session.broker = await SharedTransactionBroker.start({connections: {}})\n    return session\n  }\n\n  /**\n   * Joins one request/job callback from a live backend control message.\n   * @template T\n   * @param {{address: string, capability: string}} message - Ephemeral coordinates received over live IPC.\n   * @param {() => T} callback - Backend request or worker work.\n   * @returns {T} - Callback result.\n   */\n  static join(message, callback) {\n    return runWithSharedTransactionBrokerConfig({...message, allowDynamicIdentities: true, databaseIdentifiers: [], expected: true}, callback)\n  }\n\n  /**\n   * Lazily adds an exact physical connection to the common rollback set.\n   * @param {Enrollment} enrollment - Checked-out physical connection and owner release hook.\n   */\n  async enroll(enrollment) {\n    const broker = this.requiredBroker()\n    const identity = `${enrollment.databaseIdentifier}\\0${enrollment.reuseKey}`\n    const existing = this.enrollments.get(identity)\n    if (existing) {\n      if (existing.connection !== enrollment.connection) await enrollment.release()\n      return\n    }\n    try {\n      await enrollment.connection.startTransaction()\n    } catch (error) {\n      /** @type {Error | undefined} */\n      let releaseFailure\n      try {\n        await enrollment.release()\n      } catch (releaseError) {\n        releaseFailure = this.normalizeError(releaseError)\n      }\n      if (releaseFailure) {\n        throw new AggregateError(\n          [this.normalizeError(error), releaseFailure],\n          \"Test transaction enrollment start and release failed\",\n          {cause: error}\n        )\n      }\n      throw error\n    }\n    try {\n      broker.enrollConnection(enrollment)\n      this.enrollments.set(identity, enrollment)\n    } catch (error) {\n      await this.rollbackAndRelease(enrollment)\n      throw error\n    }\n  }\n\n  /**\n   * Lazily checks out and enrolls the physical database selected by a tenant descriptor.\n   * @param {{databaseIdentifier: string, tenant?: object}} args - Logical and tenant identity.\n   */\n  async enrollDatabase({databaseIdentifier, tenant}) {\n    if (!this.configuration) throw new Error(\"Test transaction session requires a configuration to enroll a database\")\n    const pool = this.configuration.getDatabasePool(databaseIdentifier)\n    const databaseConfiguration = this.configuration.resolveDatabaseConfiguration(databaseIdentifier, tenant)\n    const reuseKey = pool.getConfigurationReuseKey(databaseConfiguration)\n    const identity = `${databaseIdentifier}\\0${reuseKey}`\n    if (this.enrollments.has(identity)) return\n    const connection = await this.configuration.runWithTenant(tenant, async () => {\n      return await pool.checkout({name: \"Test transaction session\"})\n    })\n    await this.enroll({\n      connection,\n      databaseIdentifier,\n      release: async () => { await pool.checkin(connection) },\n      reuseKey\n    })\n    this.installSharedConnectionProvider(databaseIdentifier, pool)\n  }\n\n  /**\n   * Makes in-process request/Scoundrel checkouts resolve by current physical identity.\n   * @param {string} databaseIdentifier - Logical database identifier.\n   * @param {import(\"../database/pool/base.js\").default} pool - Owning pool.\n   */\n  installSharedConnectionProvider(databaseIdentifier, pool) {\n    if (this.sharedConnectionRegistrations.has(databaseIdentifier)) return\n    const broker = this.requiredBroker()\n    const sessionIdentity = {address: broker.address(), capability: broker.capability()}\n    const registration = pool.registerTestSharedConnectionProvider({\n      matches: () => sharedTransactionBrokerContextMatches(sessionIdentity),\n      provider: () => {\n        if (!broker.accepting) throw new Error(\"Test transaction session capability has been revoked\")\n        const reuseKey = pool.getConfigurationReuseKey()\n        const connection = this.enrollments.get(`${databaseIdentifier}\\0${reuseKey}`)?.connection\n        if (!connection) throw new Error(`Test transaction physical identity is not enrolled: ${databaseIdentifier}`)\n        return connection\n      }\n    })\n    if (registration) this.sharedConnectionRegistrations.set(databaseIdentifier, {pool, registration})\n  }\n\n  /**\n   * Returns ephemeral coordinates for one live IPC/control message.\n   * @returns {{address: string, capability: string}} - Non-durable join coordinates.\n   */\n  joinMessage() {\n    const broker = this.requiredBroker()\n    if (!broker.accepting) throw new Error(\"Test transaction session capability has been revoked\")\n    return {address: broker.address(), capability: broker.capability()}\n  }\n\n  /** Stops admission to the capability. */\n  revoke() { this.requiredBroker().revoke() }\n\n  /** Drains work accepted before revocation. */\n  async drain() { await this.requiredBroker().drain() }\n\n  /**\n   * Rolls back and releases the complete enrolled set after admission stops.\n   * @returns {Promise<void>} - Resolves after rollback and release.\n   */\n  async rollback() {\n    if (this.rollbackPromise) return await this.rollbackPromise\n    this.rollbackPromise = this.rollbackActual()\n    return await this.rollbackPromise\n  }\n\n  /**\n   * Performs rollback and release once.\n   * @returns {Promise<void>} - Resolves after actual rollback and release.\n   */\n  async rollbackActual() {\n    const broker = this.requiredBroker()\n    if (broker.accepting) throw new Error(\"Test transaction session must be revoked before rollback\")\n    /** @type {Array<Error>} */\n    const errors = []\n    try { await broker.close() } catch (error) { errors.push(this.normalizeError(error)) }\n    for (const {pool, registration} of this.sharedConnectionRegistrations.values()) {\n      pool.clearTestSharedConnection(registration)\n    }\n    this.sharedConnectionRegistrations.clear()\n    for (const enrollment of this.enrollments.values()) {\n      try { await this.rollbackAndRelease(enrollment) } catch (error) { errors.push(this.normalizeError(error)) }\n    }\n    this.enrollments.clear()\n    if (errors.length > 0) throw new AggregateError(errors, \"Test transaction session rollback failed\")\n  }\n\n  /**\n   * Revokes, drains, rolls back, and releases every enrolled physical connection exactly once.\n   * @returns {Promise<void>} - Resolves after idempotent cleanup.\n   */\n  async cleanup() {\n    if (this.cleanupPromise) return await this.cleanupPromise\n    this.cleanupPromise = this.cleanupActual()\n    return await this.cleanupPromise\n  }\n\n  /**\n   * Performs idempotent cleanup once.\n   * @returns {Promise<void>} - Resolves after actual cleanup.\n   */\n  async cleanupActual() {\n    this.revoke()\n    await this.rollback()\n  }\n\n  /**\n   * Returns capability-free session diagnostics.\n   * @returns {{accepting: boolean, enrollmentCount: number}} - Capability-free diagnostics.\n   */\n  debugSnapshot() {\n    return {accepting: this.broker?.accepting === true, enrollmentCount: this.enrollments.size}\n  }\n\n  /**\n   * Returns the begun broker.\n   * @returns {SharedTransactionBroker} - Begun broker.\n   */\n  requiredBroker() {\n    if (!this.broker) throw new Error(\"Test transaction session has not begun\")\n    return this.broker\n  }\n\n  /**\n   * Rolls back and releases one owned physical connection.\n   * @param {Enrollment} enrollment - Owned physical connection.\n   * @returns {Promise<void>} - Resolves after rollback and release.\n   */\n  async rollbackAndRelease(enrollment) {\n    /** @type {Array<Error>} */\n    const errors = []\n    try { await enrollment.connection.rollbackTransaction() } catch (error) { errors.push(this.normalizeError(error)) }\n    try { await enrollment.release() } catch (error) { errors.push(this.normalizeError(error)) }\n    if (errors.length > 0) throw new AggregateError(errors, \"Test transaction enrollment cleanup failed\")\n  }\n\n  /**\n   * Normalizes a thrown cleanup value.\n   * @param {unknown} error - Opaque thrown cleanup value narrowed at this boundary.\n   * @returns {Error} - Error instance.\n   */\n  normalizeError(error) { return error instanceof Error ? error : new Error(String(error)) }\n}\n"]}

package/build/src/testing/test.d.ts

@@ -1,5 +1,5 @@
+import { waitForEvent } from "@velocious/testing";
 import Expect from "./expect.js";
-import waitForEvent from "./wait-for-event.js";
 import { arrayContaining, objectContaining } from "./expect-utils.js";
 export type VelociousTestConfig = {
     /**

package/build/src/testing/test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEjD,OAAO,MAAM,MAAM,aAAa,CAAA;AAChC,OAAO,EAAC,eAAe,EAAE,gBAAgB,EAAC,MAAM,mBAAmB,CAAA;AAIhE,YAAkB,mBAAmB,GACrC;;;;IAA+B,aAAa,EAAjC,SAAS,GAAG,MAAM,CAC7B;;;;IAAqB,WAAW,EAArB,MAAM,EAAE,CACnB;;;;IAAmB,qBAAqB,EAA7B,MAAM,CACjB;;;;IAAmB,2BAA2B,EAAnC,MAAM,CACnB;CAAA,CAAA;AAPD;;;;;;;GAOG;AACH;;sDAEsD;AACtD,QAAA,MAAM,KAAK,EADD,OAAO,kBAAkB,EAAE,aAwBpC,CAAA;AAED,QAAA,MAAM,UAAU,4DAAqB,CAAA;AA+DrC;;iCAEiC;AACjC,QAAA,MAAM,UAAU,EADN,mBAMT,CAAA;AAED;;;;;;;;GAQG;AACH,iBAAS,cAAc,CAAC,EAAC,aAAa,EAAE,WAAW,EAAE,qBAAqB,EAAE,2BAA2B,EAAC,GANrG;IAAkC,aAAa,AAA/C,CACA,EADQ,SAAS,GAAG,MAAM,CAC1B;IAAiC,WAAW,AAA5C,CACA,EADQ,MAAM,EAAE,GAAG,MAAM,CACzB;IAAsB,qBAAqB,AAA3C,CACA,EADQ,MAAM,CACd;IAAsB,2BAA2B,AAAjD,CACA,EADQ,MAAM,CACd;CAE0G,GAFhG,IAAI,CAsBhB;AAqBD;;;;GAIG;AACH,iBAAS,UAAU,CAAC,QAAQ,EAHjB,OAAO,kBAAkB,EAAE,2BAGV,GAFf,IAAI,CAMhB;AAED;;;;GAIG;AACH,iBAAS,SAAS,CAAC,QAAQ,EAHhB,OAAO,kBAAkB,EAAE,0BAGX,GAFd,IAAI,CAMhB;AAED;;;;GAIG;AACH,iBAAS,SAAS,CAAC,QAAQ,EAHhB,OAAO,kBAAkB,EAAE,2BAGX,GAFd,IAAI,CAMhB;AAED;;;;GAIG;AACH,iBAAS,QAAQ,CAAC,QAAQ,EAHf,OAAO,kBAAkB,EAAE,0BAGZ,GAFb,IAAI,CAMhB;AAED;;;;;;GAMG;AACH,iBAAe,QAAQ,CAAC,WAAW,EALxB,MAKwB,EAAE,IAAI,EAJ9B,MAAM,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAIJ,EAAE,IAAI,AAH5C,CACA,EADQ,SAAS,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAGD,GAFlC,OAAO,CAAC,IAAI,CAAC,CA8CzB;AAED;;;;GAIG;AACH,iBAAS,MAAM,CAAC,GAAG,EAHR,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAGpB,GAFN,MAAM,CAIlB;kBAFQ,MAAM;;;;AAOf;;;;;;GAMG;AACH,iBAAS,EAAE,CAAC,WAAW,EALZ,MAKY,EAAE,IAAI,EAJlB,MAAM,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAIhB,EAAE,IAAI,AAHhC,CACA,EADQ,SAAS,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAGb,GAFtB,IAAI,CAkChB;AAED;;;;;;GAMG;AACH,iBAAS,GAAG,CAAC,WAAW,EALb,MAKa,EAAE,IAAI,EAJnB,MAAM,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAIf,EAAE,IAAI,AAHjC,CACA,EADQ,SAAS,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAGZ,GAFvB,IAAI,CAwBhB;AAgBD,OAAO,EAAC,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,eAAe,EAAE,gBAAgB,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,EAAC,CAAA"}

package/build/src/testing/test.js

@@ -1,9 +1,9 @@
 // @ts-check
 import path from "path";
 import { fileURLToPath } from "url";
+import { waitForEvent } from "@velocious/testing";
 import EventEmitter from "../utils/event-emitter.js";
 import Expect from "./expect.js";
-import waitForEvent from "./wait-for-event.js";
 import { arrayContaining, objectContaining } from "./expect-utils.js";
 /**
  * VelociousTestConfig type.
@@ -318,4 +318,4 @@ Object.assign(globalThis, {
     testEvents
 });
 export { afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, expect, fit, it, arrayContaining, objectContaining, testConfig, testEvents, tests, waitForEvent };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.js","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport path from \"path\"\nimport {fileURLToPath} from \"url\"\nimport EventEmitter from \"../utils/event-emitter.js\"\nimport Expect from \"./expect.js\"\nimport waitForEvent from \"./wait-for-event.js\"\nimport {arrayContaining, objectContaining} from \"./expect-utils.js\"\n\n/**\n * VelociousTestConfig type.\n * @typedef {object} VelociousTestConfig\n * @property {\"failure\" | \"live\"} consoleOutput - Console output mode.\n * @property {string[]} excludeTags - Tags excluded by default.\n * @property {number} defaultTimeoutSeconds - Default timeout in seconds.\n * @property {number} failedConsoleOutputMaxLines - Maximum failed console lines to print inline.\n */\n/**\n * Tests.\n * @type {import(\"./test-runner.js\").TestsArgument} */\nconst tests = {\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} */\n  afterEaches: [],\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").BeforeAfterAllCallbackObjectType[]} */\n  afterAlls: [],\n  args: {},\n\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").BeforeAfterAllCallbackObjectType[]} */\n  beforeAlls: [],\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} */\n  beforeEaches: [],\n  filePath: undefined,\n  line: undefined,\n  subs: {},\n  tests: {}\n}\n\nconst testEvents = new EventEmitter()\n\nlet currentPath = [tests]\n\n/**\n * Runs capture location.\n * @returns {{filePath?: string, line?: number}} - Location.\n */\nfunction captureLocation() {\n  const error = new Error()\n  const stack = typeof error.stack === \"string\" ? error.stack.split(\"\\n\") : []\n\n  for (const line of stack) {\n    const trimmed = line.trim()\n\n    if (!trimmed.includes(\"at\")) continue\n    if (trimmed.includes(\"/src/testing/test.js\")) continue\n\n    const match = trimmed.match(/(?:\\(|\\s)(file:\\/\\/.*?|\\/.*?):(\\d+):(\\d+)\\)?$/)\n\n    if (!match) continue\n\n    const rawPath = match[1]\n    const lineNumber = Number(match[2])\n    const filePath = rawPath.startsWith(\"file://\")\n      ? fileURLToPath(rawPath)\n      : rawPath\n\n    return {\n      filePath: path.resolve(filePath),\n      line: Number.isFinite(lineNumber) ? lineNumber : undefined\n    }\n  }\n\n  return {}\n}\n\n/**\n * Runs normalize tags.\n * @param {string[] | string | undefined} tags - Tags.\n * @returns {string[]} - Normalized tags.\n */\nfunction normalizeTags(tags) {\n  if (!tags) return []\n\n  const values = []\n  const rawTags = Array.isArray(tags) ? tags : [tags]\n\n  for (const rawTag of rawTags) {\n    if (rawTag === undefined || rawTag === null) continue\n\n    const parts = String(rawTag).split(\",\")\n\n    for (const part of parts) {\n      const trimmed = part.trim()\n\n      if (trimmed) values.push(trimmed)\n    }\n  }\n\n  return Array.from(new Set(values))\n}\n\n/**\n * Test config.\n * @type {VelociousTestConfig} */\nconst testConfig = {\n  consoleOutput: \"failure\",\n  failedConsoleOutputMaxLines: 200,\n  excludeTags: [],\n  defaultTimeoutSeconds: 60\n}\n\n/**\n * Runs configure tests.\n * @param {object} args - Options.\n * @param {\"failure\" | \"live\"} [args.consoleOutput] - Console output mode.\n * @param {string[] | string} [args.excludeTags] - Tags to exclude.\n * @param {number} [args.defaultTimeoutSeconds] - Default timeout in seconds.\n * @param {number} [args.failedConsoleOutputMaxLines] - Maximum failed console lines to print inline.\n * @returns {void}\n */\nfunction configureTests({consoleOutput, excludeTags, defaultTimeoutSeconds, failedConsoleOutputMaxLines} = {}) {\n  if (excludeTags !== undefined) {\n    testConfig.excludeTags = normalizeTags(excludeTags)\n  }\n\n  if (consoleOutput !== undefined) {\n    if (consoleOutput !== \"failure\" && consoleOutput !== \"live\") {\n      throw new Error(`Invalid consoleOutput config: ${consoleOutput}`)\n    }\n\n    testConfig.consoleOutput = consoleOutput\n  }\n\n  if (typeof defaultTimeoutSeconds === \"number\") {\n    testConfig.defaultTimeoutSeconds = defaultTimeoutSeconds\n  }\n\n  if (typeof failedConsoleOutputMaxLines === \"number\") {\n    testConfig.failedConsoleOutputMaxLines = failedConsoleOutputMaxLines\n  }\n}\n\n/**\n * Runs merge test args.\n * @param {Record<string, ReturnType<typeof JSON.parse>>} baseArgs - Base args.\n * @param {Record<string, ReturnType<typeof JSON.parse>>} extraArgs - Extra args.\n * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Merged args.\n */\nfunction mergeTestArgs(baseArgs, extraArgs) {\n  const merged = Object.assign({}, baseArgs, extraArgs)\n  const mergedTags = [...normalizeTags(baseArgs?.tags), ...normalizeTags(extraArgs?.tags)]\n\n  if (mergedTags.length > 0) {\n    merged.tags = Array.from(new Set(mergedTags))\n  } else if (\"tags\" in merged) {\n    delete merged.tags\n  }\n\n  return merged\n}\n\n/**\n * Runs before each.\n * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction beforeEach(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.beforeEaches.push({callback})\n}\n\n/**\n * Runs before all.\n * @param {import(\"./test-runner.js\").BeforeAfterAllCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction beforeAll(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.beforeAlls.push({callback})\n}\n\n/**\n * Runs after each.\n * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction afterEach(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.afterEaches.push({callback})\n}\n\n/**\n * Runs after all.\n * @param {import(\"./test-runner.js\").BeforeAfterAllCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction afterAll(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.afterAlls.push({callback})\n}\n\n/**\n * Runs describe.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {Promise<void>} - Resolves when complete.\n */\nasync function describe(description, arg1, arg2) {\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n  let testArgs, testFunction\n\n  if (typeof arg2 == \"function\") {\n    testFunction = arg2\n    testArgs = arg1\n  } else if (typeof arg1 == \"function\") {\n    testFunction = arg1\n    testArgs = {}\n  } else {\n    throw new Error(`Invalid arguments for describe: ${arg1}, ${arg2}`)\n  }\n\n  const currentTest = currentPath[currentPath.length - 1]\n  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)\n\n  if (description in currentTest.subs) {\n    throw new Error(`Duplicate test description: ${description}`)\n  }\n\n  const location = captureLocation()\n  const newTestData = {\n    afterEaches: [],\n    afterAlls: [],\n    args: newTestArgs,\n    beforeAlls: [],\n    beforeEaches: [],\n    filePath: location.filePath,\n    line: location.line,\n    subs: {},\n    tests: {}\n  }\n\n  currentTest.subs[description] = newTestData\n  currentPath.push(newTestData)\n\n  try {\n    await testFunction()\n  } finally {\n    currentPath.pop()\n  }\n}\n\n/**\n * Runs expect.\n * @param {ReturnType<typeof JSON.parse>} arg - Arg.\n * @returns {Expect} - The expect.\n */\nfunction expect(arg) {\n  return new Expect(arg)\n}\n\nexpect.objectContaining = objectContaining\nexpect.arrayContaining = arrayContaining\n\n/**\n * Runs it.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {void} - No return value.\n */\nfunction it(description, arg1, arg2) {\n  const currentTest = currentPath[currentPath.length - 1]\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n  let testArgs\n\n  /**\n   * Defines testFunction.\n   * @type {() => (void|Promise<void>)} */\n  let testFunction\n\n  if (typeof arg1 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)\n    testArgs = arg1\n  } else {\n    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)\n  }\n\n  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)\n\n  const location = captureLocation()\n\n  currentTest.tests[description] = {\n    args: newTestArgs,\n    function: testFunction,\n    filePath: location.filePath,\n    line: location.line\n  }\n}\n\n/**\n * Runs fit.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {void} - No return value.\n */\nfunction fit(description, arg1, arg2) {\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n  let testArgs\n\n  /**\n   * Defines testFunction.\n   * @type {() => (void|Promise<void>)} */\n  let testFunction\n\n  if (typeof arg1 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {focus: true}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)\n    testArgs = Object.assign({focus: true}, arg1)\n  } else {\n    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)\n  }\n\n  return it(description, testArgs, testFunction)\n}\n\n// Make the methods global so they can be used in test files\nObject.assign(globalThis, {\n  afterAll,\n  afterEach,\n  beforeAll,\n  beforeEach,\n  configureTests,\n  describe,\n  expect,\n  fit,\n  it,\n  testEvents\n})\n\nexport {afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, expect, fit, it, arrayContaining, objectContaining, testConfig, testEvents, tests, waitForEvent}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.js","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport path from \"path\"\nimport {fileURLToPath} from \"url\"\nimport { waitForEvent } from \"@velocious/testing\"\nimport EventEmitter from \"../utils/event-emitter.js\"\nimport Expect from \"./expect.js\"\nimport {arrayContaining, objectContaining} from \"./expect-utils.js\"\n\n/**\n * VelociousTestConfig type.\n * @typedef {object} VelociousTestConfig\n * @property {\"failure\" | \"live\"} consoleOutput - Console output mode.\n * @property {string[]} excludeTags - Tags excluded by default.\n * @property {number} defaultTimeoutSeconds - Default timeout in seconds.\n * @property {number} failedConsoleOutputMaxLines - Maximum failed console lines to print inline.\n */\n/**\n * Tests.\n * @type {import(\"./test-runner.js\").TestsArgument} */\nconst tests = {\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} */\n  afterEaches: [],\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").BeforeAfterAllCallbackObjectType[]} */\n  afterAlls: [],\n  args: {},\n\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").BeforeAfterAllCallbackObjectType[]} */\n  beforeAlls: [],\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} */\n  beforeEaches: [],\n  filePath: undefined,\n  line: undefined,\n  subs: {},\n  tests: {}\n}\n\nconst testEvents = new EventEmitter()\n\nlet currentPath = [tests]\n\n/**\n * Runs capture location.\n * @returns {{filePath?: string, line?: number}} - Location.\n */\nfunction captureLocation() {\n  const error = new Error()\n  const stack = typeof error.stack === \"string\" ? error.stack.split(\"\\n\") : []\n\n  for (const line of stack) {\n    const trimmed = line.trim()\n\n    if (!trimmed.includes(\"at\")) continue\n    if (trimmed.includes(\"/src/testing/test.js\")) continue\n\n    const match = trimmed.match(/(?:\\(|\\s)(file:\\/\\/.*?|\\/.*?):(\\d+):(\\d+)\\)?$/)\n\n    if (!match) continue\n\n    const rawPath = match[1]\n    const lineNumber = Number(match[2])\n    const filePath = rawPath.startsWith(\"file://\")\n      ? fileURLToPath(rawPath)\n      : rawPath\n\n    return {\n      filePath: path.resolve(filePath),\n      line: Number.isFinite(lineNumber) ? lineNumber : undefined\n    }\n  }\n\n  return {}\n}\n\n/**\n * Runs normalize tags.\n * @param {string[] | string | undefined} tags - Tags.\n * @returns {string[]} - Normalized tags.\n */\nfunction normalizeTags(tags) {\n  if (!tags) return []\n\n  const values = []\n  const rawTags = Array.isArray(tags) ? tags : [tags]\n\n  for (const rawTag of rawTags) {\n    if (rawTag === undefined || rawTag === null) continue\n\n    const parts = String(rawTag).split(\",\")\n\n    for (const part of parts) {\n      const trimmed = part.trim()\n\n      if (trimmed) values.push(trimmed)\n    }\n  }\n\n  return Array.from(new Set(values))\n}\n\n/**\n * Test config.\n * @type {VelociousTestConfig} */\nconst testConfig = {\n  consoleOutput: \"failure\",\n  failedConsoleOutputMaxLines: 200,\n  excludeTags: [],\n  defaultTimeoutSeconds: 60\n}\n\n/**\n * Runs configure tests.\n * @param {object} args - Options.\n * @param {\"failure\" | \"live\"} [args.consoleOutput] - Console output mode.\n * @param {string[] | string} [args.excludeTags] - Tags to exclude.\n * @param {number} [args.defaultTimeoutSeconds] - Default timeout in seconds.\n * @param {number} [args.failedConsoleOutputMaxLines] - Maximum failed console lines to print inline.\n * @returns {void}\n */\nfunction configureTests({consoleOutput, excludeTags, defaultTimeoutSeconds, failedConsoleOutputMaxLines} = {}) {\n  if (excludeTags !== undefined) {\n    testConfig.excludeTags = normalizeTags(excludeTags)\n  }\n\n  if (consoleOutput !== undefined) {\n    if (consoleOutput !== \"failure\" && consoleOutput !== \"live\") {\n      throw new Error(`Invalid consoleOutput config: ${consoleOutput}`)\n    }\n\n    testConfig.consoleOutput = consoleOutput\n  }\n\n  if (typeof defaultTimeoutSeconds === \"number\") {\n    testConfig.defaultTimeoutSeconds = defaultTimeoutSeconds\n  }\n\n  if (typeof failedConsoleOutputMaxLines === \"number\") {\n    testConfig.failedConsoleOutputMaxLines = failedConsoleOutputMaxLines\n  }\n}\n\n/**\n * Runs merge test args.\n * @param {Record<string, ReturnType<typeof JSON.parse>>} baseArgs - Base args.\n * @param {Record<string, ReturnType<typeof JSON.parse>>} extraArgs - Extra args.\n * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Merged args.\n */\nfunction mergeTestArgs(baseArgs, extraArgs) {\n  const merged = Object.assign({}, baseArgs, extraArgs)\n  const mergedTags = [...normalizeTags(baseArgs?.tags), ...normalizeTags(extraArgs?.tags)]\n\n  if (mergedTags.length > 0) {\n    merged.tags = Array.from(new Set(mergedTags))\n  } else if (\"tags\" in merged) {\n    delete merged.tags\n  }\n\n  return merged\n}\n\n/**\n * Runs before each.\n * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction beforeEach(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.beforeEaches.push({callback})\n}\n\n/**\n * Runs before all.\n * @param {import(\"./test-runner.js\").BeforeAfterAllCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction beforeAll(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.beforeAlls.push({callback})\n}\n\n/**\n * Runs after each.\n * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction afterEach(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.afterEaches.push({callback})\n}\n\n/**\n * Runs after all.\n * @param {import(\"./test-runner.js\").BeforeAfterAllCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction afterAll(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.afterAlls.push({callback})\n}\n\n/**\n * Runs describe.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {Promise<void>} - Resolves when complete.\n */\nasync function describe(description, arg1, arg2) {\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n  let testArgs, testFunction\n\n  if (typeof arg2 == \"function\") {\n    testFunction = arg2\n    testArgs = arg1\n  } else if (typeof arg1 == \"function\") {\n    testFunction = arg1\n    testArgs = {}\n  } else {\n    throw new Error(`Invalid arguments for describe: ${arg1}, ${arg2}`)\n  }\n\n  const currentTest = currentPath[currentPath.length - 1]\n  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)\n\n  if (description in currentTest.subs) {\n    throw new Error(`Duplicate test description: ${description}`)\n  }\n\n  const location = captureLocation()\n  const newTestData = {\n    afterEaches: [],\n    afterAlls: [],\n    args: newTestArgs,\n    beforeAlls: [],\n    beforeEaches: [],\n    filePath: location.filePath,\n    line: location.line,\n    subs: {},\n    tests: {}\n  }\n\n  currentTest.subs[description] = newTestData\n  currentPath.push(newTestData)\n\n  try {\n    await testFunction()\n  } finally {\n    currentPath.pop()\n  }\n}\n\n/**\n * Runs expect.\n * @param {ReturnType<typeof JSON.parse>} arg - Arg.\n * @returns {Expect} - The expect.\n */\nfunction expect(arg) {\n  return new Expect(arg)\n}\n\nexpect.objectContaining = objectContaining\nexpect.arrayContaining = arrayContaining\n\n/**\n * Runs it.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {void} - No return value.\n */\nfunction it(description, arg1, arg2) {\n  const currentTest = currentPath[currentPath.length - 1]\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n  let testArgs\n\n  /**\n   * Defines testFunction.\n   * @type {() => (void|Promise<void>)} */\n  let testFunction\n\n  if (typeof arg1 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)\n    testArgs = arg1\n  } else {\n    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)\n  }\n\n  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)\n\n  const location = captureLocation()\n\n  currentTest.tests[description] = {\n    args: newTestArgs,\n    function: testFunction,\n    filePath: location.filePath,\n    line: location.line\n  }\n}\n\n/**\n * Runs fit.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {void} - No return value.\n */\nfunction fit(description, arg1, arg2) {\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n  let testArgs\n\n  /**\n   * Defines testFunction.\n   * @type {() => (void|Promise<void>)} */\n  let testFunction\n\n  if (typeof arg1 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {focus: true}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)\n    testArgs = Object.assign({focus: true}, arg1)\n  } else {\n    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)\n  }\n\n  return it(description, testArgs, testFunction)\n}\n\n// Make the methods global so they can be used in test files\nObject.assign(globalThis, {\n  afterAll,\n  afterEach,\n  beforeAll,\n  beforeEach,\n  configureTests,\n  describe,\n  expect,\n  fit,\n  it,\n  testEvents\n})\n\nexport {afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, expect, fit, it, arrayContaining, objectContaining, testConfig, testEvents, tests, waitForEvent}\n"]}

package/build/testing/shared-transaction-broker-client.js

@@ -6,11 +6,12 @@ import { decodeBrokerValue, encodeBrokerValue } from "./shared-transaction-codec
 export default class SharedTransactionBrokerClient {
   /**
    * Creates a broker client.
-   * @param {{address: string, capability: string, databaseIdentifier: string}} args - Broker coordinates.
+   * @param {{address: string, capability: string, databaseIdentifier: string, reuseKey?: string}} args - Broker coordinates.
    */
-  constructor({address, capability, databaseIdentifier}) {
+  constructor({address, capability, databaseIdentifier, reuseKey}) {
     this.capability = capability
     this.databaseIdentifier = databaseIdentifier
+    this.reuseKey = reuseKey
     this.nextRequestId = 1
     /** @type {Map<number, {reject: (error: Error) => void, resolve: (value: ReturnType<typeof decodeBrokerValue>) => void}>} */
     this.pending = new Map()
@@ -46,6 +47,7 @@ export default class SharedTransactionBrokerClient {
       requestId,
       capability: this.capability,
       databaseIdentifier: this.databaseIdentifier,
+      reuseKey: this.reuseKey,
       method,
       args: encodeBrokerValue(args)
     }), (error) => {

package/build/testing/shared-transaction-broker.js

@@ -80,15 +80,9 @@ export default class SharedTransactionBroker extends EventEmitter {
     /** @type {Map<object, symbol>} */
     this.connectionCoordinatorOwners = new Map()
     for (const connection of new Set(Object.values(connections))) {
-      /**
-       * Serializes parent operations with child broker traffic.
-       * @param {() => Promise<unknown>} callback - Parent operation.
-       * @returns {Promise<unknown>} - Operation result.
-       */
-      const coordinator = async (callback) => await this.serialize(this.connectionState(connection), callback)
-      this.connectionCoordinators.set(connection, coordinator)
-      this.connectionCoordinatorOwners.set(connection, setSharedTransactionCoordinator(connection, coordinator))
+      this.installConnectionCoordinator(connection)
     }
+    this.physicalConnections = new Map()
     this.httpServer = createServer()
     this.websocketServer = new WebSocketServer({server: this.httpServer, maxPayload: 16 * 1024 * 1024})
     this.websocketServer.on("connection", (socket) => {
@@ -101,6 +95,37 @@ export default class SharedTransactionBroker extends EventEmitter {
     })
   }
 
+  /**
+   * Installs serialization ownership for a newly enrolled physical connection.
+   * @param {object} connection - Parent-owned physical connection.
+   * @returns {void}
+   */
+  installConnectionCoordinator(connection) {
+    if (this.connectionCoordinators.has(connection)) return
+    /**
+     * Serializes parent operations with child broker traffic.
+     * @param {() => Promise<unknown>} callback - Parent operation.
+     * @returns {Promise<unknown>} - Operation result.
+     */
+    const coordinator = async (callback) => await this.serialize(this.connectionState(connection), callback)
+    this.connectionCoordinators.set(connection, coordinator)
+    this.connectionCoordinatorOwners.set(connection, setSharedTransactionCoordinator(connection, coordinator))
+  }
+
+  /**
+   * Enrolls one exact physical database identity in this capability's rollback set.
+   * @param {{connection: object, databaseIdentifier: string, reuseKey: string}} args - Physical connection identity.
+   * @returns {void}
+   */
+  enrollConnection({connection, databaseIdentifier, reuseKey}) {
+    if (!this.accepting) throw new Error("Shared transaction broker capability has been revoked")
+    const identity = `${databaseIdentifier}\0${reuseKey}`
+    const existing = this.physicalConnections.get(identity)
+    if (existing && existing !== connection) throw new Error(`Shared transaction physical connection identity is already enrolled: ${databaseIdentifier}`)
+    this.installConnectionCoordinator(connection)
+    this.physicalConnections.set(identity, connection)
+  }
+
   /**
    * Starts a broker on an ephemeral loopback port.
    * @param {{connections: Record<string, object>}} args - Parent-owned physical connections.
@@ -140,18 +165,22 @@ export default class SharedTransactionBroker extends EventEmitter {
   async handleRequest(socket, serialized) {
     let requestId = 0
     try {
-      const request = /** @type {{requestId: number, capability: string, databaseIdentifier: string, method: string, args: import("./shared-transaction-codec.js").EncodedBrokerValue}} */ (JSON.parse(serialized))
+      const request = /** @type {{requestId: number, capability: string, databaseIdentifier: string, reuseKey?: string, method: string, args: import("./shared-transaction-codec.js").EncodedBrokerValue}} */ (JSON.parse(serialized))
       requestId = request.requestId
       if (!this.accepting) throw new Error("Shared transaction broker capability has been revoked")
       if (!capabilityMatches(request.capability, this.secret)) throw new Error("Unknown shared transaction broker capability")
-      const connection = this.connections[request.databaseIdentifier]
-      if (!connection) throw new Error(`Unknown shared transaction database identifier: ${request.databaseIdentifier}`)
+      const connection = request.reuseKey
+        ? this.physicalConnections.get(`${request.databaseIdentifier}\0${request.reuseKey}`)
+        : this.connections[request.databaseIdentifier]
+      if (!connection) {
+        if (request.reuseKey) throw new Error(`Unenrolled physical connection identity: ${request.databaseIdentifier}`)
+        throw new Error(`Unknown shared transaction database identifier: ${request.databaseIdentifier}`)
+      }
       if (!ALLOWED_METHODS.has(request.method)) throw new Error(`Unsupported shared transaction broker method: ${request.method}`)
       const args = decodeBrokerValue(request.args)
       if (!Array.isArray(args)) throw new TypeError("Shared transaction broker arguments must be an array")
       this.emit("work-queued", {connection, databaseIdentifier: request.databaseIdentifier, method: request.method})
       const result = await this.runConnectionRequest({connection, method: request.method, savePointName: typeof args[0] === "string" ? args[0] : undefined, socket}, async () => {
-        if (!this.accepting) throw new Error("Shared transaction broker capability has been revoked")
         if (request.method === "rootTransactionRollback") {
           await this.rollbackRootSavePoint(connection, /** @type {string} */ (args[0]))
           return undefined
@@ -258,10 +287,11 @@ export default class SharedTransactionBroker extends EventEmitter {
 
     state.queue = previous.then(async () => {
       try {
-        if (!this.accepting || socket.readyState !== socket.OPEN) throw new Error("Shared transaction broker root transaction session closed before lease acquisition")
+        if (socket.readyState !== socket.OPEN) throw new Error("Shared transaction broker root transaction session closed before lease acquisition")
         const result = await callback()
         state.lease = {operations: Promise.resolve(), release, savePointName, socket}
         resolveStarted(result)
+        if (!this.accepting) await this.scheduleSessionCleanup(socket)
         await held
       } catch (error) {
         state.rootSessions.delete(socket)
@@ -418,17 +448,29 @@ export default class SharedTransactionBroker extends EventEmitter {
     return await this.closePromise
   }
 
+  /** Revokes admission without interrupting already accepted work. */
+  revoke() {
+    if (!this.accepting) return
+    this.accepting = false
+    this.secret = randomBytes(32).toString("base64url")
+  }
+
+  /** Drains all work accepted before capability revocation. */
+  async drain() {
+    if (this.accepting) throw new Error("Shared transaction broker must be revoked before drain")
+    await Promise.all(Array.from(this.connectionStates.values()).map((state) => state.queue))
+  }
+
   /**
    * Performs deterministic transport shutdown and reports cleanup failures last.
    * @returns {Promise<void>} - Resolves after shutdown or rejects with cleanup errors.
    */
   async closeTransport() {
-    this.accepting = false
-    this.secret = randomBytes(32).toString("base64url")
+    this.revoke()
     const closingSessions = Array.from(this.sessions)
     await Promise.all(closingSessions.map(async (socket) => await this.scheduleSessionCleanup(socket)))
+    await this.drain()
     for (const socket of closingSessions) socket.close(1001, "Shared transaction broker closed")
-    await Promise.allSettled(Array.from(this.connectionStates.values()).map((state) => state.queue))
     await new Promise((resolve) => this.websocketServer.close(() => resolve(undefined)))
     await new Promise((resolve) => this.httpServer.close(() => resolve(undefined)))
     await Promise.all(Array.from(this.sessionCleanup.values()))