velocious 1.0.618 → 1.0.619

package/build/src/testing/shared-transaction-proxy-driver.js

@@ -1,4 +1,4 @@
-/** @typedef {{address?: string, capability?: string, databaseIdentifiers?: string[], expected: boolean}} SharedTransactionBrokerJobConfig */
+/** @typedef {{address?: string, allowDynamicIdentities?: boolean, capability?: string, databaseIdentifiers?: string[], expected: boolean}} SharedTransactionBrokerJobConfig */
 // @ts-check
 import SharedTransactionBrokerClient from "./shared-transaction-broker-client.js";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -6,6 +6,21 @@ export const SHARED_TRANSACTION_BROKER_ENV = "VELOCIOUS_TEST_SHARED_TRANSACTION_
 export const BACKGROUND_JOB_CHILD_ENV = "VELOCIOUS_BACKGROUND_JOB_CHILD";
 /** @type {AsyncLocalStorage<SharedTransactionBrokerJobConfig>} */
 const pooledJobBrokerConfig = new AsyncLocalStorage();
+/**
+ * Returns the active live broker configuration without validating one database route.
+ * @returns {SharedTransactionBrokerJobConfig | undefined} - Active live or child configuration.
+ */
+function activeSharedTransactionBrokerConfig() {
+    const contextualConfig = pooledJobBrokerConfig.getStore();
+    if (contextualConfig)
+        return contextualConfig;
+    if (process.env[BACKGROUND_JOB_CHILD_ENV] !== "1")
+        return undefined;
+    const serialized = process.env[SHARED_TRANSACTION_BROKER_ENV];
+    if (!serialized)
+        return undefined;
+    return JSON.parse(Buffer.from(serialized, "base64url").toString("utf8"));
+}
 /**
  * Runs one pooled job with dispatch-time broker configuration.
  * @template T
@@ -16,6 +31,30 @@ const pooledJobBrokerConfig = new AsyncLocalStorage();
 export function runWithSharedTransactionBrokerConfig(config, callback) {
     return pooledJobBrokerConfig.run(config, callback);
 }
+/**
+ * Checks whether the current live join selects one exact session capability.
+ * @param {{address: string, capability: string}} identity - Session control-message identity.
+ * @returns {boolean} - Whether this async context belongs to that session.
+ */
+export function sharedTransactionBrokerContextMatches(identity) {
+    const config = pooledJobBrokerConfig.getStore();
+    return config?.expected === true && config.address === identity.address && config.capability === identity.capability;
+}
+/**
+ * Preserves legacy real tenant connections omitted by automatic TestRunner mode.
+ * Explicit dynamic sessions never permit this fallback.
+ * @param {string} databaseIdentifier - Logical database identifier.
+ * @returns {boolean} - Whether an omitted automatic route stays independent.
+ */
+export function automaticSharedTransactionBrokerOmits(databaseIdentifier) {
+    const config = activeSharedTransactionBrokerConfig();
+    return Boolean(config?.expected === true &&
+        !config.allowDynamicIdentities &&
+        typeof config.address === "string" &&
+        typeof config.capability === "string" &&
+        Array.isArray(config.databaseIdentifiers) &&
+        !config.databaseIdentifiers.includes(databaseIdentifier));
+}
 /**
  * Escapes a PostgreSQL literal without requiring a live child connection.
  * @param {ReturnType<typeof JSON.parse>} value - PostgreSQL literal value.
@@ -41,24 +80,19 @@ function pgEscapeLiteral(value) {
  * Parses the test-runner-owned child transport configuration when this logical
  * database is registered for the active attempt.
  * @param {string} databaseIdentifier - Logical database identifier.
- * @returns {{address: string, capability: string} | undefined} - Broker coordinates.
+ * @returns {{address: string, allowDynamicIdentities?: boolean, capability: string} | undefined} - Broker coordinates.
  */
 export function sharedTransactionBrokerConfig(databaseIdentifier) {
-    const contextualConfig = pooledJobBrokerConfig.getStore();
-    if (contextualConfig)
-        return validatedBrokerConfig(contextualConfig, databaseIdentifier);
-    if (process.env[BACKGROUND_JOB_CHILD_ENV] !== "1")
-        return undefined;
-    const serialized = process.env[SHARED_TRANSACTION_BROKER_ENV];
-    if (!serialized)
+    const config = activeSharedTransactionBrokerConfig();
+    if (!config)
         return undefined;
-    return validatedBrokerConfig(JSON.parse(Buffer.from(serialized, "base64url").toString("utf8")), databaseIdentifier);
+    return validatedBrokerConfig(config, databaseIdentifier);
 }
 /**
  * Validates dispatch-time broker configuration and fails closed when expected.
  * @param {SharedTransactionBrokerJobConfig} config - Candidate configuration.
  * @param {string} databaseIdentifier - Logical database identifier.
- * @returns {{address: string, capability: string} | undefined} - Broker coordinates.
+ * @returns {{address: string, allowDynamicIdentities?: boolean, capability: string} | undefined} - Broker coordinates.
  */
 function validatedBrokerConfig(config, databaseIdentifier) {
     if (config.expected && (!config.address || !config.capability || !config.databaseIdentifiers)) {
@@ -69,9 +103,12 @@ function validatedBrokerConfig(config, databaseIdentifier) {
     if (typeof config.address !== "string" || typeof config.capability !== "string" || !Array.isArray(config.databaseIdentifiers)) {
         throw new Error("Invalid shared transaction broker child configuration");
     }
-    if (!config.databaseIdentifiers.includes(databaseIdentifier)) {
+    if (!config.allowDynamicIdentities && !config.databaseIdentifiers.includes(databaseIdentifier)) {
         throw new Error(`Transactional pooled job expected broker database identifier: ${databaseIdentifier}`);
     }
+    if (config.allowDynamicIdentities) {
+        return { address: config.address, allowDynamicIdentities: true, capability: config.capability };
+    }
     return { address: config.address, capability: config.capability };
 }
 /**
@@ -81,7 +118,7 @@ function validatedBrokerConfig(config, databaseIdentifier) {
  * @param {import("../configuration-types.js").DatabaseConfigurationType} config - Database configuration.
  * @param {import("../configuration.js").default} configuration - Child configuration.
  * @param {string} databaseIdentifier - Logical identifier.
- * @param {{address: string, capability: string}} brokerConfig - Broker coordinates.
+ * @param {{address: string, capability: string, reuseKey?: string}} brokerConfig - Broker coordinates.
  * @returns {import("../database/drivers/base.js").default} - Unconnected physical proxy.
  */
 export function createSharedTransactionProxyDriver(DriverClass, config, configuration, databaseIdentifier, brokerConfig) {
@@ -192,4 +229,4 @@ export function createSharedTransactionProxyDriver(DriverClass, config, configur
     }
     return new SharedTransactionProxyDriver();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared-transaction-proxy-driver.js","sourceRoot":"","sources":["../../../src/testing/shared-transaction-proxy-driver.js"],"names":[],"mappings":"AAAA,6IAA6I;AAE7I,YAAY;AAEZ,OAAO,6BAA6B,MAAM,uCAAuC,CAAA;AACjF,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAEpD,MAAM,CAAC,MAAM,6BAA6B,GAAG,0CAA0C,CAAA;AACvF,MAAM,CAAC,MAAM,wBAAwB,GAAG,gCAAgC,CAAA;AAExE,kEAAkE;AAClE,MAAM,qBAAqB,GAAG,IAAI,iBAAiB,EAAE,CAAA;AAErD;;;;;;GAMG;AACH,MAAM,UAAU,oCAAoC,CAAC,MAAM,EAAE,QAAQ;IACnE,OAAO,qBAAqB,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;AACpD,CAAC;AAED;;;;GAIG;AACH,SAAS,eAAe,CAAC,KAAK;IAC5B,MAAM,MAAM,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IAChE,IAAI,OAAO,GAAG,GAAG,CAAA;IACjB,IAAI,YAAY,GAAG,KAAK,CAAA;IAExB,KAAK,MAAM,SAAS,IAAI,MAAM,EAAE,CAAC;QAC/B,IAAI,SAAS,KAAK,GAAG;YAAE,OAAO,IAAI,SAAS,CAAA;QAC3C,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;YACvB,OAAO,IAAI,SAAS,CAAA;YACpB,YAAY,GAAG,IAAI,CAAA;QACrB,CAAC;QACD,OAAO,IAAI,SAAS,CAAA;IACtB,CAAC;IAED,OAAO,IAAI,GAAG,CAAA;IACd,OAAO,YAAY,CAAC,CAAC,CAAC,KAAK,OAAO,EAAE,CAAC,CAAC,CAAC,OAAO,CAAA;AAChD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,6BAA6B,CAAC,kBAAkB;IAC9D,MAAM,gBAAgB,GAAG,qBAAqB,CAAC,QAAQ,EAAE,CAAA;IACzD,IAAI,gBAAgB;QAAE,OAAO,qBAAqB,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,CAAA;IACxF,IAAI,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,KAAK,GAAG;QAAE,OAAO,SAAS,CAAA;IAEnE,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,6BAA6B,CAAC,CAAA;IAC7D,IAAI,CAAC,UAAU;QAAE,OAAO,SAAS,CAAA;IAEjC,OAAO,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAA;AACrH,CAAC;AAED;;;;;GAKG;AACH,SAAS,qBAAqB,CAAC,MAAM,EAAE,kBAAkB;IACvD,IAAI,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,EAAE,CAAC;QAC9F,MAAM,IAAI,KAAK,CAAC,yEAAyE,CAAC,CAAA;IAC5F,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,QAAQ;QAAE,OAAO,SAAS,CAAA;IACtC,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,IAAI,OAAO,MAAM,CAAC,UAAU,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAAC,EAAE,CAAC;QAC9H,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAA;IAC1E,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC;QAC7D,MAAM,IAAI,KAAK,CAAC,iEAAiE,kBAAkB,EAAE,CAAC,CAAA;IACxG,CAAC;IAED,OAAO,EAAC,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAC,CAAA;AACjE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,kCAAkC,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,kBAAkB,EAAE,YAAY;IACrH,MAAM,4BAA6B,SAAQ,WAAW;QACpD;YACE,KAAK,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;YAC5B,IAAI,CAAC,uBAAuB,GAAG,IAAI,6BAA6B,CAAC,EAAC,GAAG,YAAY,EAAE,kBAAkB,EAAC,CAAC,CAAA;YACvG,iCAAiC;YACjC,IAAI,CAAC,8BAA8B,GAAG,SAAS,CAAA;QACjD,CAAC;QAED;;;WAGG;QACH,KAAK,CAAC,OAAO,KAAK,MAAM,IAAI,CAAC,uBAAuB,CAAC,SAAS,EAAE,CAAA,CAAC,CAAC;QAClE;;;WAGG;QACH,KAAK,CAAC,MAAM,KAAK,MAAM,IAAI,CAAC,uBAAuB,CAAC,KAAK,EAAE,CAAA,CAAC,CAAC;QAC7D;;;;WAIG;QACH,KAAK,CAAC,gCAAgC,KAAI,CAAC;QAC3C;;;;WAIG;QACH,KAAK,CAAC,YAAY,CAAC,GAAG,IAAI,OAAO,MAAM,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA,CAAC,CAAC;QACjG;;;;WAIG;QACH,KAAK,CAAC,mBAAmB,CAAC,GAAG,IAAI,OAAO,MAAM,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA,CAAC,CAAC;QAE/G;;;WAGG;QACH,KAAK,CAAC,uBAAuB;YAC3B,IAAI,CAAC,8BAA8B,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAA;YAClE,MAAM,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC,CAAA;QACxG,CAAC;QAED;;;WAGG;QACH,KAAK,CAAC,wBAAwB;YAC5B,IAAI,CAAC,IAAI,CAAC,8BAA8B;gBAAE,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAA;YAC3G,MAAM,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,wBAAwB,EAAE,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC,CAAA;YACxG,IAAI,CAAC,8BAA8B,GAAG,SAAS,CAAA;QACjD,CAAC;QAED;;;WAGG;QACH,KAAK,CAAC,0BAA0B;YAC9B,IAAI,CAAC,IAAI,CAAC,8BAA8B;gBAAE,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAA;YAC3G,MAAM,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,yBAAyB,EAAE,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC,CAAA;YACzG,IAAI,CAAC,8BAA8B,GAAG,SAAS,CAAA;QACjD,CAAC;QAED;;;;WAIG;QACH,MAAM,CAAC,KAAK;YACV,IAAI,IAAI,CAAC,OAAO,EAAE,KAAK,OAAO;gBAAE,OAAO,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;YAC1D,IAAI,OAAO,KAAK,KAAK,QAAQ;gBAAE,OAAO,KAAK,CAAA;YAC3C,MAAM,OAAO,GAAG,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAA;YAC1D,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;QAC7B,CAAC;QAED;;;;WAIG;QACH,KAAK,CAAC,KAAK;YACT,IAAI,IAAI,CAAC,OAAO,EAAE,KAAK,OAAO;gBAAE,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;YACzD,IAAI,OAAO,KAAK,KAAK,QAAQ;gBAAE,OAAO,KAAK,CAAA;YAC3C,OAAO,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAA;QACnD,CAAC;QAED;;;;;WAKG;QACH,KAAK,CAAC,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,EAAE;YAClC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;YAC3C,KAAK,MAAM,GAAG,IAAI,IAAI;gBAAE,MAAM,GAAG,CAAA;QACnC,CAAC;QAED;;;WAGG;QACH,KAAK,CAAC,mBAAmB,KAAK,OAAO,KAAK,CAAA,CAAC,CAAC;KAC7C;IAED,OAAO,IAAI,4BAA4B,EAAE,CAAA;AAC3C,CAAC","sourcesContent":["/** @typedef {{address?: string, capability?: string, databaseIdentifiers?: string[], expected: boolean}} SharedTransactionBrokerJobConfig */\n\n// @ts-check\n\nimport SharedTransactionBrokerClient from \"./shared-transaction-broker-client.js\"\nimport { AsyncLocalStorage } from \"node:async_hooks\"\n\nexport const SHARED_TRANSACTION_BROKER_ENV = \"VELOCIOUS_TEST_SHARED_TRANSACTION_BROKER\"\nexport const BACKGROUND_JOB_CHILD_ENV = \"VELOCIOUS_BACKGROUND_JOB_CHILD\"\n\n/** @type {AsyncLocalStorage<SharedTransactionBrokerJobConfig>} */\nconst pooledJobBrokerConfig = new AsyncLocalStorage()\n\n/**\n * Runs one pooled job with dispatch-time broker configuration.\n * @template T\n * @param {SharedTransactionBrokerJobConfig} config - Per-job broker mode and coordinates.\n * @param {() => T} callback - Job callback.\n * @returns {T} - Callback result.\n */\nexport function runWithSharedTransactionBrokerConfig(config, callback) {\n  return pooledJobBrokerConfig.run(config, callback)\n}\n\n/**\n * Escapes a PostgreSQL literal without requiring a live child connection.\n * @param {ReturnType<typeof JSON.parse>} value - PostgreSQL literal value.\n * @returns {string} - Quoted literal.\n */\nfunction pgEscapeLiteral(value) {\n  const string = typeof value === \"string\" ? value : String(value)\n  let escaped = \"'\"\n  let hasBackslash = false\n\n  for (const character of string) {\n    if (character === \"'\") escaped += character\n    if (character === \"\\\\\") {\n      escaped += character\n      hasBackslash = true\n    }\n    escaped += character\n  }\n\n  escaped += \"'\"\n  return hasBackslash ? ` E${escaped}` : escaped\n}\n\n/**\n * Parses the test-runner-owned child transport configuration when this logical\n * database is registered for the active attempt.\n * @param {string} databaseIdentifier - Logical database identifier.\n * @returns {{address: string, capability: string} | undefined} - Broker coordinates.\n */\nexport function sharedTransactionBrokerConfig(databaseIdentifier) {\n  const contextualConfig = pooledJobBrokerConfig.getStore()\n  if (contextualConfig) return validatedBrokerConfig(contextualConfig, databaseIdentifier)\n  if (process.env[BACKGROUND_JOB_CHILD_ENV] !== \"1\") return undefined\n\n  const serialized = process.env[SHARED_TRANSACTION_BROKER_ENV]\n  if (!serialized) return undefined\n\n  return validatedBrokerConfig(JSON.parse(Buffer.from(serialized, \"base64url\").toString(\"utf8\")), databaseIdentifier)\n}\n\n/**\n * Validates dispatch-time broker configuration and fails closed when expected.\n * @param {SharedTransactionBrokerJobConfig} config - Candidate configuration.\n * @param {string} databaseIdentifier - Logical database identifier.\n * @returns {{address: string, capability: string} | undefined} - Broker coordinates.\n */\nfunction validatedBrokerConfig(config, databaseIdentifier) {\n  if (config.expected && (!config.address || !config.capability || !config.databaseIdentifiers)) {\n    throw new Error(\"Transactional pooled job expected shared transaction broker coordinates\")\n  }\n  if (!config.expected) return undefined\n  if (typeof config.address !== \"string\" || typeof config.capability !== \"string\" || !Array.isArray(config.databaseIdentifiers)) {\n    throw new Error(\"Invalid shared transaction broker child configuration\")\n  }\n  if (!config.databaseIdentifiers.includes(databaseIdentifier)) {\n    throw new Error(`Transactional pooled job expected broker database identifier: ${databaseIdentifier}`)\n  }\n\n  return {address: config.address, capability: config.capability}\n}\n\n/**\n * Creates a concrete-driver subclass that retains all local SQL/query/model\n * builders while forwarding only physical connection actions to the parent.\n * @param {typeof import(\"../database/drivers/base.js\").default} DriverClass - Configured concrete driver.\n * @param {import(\"../configuration-types.js\").DatabaseConfigurationType} config - Database configuration.\n * @param {import(\"../configuration.js\").default} configuration - Child configuration.\n * @param {string} databaseIdentifier - Logical identifier.\n * @param {{address: string, capability: string}} brokerConfig - Broker coordinates.\n * @returns {import(\"../database/drivers/base.js\").default} - Unconnected physical proxy.\n */\nexport function createSharedTransactionProxyDriver(DriverClass, config, configuration, databaseIdentifier, brokerConfig) {\n  class SharedTransactionProxyDriver extends DriverClass {\n    constructor() {\n      super(config, configuration)\n      this.sharedTransactionClient = new SharedTransactionBrokerClient({...brokerConfig, databaseIdentifier})\n      /** @type {string | undefined} */\n      this.sharedTransactionRootSavePoint = undefined\n    }\n\n    /**\n     * Connects the proxy transport.\n     * @returns {Promise<void>} - Resolves when connected.\n     */\n    async connect() { await this.sharedTransactionClient.connected() }\n    /**\n     * Closes only the proxy transport.\n     * @returns {Promise<void>} - Resolves when closed.\n     */\n    async _close() { await this.sharedTransactionClient.close() }\n    /**\n     * Keeps a broker proxy transport alive across logical MySQL checkouts.\n     * Parent TestRunner owns physical session cleanup and rollback.\n     * @returns {Promise<void>} - Resolves without closing the transport.\n     */\n    async cleanupSessionStateAfterCheckout() {}\n    /**\n     * Routes a physical query.\n     * @param {string} sql - SQL statement.\n     * @returns {Promise<import(\"../database/drivers/base.js\").QueryResultType>} - Rows.\n     */\n    async _queryActual(sql) { return await this.sharedTransactionClient.call(\"_queryActual\", [sql]) }\n    /**\n     * Routes an affected-row query.\n     * @param {string} sql - SQL statement.\n     * @returns {Promise<number>} - Affected rows.\n     */\n    async _affectedRowsActual(sql) { return await this.sharedTransactionClient.call(\"_affectedRowsActual\", [sql]) }\n\n    /**\n     * Starts a child transaction as a parent savepoint.\n     * @returns {Promise<void>} - Resolves when started.\n     */\n    async _startTransactionAction() {\n      this.sharedTransactionRootSavePoint = this.generateSavePointName()\n      await this.sharedTransactionClient.call(\"rootTransactionStart\", [this.sharedTransactionRootSavePoint])\n    }\n\n    /**\n     * Releases the child transaction savepoint.\n     * @returns {Promise<void>} - Resolves when released.\n     */\n    async _commitTransactionAction() {\n      if (!this.sharedTransactionRootSavePoint) throw new Error(\"Shared transaction proxy has no root savepoint\")\n      await this.sharedTransactionClient.call(\"rootTransactionRelease\", [this.sharedTransactionRootSavePoint])\n      this.sharedTransactionRootSavePoint = undefined\n    }\n\n    /**\n     * Rolls back the child transaction savepoint.\n     * @returns {Promise<void>} - Resolves when rolled back.\n     */\n    async _rollbackTransactionAction() {\n      if (!this.sharedTransactionRootSavePoint) throw new Error(\"Shared transaction proxy has no root savepoint\")\n      await this.sharedTransactionClient.call(\"rootTransactionRollback\", [this.sharedTransactionRootSavePoint])\n      this.sharedTransactionRootSavePoint = undefined\n    }\n\n    /**\n     * Escapes a local SQL value.\n     * @param {ReturnType<typeof JSON.parse>} value - SQL value.\n     * @returns {ReturnType<typeof JSON.parse>} - Escaped value.\n     */\n    escape(value) {\n      if (this.getType() !== \"pgsql\") return super.escape(value)\n      if (typeof value === \"number\") return value\n      const escaped = pgEscapeLiteral(this._convertValue(value))\n      return escaped.slice(1, -1)\n    }\n\n    /**\n     * Quotes a local SQL value.\n     * @param {ReturnType<typeof JSON.parse>} value - SQL value.\n     * @returns {string | number} - Quoted value.\n     */\n    quote(value) {\n      if (this.getType() !== \"pgsql\") return super.quote(value)\n      if (typeof value === \"number\") return value\n      return pgEscapeLiteral(this._convertValue(value))\n    }\n\n    /**\n     * Streams brokered rows through the driver's buffered fallback.\n     * @param {string} sql - SQL statement.\n     * @param {import(\"../database/drivers/base.js\").QueryOptions} [options] - Query options.\n     * @yields {Record<string, ReturnType<typeof JSON.parse>>} - Result rows.\n     */\n    async *queryStream(sql, options = {}) {\n      const rows = await this.query(sql, options)\n      for (const row of rows) yield row\n    }\n\n    /**\n     * Keeps structure SQL on normal brokered statements.\n     * @returns {Promise<boolean>} - Always false.\n     */\n    async execStructureScript() { return false }\n  }\n\n  return new SharedTransactionProxyDriver()\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared-transaction-proxy-driver.js","sourceRoot":"","sources":["../../../src/testing/shared-transaction-proxy-driver.js"],"names":[],"mappings":"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","sourcesContent":["/** @typedef {{address?: string, allowDynamicIdentities?: boolean, capability?: string, databaseIdentifiers?: string[], expected: boolean}} SharedTransactionBrokerJobConfig */\n\n// @ts-check\n\nimport SharedTransactionBrokerClient from \"./shared-transaction-broker-client.js\"\nimport { AsyncLocalStorage } from \"node:async_hooks\"\n\nexport const SHARED_TRANSACTION_BROKER_ENV = \"VELOCIOUS_TEST_SHARED_TRANSACTION_BROKER\"\nexport const BACKGROUND_JOB_CHILD_ENV = \"VELOCIOUS_BACKGROUND_JOB_CHILD\"\n\n/** @type {AsyncLocalStorage<SharedTransactionBrokerJobConfig>} */\nconst pooledJobBrokerConfig = new AsyncLocalStorage()\n\n/**\n * Returns the active live broker configuration without validating one database route.\n * @returns {SharedTransactionBrokerJobConfig | undefined} - Active live or child configuration.\n */\nfunction activeSharedTransactionBrokerConfig() {\n  const contextualConfig = pooledJobBrokerConfig.getStore()\n  if (contextualConfig) return contextualConfig\n  if (process.env[BACKGROUND_JOB_CHILD_ENV] !== \"1\") return undefined\n  const serialized = process.env[SHARED_TRANSACTION_BROKER_ENV]\n  if (!serialized) return undefined\n  return JSON.parse(Buffer.from(serialized, \"base64url\").toString(\"utf8\"))\n}\n\n/**\n * Runs one pooled job with dispatch-time broker configuration.\n * @template T\n * @param {SharedTransactionBrokerJobConfig} config - Per-job broker mode and coordinates.\n * @param {() => T} callback - Job callback.\n * @returns {T} - Callback result.\n */\nexport function runWithSharedTransactionBrokerConfig(config, callback) {\n  return pooledJobBrokerConfig.run(config, callback)\n}\n\n/**\n * Checks whether the current live join selects one exact session capability.\n * @param {{address: string, capability: string}} identity - Session control-message identity.\n * @returns {boolean} - Whether this async context belongs to that session.\n */\nexport function sharedTransactionBrokerContextMatches(identity) {\n  const config = pooledJobBrokerConfig.getStore()\n  return config?.expected === true && config.address === identity.address && config.capability === identity.capability\n}\n\n/**\n * Preserves legacy real tenant connections omitted by automatic TestRunner mode.\n * Explicit dynamic sessions never permit this fallback.\n * @param {string} databaseIdentifier - Logical database identifier.\n * @returns {boolean} - Whether an omitted automatic route stays independent.\n */\nexport function automaticSharedTransactionBrokerOmits(databaseIdentifier) {\n  const config = activeSharedTransactionBrokerConfig()\n  return Boolean(\n    config?.expected === true &&\n    !config.allowDynamicIdentities &&\n    typeof config.address === \"string\" &&\n    typeof config.capability === \"string\" &&\n    Array.isArray(config.databaseIdentifiers) &&\n    !config.databaseIdentifiers.includes(databaseIdentifier)\n  )\n}\n\n/**\n * Escapes a PostgreSQL literal without requiring a live child connection.\n * @param {ReturnType<typeof JSON.parse>} value - PostgreSQL literal value.\n * @returns {string} - Quoted literal.\n */\nfunction pgEscapeLiteral(value) {\n  const string = typeof value === \"string\" ? value : String(value)\n  let escaped = \"'\"\n  let hasBackslash = false\n\n  for (const character of string) {\n    if (character === \"'\") escaped += character\n    if (character === \"\\\\\") {\n      escaped += character\n      hasBackslash = true\n    }\n    escaped += character\n  }\n\n  escaped += \"'\"\n  return hasBackslash ? ` E${escaped}` : escaped\n}\n\n/**\n * Parses the test-runner-owned child transport configuration when this logical\n * database is registered for the active attempt.\n * @param {string} databaseIdentifier - Logical database identifier.\n * @returns {{address: string, allowDynamicIdentities?: boolean, capability: string} | undefined} - Broker coordinates.\n */\nexport function sharedTransactionBrokerConfig(databaseIdentifier) {\n  const config = activeSharedTransactionBrokerConfig()\n  if (!config) return undefined\n  return validatedBrokerConfig(config, databaseIdentifier)\n}\n\n/**\n * Validates dispatch-time broker configuration and fails closed when expected.\n * @param {SharedTransactionBrokerJobConfig} config - Candidate configuration.\n * @param {string} databaseIdentifier - Logical database identifier.\n * @returns {{address: string, allowDynamicIdentities?: boolean, capability: string} | undefined} - Broker coordinates.\n */\nfunction validatedBrokerConfig(config, databaseIdentifier) {\n  if (config.expected && (!config.address || !config.capability || !config.databaseIdentifiers)) {\n    throw new Error(\"Transactional pooled job expected shared transaction broker coordinates\")\n  }\n  if (!config.expected) return undefined\n  if (typeof config.address !== \"string\" || typeof config.capability !== \"string\" || !Array.isArray(config.databaseIdentifiers)) {\n    throw new Error(\"Invalid shared transaction broker child configuration\")\n  }\n  if (!config.allowDynamicIdentities && !config.databaseIdentifiers.includes(databaseIdentifier)) {\n    throw new Error(`Transactional pooled job expected broker database identifier: ${databaseIdentifier}`)\n  }\n\n  if (config.allowDynamicIdentities) {\n    return {address: config.address, allowDynamicIdentities: true, capability: config.capability}\n  }\n  return {address: config.address, capability: config.capability}\n}\n\n/**\n * Creates a concrete-driver subclass that retains all local SQL/query/model\n * builders while forwarding only physical connection actions to the parent.\n * @param {typeof import(\"../database/drivers/base.js\").default} DriverClass - Configured concrete driver.\n * @param {import(\"../configuration-types.js\").DatabaseConfigurationType} config - Database configuration.\n * @param {import(\"../configuration.js\").default} configuration - Child configuration.\n * @param {string} databaseIdentifier - Logical identifier.\n * @param {{address: string, capability: string, reuseKey?: string}} brokerConfig - Broker coordinates.\n * @returns {import(\"../database/drivers/base.js\").default} - Unconnected physical proxy.\n */\nexport function createSharedTransactionProxyDriver(DriverClass, config, configuration, databaseIdentifier, brokerConfig) {\n  class SharedTransactionProxyDriver extends DriverClass {\n    constructor() {\n      super(config, configuration)\n      this.sharedTransactionClient = new SharedTransactionBrokerClient({...brokerConfig, databaseIdentifier})\n      /** @type {string | undefined} */\n      this.sharedTransactionRootSavePoint = undefined\n    }\n\n    /**\n     * Connects the proxy transport.\n     * @returns {Promise<void>} - Resolves when connected.\n     */\n    async connect() { await this.sharedTransactionClient.connected() }\n    /**\n     * Closes only the proxy transport.\n     * @returns {Promise<void>} - Resolves when closed.\n     */\n    async _close() { await this.sharedTransactionClient.close() }\n    /**\n     * Keeps a broker proxy transport alive across logical MySQL checkouts.\n     * Parent TestRunner owns physical session cleanup and rollback.\n     * @returns {Promise<void>} - Resolves without closing the transport.\n     */\n    async cleanupSessionStateAfterCheckout() {}\n    /**\n     * Routes a physical query.\n     * @param {string} sql - SQL statement.\n     * @returns {Promise<import(\"../database/drivers/base.js\").QueryResultType>} - Rows.\n     */\n    async _queryActual(sql) { return await this.sharedTransactionClient.call(\"_queryActual\", [sql]) }\n    /**\n     * Routes an affected-row query.\n     * @param {string} sql - SQL statement.\n     * @returns {Promise<number>} - Affected rows.\n     */\n    async _affectedRowsActual(sql) { return await this.sharedTransactionClient.call(\"_affectedRowsActual\", [sql]) }\n\n    /**\n     * Starts a child transaction as a parent savepoint.\n     * @returns {Promise<void>} - Resolves when started.\n     */\n    async _startTransactionAction() {\n      this.sharedTransactionRootSavePoint = this.generateSavePointName()\n      await this.sharedTransactionClient.call(\"rootTransactionStart\", [this.sharedTransactionRootSavePoint])\n    }\n\n    /**\n     * Releases the child transaction savepoint.\n     * @returns {Promise<void>} - Resolves when released.\n     */\n    async _commitTransactionAction() {\n      if (!this.sharedTransactionRootSavePoint) throw new Error(\"Shared transaction proxy has no root savepoint\")\n      await this.sharedTransactionClient.call(\"rootTransactionRelease\", [this.sharedTransactionRootSavePoint])\n      this.sharedTransactionRootSavePoint = undefined\n    }\n\n    /**\n     * Rolls back the child transaction savepoint.\n     * @returns {Promise<void>} - Resolves when rolled back.\n     */\n    async _rollbackTransactionAction() {\n      if (!this.sharedTransactionRootSavePoint) throw new Error(\"Shared transaction proxy has no root savepoint\")\n      await this.sharedTransactionClient.call(\"rootTransactionRollback\", [this.sharedTransactionRootSavePoint])\n      this.sharedTransactionRootSavePoint = undefined\n    }\n\n    /**\n     * Escapes a local SQL value.\n     * @param {ReturnType<typeof JSON.parse>} value - SQL value.\n     * @returns {ReturnType<typeof JSON.parse>} - Escaped value.\n     */\n    escape(value) {\n      if (this.getType() !== \"pgsql\") return super.escape(value)\n      if (typeof value === \"number\") return value\n      const escaped = pgEscapeLiteral(this._convertValue(value))\n      return escaped.slice(1, -1)\n    }\n\n    /**\n     * Quotes a local SQL value.\n     * @param {ReturnType<typeof JSON.parse>} value - SQL value.\n     * @returns {string | number} - Quoted value.\n     */\n    quote(value) {\n      if (this.getType() !== \"pgsql\") return super.quote(value)\n      if (typeof value === \"number\") return value\n      return pgEscapeLiteral(this._convertValue(value))\n    }\n\n    /**\n     * Streams brokered rows through the driver's buffered fallback.\n     * @param {string} sql - SQL statement.\n     * @param {import(\"../database/drivers/base.js\").QueryOptions} [options] - Query options.\n     * @yields {Record<string, ReturnType<typeof JSON.parse>>} - Result rows.\n     */\n    async *queryStream(sql, options = {}) {\n      const rows = await this.query(sql, options)\n      for (const row of rows) yield row\n    }\n\n    /**\n     * Keeps structure SQL on normal brokered statements.\n     * @returns {Promise<boolean>} - Always false.\n     */\n    async execStructureScript() { return false }\n  }\n\n  return new SharedTransactionProxyDriver()\n}\n"]}

package/build/src/testing/test-transaction-session.d.ts

@@ -0,0 +1,129 @@
+import SharedTransactionBroker from "./shared-transaction-broker.js";
+export type Enrollment = {
+    connection: import("../database/drivers/base.js").default;
+    databaseIdentifier: string;
+    release: () => Promise<void>;
+    reuseKey: string;
+};
+/** @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 {
+    configuration: import("../configuration.js").default | undefined;
+    /** @type {SharedTransactionBroker | undefined} */
+    broker: SharedTransactionBroker | undefined;
+    /** @type {Map<string, Enrollment>} */
+    enrollments: Map<string, Enrollment>;
+    /** @type {Map<string, {pool: import("../database/pool/base.js").default, registration: import("../database/pool/base.js").TestSharedConnectionRegistration}>} */
+    sharedConnectionRegistrations: Map<string, {
+        pool: import("../database/pool/base.js").default;
+        registration: import("../database/pool/base.js").TestSharedConnectionRegistration;
+    }>;
+    /** @type {Promise<void> | undefined} */
+    cleanupPromise: Promise<void> | undefined;
+    /** @type {Promise<void> | undefined} */
+    rollbackPromise: Promise<void> | undefined;
+    /**
+     * Creates an unstarted transaction session.
+     * @param {import("../configuration.js").default} [configuration] - Backend configuration owning enrolled pools.
+     */
+    constructor(configuration?: import("../configuration.js").default);
+    /**
+     * Begins a test transaction session.
+     * @param {{configuration?: import("../configuration.js").default}} [args] - Backend owner.
+     * @returns {Promise<TestTransactionSession>} - Begun session.
+     */
+    static begin({ configuration }?: {
+        configuration?: import("../configuration.js").default;
+    }): Promise<TestTransactionSession>;
+    /**
+     * 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<T>(message: {
+        address: string;
+        capability: string;
+    }, callback: () => T): T;
+    /**
+     * Lazily adds an exact physical connection to the common rollback set.
+     * @param {Enrollment} enrollment - Checked-out physical connection and owner release hook.
+     */
+    enroll(enrollment: Enrollment): Promise<void>;
+    /**
+     * Lazily checks out and enrolls the physical database selected by a tenant descriptor.
+     * @param {{databaseIdentifier: string, tenant?: object}} args - Logical and tenant identity.
+     */
+    enrollDatabase({ databaseIdentifier, tenant }: {
+        databaseIdentifier: string;
+        tenant?: object;
+    }): Promise<void>;
+    /**
+     * 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: string, pool: import("../database/pool/base.js").default): void;
+    /**
+     * Returns ephemeral coordinates for one live IPC/control message.
+     * @returns {{address: string, capability: string}} - Non-durable join coordinates.
+     */
+    joinMessage(): {
+        address: string;
+        capability: string;
+    };
+    /** Stops admission to the capability. */
+    revoke(): void;
+    /** Drains work accepted before revocation. */
+    drain(): Promise<void>;
+    /**
+     * Rolls back and releases the complete enrolled set after admission stops.
+     * @returns {Promise<void>} - Resolves after rollback and release.
+     */
+    rollback(): Promise<void>;
+    /**
+     * Performs rollback and release once.
+     * @returns {Promise<void>} - Resolves after actual rollback and release.
+     */
+    rollbackActual(): Promise<void>;
+    /**
+     * Revokes, drains, rolls back, and releases every enrolled physical connection exactly once.
+     * @returns {Promise<void>} - Resolves after idempotent cleanup.
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Performs idempotent cleanup once.
+     * @returns {Promise<void>} - Resolves after actual cleanup.
+     */
+    cleanupActual(): Promise<void>;
+    /**
+     * Returns capability-free session diagnostics.
+     * @returns {{accepting: boolean, enrollmentCount: number}} - Capability-free diagnostics.
+     */
+    debugSnapshot(): {
+        accepting: boolean;
+        enrollmentCount: number;
+    };
+    /**
+     * Returns the begun broker.
+     * @returns {SharedTransactionBroker} - Begun broker.
+     */
+    requiredBroker(): SharedTransactionBroker;
+    /**
+     * Rolls back and releases one owned physical connection.
+     * @param {Enrollment} enrollment - Owned physical connection.
+     * @returns {Promise<void>} - Resolves after rollback and release.
+     */
+    rollbackAndRelease(enrollment: Enrollment): Promise<void>;
+    /**
+     * Normalizes a thrown cleanup value.
+     * @param {unknown} error - Opaque thrown cleanup value narrowed at this boundary.
+     * @returns {Error} - Error instance.
+     */
+    normalizeError(error: unknown): Error;
+}
+//# sourceMappingURL=test-transaction-session.d.ts.map

package/build/src/testing/test-transaction-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-transaction-session.d.ts","sourceRoot":"","sources":["../../../src/testing/test-transaction-session.js"],"names":[],"mappings":"AAEA,OAAO,uBAAuB,MAAM,gCAAgC,CAAA;AAGhE,YAAmJ,UAAU,GAAnJ;IAAC,UAAU,EAAE,OAAO,6BAA6B,EAAE,OAAO,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAAY;AAAjK,oKAAoK;AAEpK;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,sBAAsB;IAMlC,aAAa;IAClB,kDAAkD;IAC7C,MAAM,EADA,uBAAuB,GAAG,SAAS;IAE9C,sCAAsC;IACjC,WAAW,EADL,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC;IAElC,iKAAiK;IAC5J,6BAA6B,EADvB,GAAG,CAAC,MAAM,EAAE;QAAC,IAAI,EAAE,OAAO,0BAA0B,EAAE,OAAO,CAAC;QAAC,YAAY,EAAE,OAAO,0BAA0B,EAAE,gCAAgC,CAAA;KAAC,CAAC;IAE7J,wCAAwC;IACnC,cAAc,EADR,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS;IAEpC,wCAAwC;IACnC,eAAe,EADT,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS;IAdtC;;;OAGG;IACH,YAAY,aAAa,AAFtB,CACF,EADU,OAAO,qBAAqB,EAAE,OAEhB,EAYxB;IAED;;;;OAIG;IACH,OAAa,KAAK,CAAC,EAAC,aAAa,EAAC,AAH/B,CACA,EADQ;QAAC,aAAa,CAAC,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAA;KAG1B,GAF1B,OAAO,CAAC,sBAAsB,CAAC,CAM3C;IAED;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,CALE,CAAC,EAKF,OAAO,EAJR;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAI5B,EAAE,QAAQ,EAHlB,MAAM,CAGY,GAFhB,CAAC,CAIb;IAED;;;OAGG;IACG,MAAM,CAAC,UAAU,EAFZ,UAEY,iBAkCtB;IAED;;;OAGG;IACG,cAAc,CAAC,EAAC,kBAAkB,EAAE,MAAM,EAAC,EAFtC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAEN,iBAiBhD;IAED;;;;OAIG;IACH,+BAA+B,CAAC,kBAAkB,EAHvC,MAGuC,EAAE,IAAI,EAF7C,OAAO,0BAA0B,EAAE,OAEU,QAevD;IAED;;;OAGG;IACH,WAAW,IAFE;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAMjD;IAED,yCAAyC;IACzC,MAAM,SAAqC;IAE3C,8CAA8C;IACxC,KAAK,kBAA0C;IAErD;;;OAGG;IACG,QAAQ,IAFD,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;OAGG;IACG,cAAc,IAFP,OAAO,CAAC,IAAI,CAAC,CAiBzB;IAED;;;OAGG;IACG,OAAO,IAFA,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;OAGG;IACG,aAAa,IAFN,OAAO,CAAC,IAAI,CAAC,CAKzB;IAED;;;OAGG;IACH,aAAa,IAFA;QAAC,SAAS,EAAE,OAAO,CAAC;QAAC,eAAe,EAAE,MAAM,CAAA;KAAC,CAIzD;IAED;;;OAGG;IACH,cAAc,IAFD,uBAAuB,CAKnC;IAED;;;;OAIG;IACG,kBAAkB,CAAC,UAAU,EAHxB,UAGwB,GAFtB,OAAO,CAAC,IAAI,CAAC,CAQzB;IAED;;;;OAIG;IACH,cAAc,CAAC,KAAK,EAHT,OAGS,GAFP,KAAK,CAEwE;CAC3F"}

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":"AAAA,YAAY;AAEZ,OAAO,uBAAuB,MAAM,gCAAgC,CAAA;AACpE,OAAO,EAAE,oCAAoC,EAAE,qCAAqC,EAAE,MAAM,sCAAsC,CAAA;AAElI,oKAAoK;AAEpK;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,sBAAsB;IACzC;;;OAGG;IACH,YAAY,aAAa;QACvB,IAAI,CAAC,aAAa,GAAG,aAAa,CAAA;QAClC,kDAAkD;QAClD,IAAI,CAAC,MAAM,GAAG,SAAS,CAAA;QACvB,sCAAsC;QACtC,IAAI,CAAC,WAAW,GAAG,IAAI,GAAG,EAAE,CAAA;QAC5B,iKAAiK;QACjK,IAAI,CAAC,6BAA6B,GAAG,IAAI,GAAG,EAAE,CAAA;QAC9C,wCAAwC;QACxC,IAAI,CAAC,cAAc,GAAG,SAAS,CAAA;QAC/B,wCAAwC;QACxC,IAAI,CAAC,eAAe,GAAG,SAAS,CAAA;IAClC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,EAAC,aAAa,EAAC,GAAG,EAAE;QACrC,MAAM,OAAO,GAAG,IAAI,sBAAsB,CAAC,aAAa,CAAC,CAAA;QACzD,OAAO,CAAC,MAAM,GAAG,MAAM,uBAAuB,CAAC,KAAK,CAAC,EAAC,WAAW,EAAE,EAAE,EAAC,CAAC,CAAA;QACvE,OAAO,OAAO,CAAA;IAChB,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ;QAC3B,OAAO,oCAAoC,CAAC,EAAC,GAAG,OAAO,EAAE,sBAAsB,EAAE,IAAI,EAAE,mBAAmB,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAC,EAAE,QAAQ,CAAC,CAAA;IAC5I,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,MAAM,CAAC,UAAU;QACrB,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,EAAE,CAAA;QACpC,MAAM,QAAQ,GAAG,GAAG,UAAU,CAAC,kBAAkB,KAAK,UAAU,CAAC,QAAQ,EAAE,CAAA;QAC3E,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;QAC/C,IAAI,QAAQ,EAAE,CAAC;YACb,IAAI,QAAQ,CAAC,UAAU,KAAK,UAAU,CAAC,UAAU;gBAAE,MAAM,UAAU,CAAC,OAAO,EAAE,CAAA;YAC7E,OAAM;QACR,CAAC;QACD,IAAI,CAAC;YACH,MAAM,UAAU,CAAC,UAAU,CAAC,gBAAgB,EAAE,CAAA;QAChD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,gCAAgC;YAChC,IAAI,cAAc,CAAA;YAClB,IAAI,CAAC;gBACH,MAAM,UAAU,CAAC,OAAO,EAAE,CAAA;YAC5B,CAAC;YAAC,OAAO,YAAY,EAAE,CAAC;gBACtB,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,CAAA;YACpD,CAAC;YACD,IAAI,cAAc,EAAE,CAAC;gBACnB,MAAM,IAAI,cAAc,CACtB,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC,EAC5C,sDAAsD,EACtD,EAAC,KAAK,EAAE,KAAK,EAAC,CACf,CAAA;YACH,CAAC;YACD,MAAM,KAAK,CAAA;QACb,CAAC;QACD,IAAI,CAAC;YACH,MAAM,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAA;YACnC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAA;QAC5C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAA;YACzC,MAAM,KAAK,CAAA;QACb,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,cAAc,CAAC,EAAC,kBAAkB,EAAE,MAAM,EAAC;QAC/C,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,MAAM,IAAI,KAAK,CAAC,wEAAwE,CAAC,CAAA;QAClH,MAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAA;QACnE,MAAM,qBAAqB,GAAG,IAAI,CAAC,aAAa,CAAC,4BAA4B,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAA;QACzG,MAAM,QAAQ,GAAG,IAAI,CAAC,wBAAwB,CAAC,qBAAqB,CAAC,CAAA;QACrE,MAAM,QAAQ,GAAG,GAAG,kBAAkB,KAAK,QAAQ,EAAE,CAAA;QACrD,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC;YAAE,OAAM;QAC1C,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,MAAM,EAAE,KAAK,IAAI,EAAE;YAC3E,OAAO,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAC,IAAI,EAAE,0BAA0B,EAAC,CAAC,CAAA;QAChE,CAAC,CAAC,CAAA;QACF,MAAM,IAAI,CAAC,MAAM,CAAC;YAChB,UAAU;YACV,kBAAkB;YAClB,OAAO,EAAE,KAAK,IAAI,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA,CAAC,CAAC;YACvD,QAAQ;SACT,CAAC,CAAA;QACF,IAAI,CAAC,+BAA+B,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAA;IAChE,CAAC;IAED;;;;OAIG;IACH,+BAA+B,CAAC,kBAAkB,EAAE,IAAI;QACtD,IAAI,IAAI,CAAC,6BAA6B,CAAC,GAAG,CAAC,kBAAkB,CAAC;YAAE,OAAM;QACtE,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,EAAE,CAAA;QACpC,MAAM,eAAe,GAAG,EAAC,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,EAAC,CAAA;QACpF,MAAM,YAAY,GAAG,IAAI,CAAC,oCAAoC,CAAC;YAC7D,OAAO,EAAE,GAAG,EAAE,CAAC,qCAAqC,CAAC,eAAe,CAAC;YACrE,QAAQ,EAAE,GAAG,EAAE;gBACb,IAAI,CAAC,MAAM,CAAC,SAAS;oBAAE,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAA;gBAC9F,MAAM,QAAQ,GAAG,IAAI,CAAC,wBAAwB,EAAE,CAAA;gBAChD,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,kBAAkB,KAAK,QAAQ,EAAE,CAAC,EAAE,UAAU,CAAA;gBACzF,IAAI,CAAC,UAAU;oBAAE,MAAM,IAAI,KAAK,CAAC,uDAAuD,kBAAkB,EAAE,CAAC,CAAA;gBAC7G,OAAO,UAAU,CAAA;YACnB,CAAC;SACF,CAAC,CAAA;QACF,IAAI,YAAY;YAAE,IAAI,CAAC,6BAA6B,CAAC,GAAG,CAAC,kBAAkB,EAAE,EAAC,IAAI,EAAE,YAAY,EAAC,CAAC,CAAA;IACpG,CAAC;IAED;;;OAGG;IACH,WAAW;QACT,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,EAAE,CAAA;QACpC,IAAI,CAAC,MAAM,CAAC,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAA;QAC9F,OAAO,EAAC,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,EAAC,CAAA;IACrE,CAAC;IAED,yCAAyC;IACzC,MAAM,KAAK,IAAI,CAAC,cAAc,EAAE,CAAC,MAAM,EAAE,CAAA,CAAC,CAAC;IAE3C,8CAA8C;IAC9C,KAAK,CAAC,KAAK,KAAK,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,CAAA,CAAC,CAAC;IAErD;;;OAGG;IACH,KAAK,CAAC,QAAQ;QACZ,IAAI,IAAI,CAAC,eAAe;YAAE,OAAO,MAAM,IAAI,CAAC,eAAe,CAAA;QAC3D,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,cAAc,EAAE,CAAA;QAC5C,OAAO,MAAM,IAAI,CAAC,eAAe,CAAA;IACnC,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,cAAc;QAClB,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,EAAE,CAAA;QACpC,IAAI,MAAM,CAAC,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAA;QACjG,2BAA2B;QAC3B,MAAM,MAAM,GAAG,EAAE,CAAA;QACjB,IAAI,CAAC;YAAC,MAAM,MAAM,CAAC,KAAK,EAAE,CAAA;QAAC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAA;QAAC,CAAC;QACtF,KAAK,MAAM,EAAC,IAAI,EAAE,YAAY,EAAC,IAAI,IAAI,CAAC,6BAA6B,CAAC,MAAM,EAAE,EAAE,CAAC;YAC/E,IAAI,CAAC,yBAAyB,CAAC,YAAY,CAAC,CAAA;QAC9C,CAAC;QACD,IAAI,CAAC,6BAA6B,CAAC,KAAK,EAAE,CAAA;QAC1C,KAAK,MAAM,UAAU,IAAI,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC;YACnD,IAAI,CAAC;gBAAC,MAAM,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAA;YAAC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAA;YAAC,CAAC;QAC7G,CAAC;QACD,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAA;QACxB,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,IAAI,cAAc,CAAC,MAAM,EAAE,0CAA0C,CAAC,CAAA;IACrG,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,OAAO;QACX,IAAI,IAAI,CAAC,cAAc;YAAE,OAAO,MAAM,IAAI,CAAC,cAAc,CAAA;QACzD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,aAAa,EAAE,CAAA;QAC1C,OAAO,MAAM,IAAI,CAAC,cAAc,CAAA;IAClC,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,aAAa;QACjB,IAAI,CAAC,MAAM,EAAE,CAAA;QACb,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAA;IACvB,CAAC;IAED;;;OAGG;IACH,aAAa;QACX,OAAO,EAAC,SAAS,EAAE,IAAI,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,EAAE,eAAe,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,EAAC,CAAA;IAC7F,CAAC;IAED;;;OAGG;IACH,cAAc;QACZ,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAA;QAC3E,OAAO,IAAI,CAAC,MAAM,CAAA;IACpB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,kBAAkB,CAAC,UAAU;QACjC,2BAA2B;QAC3B,MAAM,MAAM,GAAG,EAAE,CAAA;QACjB,IAAI,CAAC;YAAC,MAAM,UAAU,CAAC,UAAU,CAAC,mBAAmB,EAAE,CAAA;QAAC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAA;QAAC,CAAC;QACnH,IAAI,CAAC;YAAC,MAAM,UAAU,CAAC,OAAO,EAAE,CAAA;QAAC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAA;QAAC,CAAC;QAC5F,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,IAAI,cAAc,CAAC,MAAM,EAAE,4CAA4C,CAAC,CAAA;IACvG,CAAC;IAED;;;;OAIG;IACH,cAAc,CAAC,KAAK,IAAI,OAAO,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA,CAAC,CAAC;CAC3F","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"]}