velocious 1.0.618 → 1.0.620

package/build/src/testing/shared-transaction-connection-coordinator.js

@@ -1,15 +1,26 @@
 // @ts-check
-/** @typedef {{coordinator: (callback: () => Promise<unknown>) => Promise<unknown>, ownedQueue: Promise<void>, owner: symbol}} CoordinatorRegistration */
+/** @typedef {{coordinator: (callback: () => Promise<unknown>) => Promise<unknown>, ownedQueue: Promise<void>, owner: symbol, reentrantOwners: Set<symbol>, rootOwners: Set<symbol>}} CoordinatorRegistration */
 /** @type {WeakMap<object, CoordinatorRegistration>} */
 const coordinators = new WeakMap();
+/** @type {WeakMap<object, CoordinatorRegistration>} */
+const connectionRegistrations = new WeakMap();
+/**
+ * Runs work directly when only the connection-local queue remains registered.
+ * @param {() => Promise<unknown>} callback - Serialized operation.
+ * @returns {Promise<unknown>} - Operation result.
+ */
+async function inactiveCoordinator(callback) {
+    return await callback();
+}
 /**
  * Serializes sibling work that inherited one coordinator owner without re-entering the broker queue.
  * @template T
+ * @param {import("../database/drivers/base.js").default} connection - Parent physical connection.
  * @param {CoordinatorRegistration} registration - Physical connection registration.
  * @param {() => Promise<T>} callback - Owned operation.
  * @returns {Promise<T>} - Operation result.
  */
-async function coordinateOwnedSharedTransactionConnection(registration, callback) {
+async function coordinateOwnedSharedTransactionConnection(connection, registration, callback) {
     const previous = registration.ownedQueue;
     /**
      * Releases the next owned sibling operation.
@@ -18,13 +29,50 @@ async function coordinateOwnedSharedTransactionConnection(registration, callback
     let release = () => { };
     registration.ownedQueue = new Promise((resolve) => { release = resolve; });
     await previous;
+    const operationOwner = Symbol("shared-transaction-owned-operation");
+    const environmentHandler = connection.configuration.getEnvironmentHandler();
+    registration.reentrantOwners.add(operationOwner);
     try {
-        return await callback();
+        return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, operationOwner, callback);
     }
     finally {
+        registration.reentrantOwners.delete(operationOwner);
         release();
     }
 }
+/**
+ * Drains all inherited operations admitted before the root owner is revoked.
+ * @param {CoordinatorRegistration} registration - Physical connection registration.
+ * @returns {Promise<void>} - Resolves when the owned queue stops advancing.
+ */
+async function drainOwnedSharedTransactionConnections(registration) {
+    let tail;
+    do {
+        tail = registration.ownedQueue;
+        await tail;
+    } while (tail !== registration.ownedQueue);
+}
+/**
+ * Runs one broker-serialized root while tracking and draining its inherited work.
+ * @template T
+ * @param {import("../database/drivers/base.js").default} connection - Parent physical connection.
+ * @param {CoordinatorRegistration} registration - Physical connection registration.
+ * @param {() => Promise<T>} callback - Root operation.
+ * @returns {Promise<T>} - Operation result.
+ */
+async function coordinateRootSharedTransactionConnection(connection, registration, callback) {
+    await drainOwnedSharedTransactionConnections(registration);
+    const rootOwner = Symbol("shared-transaction-root-operation");
+    const environmentHandler = connection.configuration.getEnvironmentHandler();
+    registration.rootOwners.add(rootOwner);
+    try {
+        return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, rootOwner, callback);
+    }
+    finally {
+        await drainOwnedSharedTransactionConnections(registration);
+        registration.rootOwners.delete(rootOwner);
+    }
+}
 /**
  * Registers test-only serialization owned by the active broker.
  * @param {object} connection - Parent physical connection.
@@ -33,7 +81,16 @@ async function coordinateOwnedSharedTransactionConnection(registration, callback
  */
 export function setSharedTransactionCoordinator(connection, coordinator) {
     const owner = Symbol("shared-transaction-coordinator");
-    coordinators.set(connection, { coordinator, ownedQueue: Promise.resolve(), owner });
+    let registration = connectionRegistrations.get(connection);
+    if (registration) {
+        registration.coordinator = coordinator;
+        registration.owner = owner;
+    }
+    else {
+        registration = { coordinator, ownedQueue: Promise.resolve(), owner, reentrantOwners: new Set(), rootOwners: new Set() };
+        connectionRegistrations.set(connection, registration);
+    }
+    coordinators.set(connection, registration);
     return owner;
 }
 /**
@@ -43,8 +100,11 @@ export function setSharedTransactionCoordinator(connection, coordinator) {
  * @returns {void}
  */
 export function clearSharedTransactionCoordinator(connection, coordinator) {
-    if (coordinators.get(connection)?.coordinator === coordinator)
+    const registration = coordinators.get(connection);
+    if (registration?.coordinator === coordinator) {
         coordinators.delete(connection);
+        registration.coordinator = inactiveCoordinator;
+    }
 }
 /**
  * Runs parent work through broker serialization when registered.
@@ -55,17 +115,24 @@ export function clearSharedTransactionCoordinator(connection, coordinator) {
  * @returns {Promise<T>} - Operation result.
  */
 export async function coordinateSharedTransactionConnection(connection, callback, operationOwner) {
-    const registration = coordinators.get(connection);
+    const activeRegistration = coordinators.get(connection);
+    const registration = activeRegistration || connectionRegistrations.get(connection);
     if (!registration)
         return await callback();
-    if (operationOwner === registration.owner)
-        return await callback();
     const environmentHandler = connection.configuration.getEnvironmentHandler();
-    if (environmentHandler.getSharedTransactionCoordinatorOwner(connection) === registration.owner) {
-        return await coordinateOwnedSharedTransactionConnection(registration, callback);
+    const currentOwner = environmentHandler.getSharedTransactionCoordinatorOwner(connection);
+    if (currentOwner && registration.reentrantOwners.has(currentOwner))
+        return await callback();
+    if (currentOwner && registration.rootOwners.has(currentOwner)) {
+        return await coordinateOwnedSharedTransactionConnection(connection, registration, callback);
+    }
+    if (!activeRegistration)
+        return await coordinateOwnedSharedTransactionConnection(connection, registration, callback);
+    if (operationOwner === registration.owner) {
+        return await coordinateRootSharedTransactionConnection(connection, registration, callback);
     }
     return /** @type {T} */ (await registration.coordinator(async () => {
-        return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, registration.owner, callback);
+        return await coordinateRootSharedTransactionConnection(connection, registration, callback);
     }));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared-transaction-connection-coordinator.js","sourceRoot":"","sources":["../../../src/testing/shared-transaction-connection-coordinator.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/** @typedef {{coordinator: (callback: () => Promise<unknown>) => Promise<unknown>, ownedQueue: Promise<void>, owner: symbol, reentrantOwners: Set<symbol>, rootOwners: Set<symbol>}} CoordinatorRegistration */\n\n/** @type {WeakMap<object, CoordinatorRegistration>} */\nconst coordinators = new WeakMap()\n/** @type {WeakMap<object, CoordinatorRegistration>} */\nconst connectionRegistrations = new WeakMap()\n\n/**\n * Runs work directly when only the connection-local queue remains registered.\n * @param {() => Promise<unknown>} callback - Serialized operation.\n * @returns {Promise<unknown>} - Operation result.\n */\nasync function inactiveCoordinator(callback) {\n  return await callback()\n}\n\n/**\n * Serializes sibling work that inherited one coordinator owner without re-entering the broker queue.\n * @template T\n * @param {import(\"../database/drivers/base.js\").default} connection - Parent physical connection.\n * @param {CoordinatorRegistration} registration - Physical connection registration.\n * @param {() => Promise<T>} callback - Owned operation.\n * @returns {Promise<T>} - Operation result.\n */\nasync function coordinateOwnedSharedTransactionConnection(connection, registration, callback) {\n  const previous = registration.ownedQueue\n  /**\n   * Releases the next owned sibling operation.\n   * @type {() => void}\n   */\n  let release = () => {}\n\n  registration.ownedQueue = new Promise((resolve) => { release = resolve })\n  await previous\n  const operationOwner = Symbol(\"shared-transaction-owned-operation\")\n  const environmentHandler = connection.configuration.getEnvironmentHandler()\n\n  registration.reentrantOwners.add(operationOwner)\n  try {\n    return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, operationOwner, callback)\n  } finally {\n    registration.reentrantOwners.delete(operationOwner)\n    release()\n  }\n}\n\n/**\n * Drains all inherited operations admitted before the root owner is revoked.\n * @param {CoordinatorRegistration} registration - Physical connection registration.\n * @returns {Promise<void>} - Resolves when the owned queue stops advancing.\n */\nasync function drainOwnedSharedTransactionConnections(registration) {\n  let tail\n\n  do {\n    tail = registration.ownedQueue\n    await tail\n  } while (tail !== registration.ownedQueue)\n}\n\n/**\n * Runs one broker-serialized root while tracking and draining its inherited work.\n * @template T\n * @param {import(\"../database/drivers/base.js\").default} connection - Parent physical connection.\n * @param {CoordinatorRegistration} registration - Physical connection registration.\n * @param {() => Promise<T>} callback - Root operation.\n * @returns {Promise<T>} - Operation result.\n */\nasync function coordinateRootSharedTransactionConnection(connection, registration, callback) {\n  await drainOwnedSharedTransactionConnections(registration)\n  const rootOwner = Symbol(\"shared-transaction-root-operation\")\n  const environmentHandler = connection.configuration.getEnvironmentHandler()\n\n  registration.rootOwners.add(rootOwner)\n  try {\n    return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, rootOwner, callback)\n  } finally {\n    await drainOwnedSharedTransactionConnections(registration)\n    registration.rootOwners.delete(rootOwner)\n  }\n}\n\n/**\n * Registers test-only serialization owned by the active broker.\n * @param {object} connection - Parent physical connection.\n * @param {(callback: () => Promise<unknown>) => Promise<unknown>} coordinator - Serializer.\n * @returns {symbol} - Opaque owner for broker-internal connection calls.\n */\nexport function setSharedTransactionCoordinator(connection, coordinator) {\n  const owner = Symbol(\"shared-transaction-coordinator\")\n  let registration = connectionRegistrations.get(connection)\n\n  if (registration) {\n    registration.coordinator = coordinator\n    registration.owner = owner\n  } else {\n    registration = {coordinator, ownedQueue: Promise.resolve(), owner, reentrantOwners: new Set(), rootOwners: new Set()}\n    connectionRegistrations.set(connection, registration)\n  }\n\n  coordinators.set(connection, registration)\n  return owner\n}\n\n/**\n * Removes a broker-owned coordinator without disturbing a replacement.\n * @param {object} connection - Parent physical connection.\n * @param {(callback: () => Promise<unknown>) => Promise<unknown>} coordinator - Expected serializer.\n * @returns {void}\n */\nexport function clearSharedTransactionCoordinator(connection, coordinator) {\n  const registration = coordinators.get(connection)\n\n  if (registration?.coordinator === coordinator) {\n    coordinators.delete(connection)\n    registration.coordinator = inactiveCoordinator\n  }\n}\n\n/**\n * Runs parent work through broker serialization when registered.\n * @template T\n * @param {import(\"../database/drivers/base.js\").default} connection - Parent physical connection.\n * @param {() => Promise<T>} callback - Parent operation.\n * @param {symbol} [operationOwner] - Broker owner for an already-coordinated operation.\n * @returns {Promise<T>} - Operation result.\n */\nexport async function coordinateSharedTransactionConnection(connection, callback, operationOwner) {\n  const activeRegistration = coordinators.get(connection)\n  const registration = activeRegistration || connectionRegistrations.get(connection)\n\n  if (!registration) return await callback()\n\n  const environmentHandler = connection.configuration.getEnvironmentHandler()\n  const currentOwner = environmentHandler.getSharedTransactionCoordinatorOwner(connection)\n\n  if (currentOwner && registration.reentrantOwners.has(currentOwner)) return await callback()\n  if (currentOwner && registration.rootOwners.has(currentOwner)) {\n    return await coordinateOwnedSharedTransactionConnection(connection, registration, callback)\n  }\n  if (!activeRegistration) return await coordinateOwnedSharedTransactionConnection(connection, registration, callback)\n  if (operationOwner === registration.owner) {\n    return await coordinateRootSharedTransactionConnection(connection, registration, callback)\n  }\n\n  return /** @type {T} */ (await registration.coordinator(async () => {\n    return await coordinateRootSharedTransactionConnection(connection, registration, callback)\n  }))\n}\n"]}

package/build/src/testing/shared-transaction-proxy-driver.d.ts

@@ -1,6 +1,7 @@
-/** @typedef {{address?: string, capability?: string, databaseIdentifiers?: string[], expected: boolean}} SharedTransactionBrokerJobConfig */
+/** @typedef {{address?: string, allowDynamicIdentities?: boolean, capability?: string, databaseIdentifiers?: string[], expected: boolean}} SharedTransactionBrokerJobConfig */
 export type SharedTransactionBrokerJobConfig = {
     address?: string;
+    allowDynamicIdentities?: boolean;
     capability?: string;
     databaseIdentifiers?: string[];
     expected: boolean;
@@ -15,14 +16,31 @@ export declare const BACKGROUND_JOB_CHILD_ENV = "VELOCIOUS_BACKGROUND_JOB_CHILD"
  * @returns {T} - Callback result.
  */
 export declare function runWithSharedTransactionBrokerConfig<T>(config: SharedTransactionBrokerJobConfig, callback: () => T): T;
+/**
+ * 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 declare function sharedTransactionBrokerContextMatches(identity: {
+    address: string;
+    capability: string;
+}): boolean;
+/**
+ * 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 declare function automaticSharedTransactionBrokerOmits(databaseIdentifier: string): boolean;
 /**
  * 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 declare function sharedTransactionBrokerConfig(databaseIdentifier: string): {
     address: string;
+    allowDynamicIdentities?: boolean;
     capability: string;
 } | undefined;
 /**
@@ -32,11 +50,12 @@ export declare function sharedTransactionBrokerConfig(databaseIdentifier: string
  * @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 declare function createSharedTransactionProxyDriver(DriverClass: typeof import("../database/drivers/base.js").default, config: import("../configuration-types.js").DatabaseConfigurationType, configuration: import("../configuration.js").default, databaseIdentifier: string, brokerConfig: {
     address: string;
     capability: string;
+    reuseKey?: string;
 }): import("../database/drivers/base.js").default;
 //# sourceMappingURL=shared-transaction-proxy-driver.d.ts.map

package/build/src/testing/shared-transaction-proxy-driver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared-transaction-proxy-driver.d.ts","sourceRoot":"","sources":["../../../src/testing/shared-transaction-proxy-driver.js"],"names":[],"mappings":"AAAA,6IAA6I;AAAzI,YAAsG,gCAAgC,GAA5H;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAC,CAAkC;AAO1I,eAAO,MAAM,6BAA6B,6CAA6C,CAAA;AACvF,eAAO,MAAM,wBAAwB,mCAAmC,CAAA;AAKxE;;;;;;GAMG;AACH,wBAAgB,oCAAoC,CALvC,CAAC,EAKuC,MAAM,EAJhD,gCAIgD,EAAE,QAAQ,EAH1D,MAAM,CAGoD,GAFxD,CAAC,CAIb;AAyBD;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,kBAAkB,EAHrD,MAGqD,GAFnD;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,GAAG,SAAS,CAW7D;AAuBD;;;;;;;;;GASG;AACH,wBAAgB,kCAAkC,CAAC,WAAW,EAPnD,cAAc,6BAA6B,EAAE,OAOM,EAAE,MAAM,EAN3D,OAAO,2BAA2B,EAAE,yBAMuB,EAAE,aAAa,EAL1E,OAAO,qBAAqB,EAAE,OAK4C,EAAE,kBAAkB,EAJ9F,MAI8F,EAAE,YAAY,EAH5G;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAGwE,GAF1G,OAAO,6BAA6B,EAAE,OAAO,CA+GzD"}
+{"version":3,"file":"shared-transaction-proxy-driver.d.ts","sourceRoot":"","sources":["../../../src/testing/shared-transaction-proxy-driver.js"],"names":[],"mappings":"AAAA,+KAA+K;AAA3K,YAAwI,gCAAgC,GAA9J;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAC,CAAkC;AAO5K,eAAO,MAAM,6BAA6B,6CAA6C,CAAA;AACvF,eAAO,MAAM,wBAAwB,mCAAmC,CAAA;AAkBxE;;;;;;GAMG;AACH,wBAAgB,oCAAoC,CALvC,CAAC,EAKuC,MAAM,EAJhD,gCAIgD,EAAE,QAAQ,EAH1D,MAAM,CAGoD,GAFxD,CAAC,CAIb;AAED;;;;GAIG;AACH,wBAAgB,qCAAqC,CAAC,QAAQ,EAHnD;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAGe,GAFjD,OAAO,CAKnB;AAED;;;;;GAKG;AACH,wBAAgB,qCAAqC,CAAC,kBAAkB,EAH7D,MAG6D,GAF3D,OAAO,CAYnB;AAyBD;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,kBAAkB,EAHrD,MAGqD,GAFnD;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,GAAG,SAAS,CAM/F;AA0BD;;;;;;;;;GASG;AACH,wBAAgB,kCAAkC,CAAC,WAAW,EAPnD,cAAc,6BAA6B,EAAE,OAOM,EAAE,MAAM,EAN3D,OAAO,2BAA2B,EAAE,yBAMuB,EAAE,aAAa,EAL1E,OAAO,qBAAqB,EAAE,OAK4C,EAAE,kBAAkB,EAJ9F,MAI8F,EAAE,YAAY,EAH5G;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAGqD,GAF1G,OAAO,6BAA6B,EAAE,OAAO,CA+GzD"}

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":"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","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":"AAAA,+KAA+K;AAE/K,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;;;GAGG;AACH,SAAS,mCAAmC;IAC1C,MAAM,gBAAgB,GAAG,qBAAqB,CAAC,QAAQ,EAAE,CAAA;IACzD,IAAI,gBAAgB;QAAE,OAAO,gBAAgB,CAAA;IAC7C,IAAI,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,KAAK,GAAG;QAAE,OAAO,SAAS,CAAA;IACnE,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,6BAA6B,CAAC,CAAA;IAC7D,IAAI,CAAC,UAAU;QAAE,OAAO,SAAS,CAAA;IACjC,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAA;AAC1E,CAAC;AAED;;;;;;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,MAAM,UAAU,qCAAqC,CAAC,QAAQ;IAC5D,MAAM,MAAM,GAAG,qBAAqB,CAAC,QAAQ,EAAE,CAAA;IAC/C,OAAO,MAAM,EAAE,QAAQ,KAAK,IAAI,IAAI,MAAM,CAAC,OAAO,KAAK,QAAQ,CAAC,OAAO,IAAI,MAAM,CAAC,UAAU,KAAK,QAAQ,CAAC,UAAU,CAAA;AACtH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qCAAqC,CAAC,kBAAkB;IACtE,MAAM,MAAM,GAAG,mCAAmC,EAAE,CAAA;IACpD,OAAO,OAAO,CACZ,MAAM,EAAE,QAAQ,KAAK,IAAI;QACzB,CAAC,MAAM,CAAC,sBAAsB;QAC9B,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ;QAClC,OAAO,MAAM,CAAC,UAAU,KAAK,QAAQ;QACrC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAAC;QACzC,CAAC,MAAM,CAAC,mBAAmB,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CACzD,CAAA;AACH,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,MAAM,GAAG,mCAAmC,EAAE,CAAA;IACpD,IAAI,CAAC,MAAM;QAAE,OAAO,SAAS,CAAA;IAC7B,OAAO,qBAAqB,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;AAC1D,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,sBAAsB,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC;QAC/F,MAAM,IAAI,KAAK,CAAC,iEAAiE,kBAAkB,EAAE,CAAC,CAAA;IACxG,CAAC;IAED,IAAI,MAAM,CAAC,sBAAsB,EAAE,CAAC;QAClC,OAAO,EAAC,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,sBAAsB,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAC,CAAA;IAC/F,CAAC;IACD,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, 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"}