velocious 1.0.617 → 1.0.619

package/README.md

@@ -2162,7 +2162,9 @@ option; the default configuration keeps sequential `TRUNCATE TABLE` requests. Se
 
 Request tests share transaction-active, non-tenant database connections with their in-process HTTP handlers. Eligibility is evaluated when each request is dispatched, so a hook can start a transaction and issue a request in the same callback. This makes uncommitted setup visible to handlers while preserving rollback isolation. Without an active transaction, handlers use independent pooled connections, so concurrency and locking tests can opt out of transaction cleanup and exercise production-style connections. Shared connection state is scoped to the test lifecycle and cleared around each test. See [docs/testing-guidelines.md](docs/testing-guidelines.md#request-test-database-connections).
 
-Transactional tests also share active non-tenant connections with real forked, reusable pooled, and spawned background-job child runners through a per-attempt test-only loopback broker. Parent setup and child writes therefore occupy the same physical transaction and roll back together, including background-job persistence. Multiple configured databases route by identifier; tenant-only databases remain excluded. Tests using `{transaction: false, truncate: true}` retain ordinary independent physical connections for concurrency and locking coverage. See [docs/testing-guidelines.md](docs/testing-guidelines.md#request-test-database-connections).
+Transactional tests also share active non-tenant connections with real forked, reusable pooled, and spawned background-job child runners through a per-attempt test-only loopback broker. Parent setup and child writes therefore occupy the same physical transaction and roll back together, including background-job persistence. Backend harnesses can use [`TestTransactionSession`](docs/test-transaction-sessions.md) to propagate an ephemeral capability to already-running services and lazily enroll exact tenant physical identities. Tests using `{transaction: false, truncate: true}` retain ordinary independent connections for DDL, lock contention, independent commits, and genuine concurrency. See [docs/testing-guidelines.md](docs/testing-guidelines.md#request-test-database-connections).
+
+Multiple configured databases route by identifier. Tenant-only databases remain excluded by default; a test can explicitly call `registerTransactionalTenant({databaseIdentifier, tenant})` from its attempt args to share one transaction with same-process paths resolving that exact physical tenant configuration. That registration remains active through `afterEach` and is revoked, rolled back, and released afterward. Emergency cleanup for a lifecycle hung beyond timeout grace revokes pending setup before it can publish stale state, bounds cleanup waits, and discards its physical tenant connection, so stale resumed work cannot use a driver recycled into a successor attempt. See [docs/testing-guidelines.md](docs/testing-guidelines.md#in-process-test-database-connections).
 
 Warm pooled children receive the active broker capability per job, discard retained proxy state when the capability changes, and fail closed if a transactional dispatch lacks coordinates. Child transaction/savepoint work holds a FIFO lease on the parent physical connection until the matching root release or rollback.
 
@@ -2520,6 +2522,8 @@ Set `deduplicateWhileQueued: true` to coalesce an enqueue onto the earliest iden
 
 Use `options: {idempotencyKey}` when producer replay must converge on the original durable job across every state and even after terminal-job pruning. Ownership is scoped to the resolved job class name, resolved queue, and key; reusing that scope with changed canonical arguments or behavior-affecting options fails. This is distinct from queued-only deduplication, and ownership rows are intentionally retained until a future explicit reconciliation/deletion policy. See [durable idempotent enqueue](docs/background-jobs.md#durable-idempotent-enqueue).
 
+The Node producer rejects and destroys its one-shot socket when the main closes before acknowledging or when an enqueue acknowledgement stalls for 5 seconds. Because the main may already have committed the job, this is an ambiguous outcome: replay with the same durable `idempotencyKey` to recover the original job id without creating a duplicate. Direct `BackgroundJobsClient` users can set a different bounded `enqueueTimeoutMs` constructor option. See [durable idempotent enqueue](docs/background-jobs.md#durable-idempotent-enqueue).
+
 Select a non-default runtime explicitly with `options: {executionMode: "inline" | "forked" | "spawned"}`.
 
 Inline jobs share the worker process and run concurrently up to `maxConcurrentInlineJobs`, so a single slow inline job no longer blocks the queue. A single worker can also override the configured cap explicitly:

package/build/background-jobs/client.js

@@ -1,16 +1,21 @@
 // @ts-check
 
+import timeout from "awaitery/build/timeout.js"
 import configurationResolver from "../configuration-resolver.js"
 import BackgroundJobsSocketRequest from "./socket-request.js"
 
+const DEFAULT_ENQUEUE_TIMEOUT_MS = 5000
+
 export default class BackgroundJobsClient {
   /**
    * Runs constructor.
    * @param {object} [args] - Options.
    * @param {import("../configuration.js").default} [args.configuration] - Configuration.
+   * @param {number} [args.enqueueTimeoutMs] - Maximum time to wait for an enqueue acknowledgement in milliseconds (default: 5000).
    */
-  constructor({configuration} = {}) {
+  constructor({configuration, enqueueTimeoutMs = DEFAULT_ENQUEUE_TIMEOUT_MS} = {}) {
     this.configurationPromise = configuration ? Promise.resolve(configuration) : configurationResolver()
+    this.enqueueTimeoutMs = enqueueTimeoutMs
   }
 
   /**
@@ -35,7 +40,11 @@ export default class BackgroundJobsClient {
   async enqueue({jobName, args, options}) {
     const request = await this._request()
 
-    return await request.run({
+    return await timeout({
+      errorMessage: `Background job enqueue acknowledgement timed out after ${this.enqueueTimeoutMs}ms`,
+      timeout: this.enqueueTimeoutMs
+    }, async ({control}) => await request.run({
+      signal: control.signal,
       onConnect: (jsonSocket) => {
         jsonSocket.send({
           type: "enqueue",
@@ -54,7 +63,7 @@ export default class BackgroundJobsClient {
           reject(new Error(message.error || "Failed to enqueue job"))
         }
       }
-    })
+    }))
   }
 
   /**

package/build/background-jobs/socket-request.js

@@ -89,6 +89,10 @@ export default class BackgroundJobsSocketRequest {
         finish({}, () => reject(error))
       })
 
+      jsonSocket.on("close", () => {
+        finish({destroy: true}, () => reject(new Error("Background jobs socket closed before the request was acknowledged")))
+      })
+
       /**
        * Handles the socket response message.
        * @param {import("./types.js").BackgroundJobSocketMessage} message - Socket message.

package/build/database/migration/index.js

@@ -1,5 +1,6 @@
 // @ts-check
 
+/** @typedef {import("../table-data/table-column.js").TableColumnArgsType} AddColumnArgsType */
 /**
  * CreateTableIdArgsType type.
  * @typedef {object} CreateTableIdArgsType
@@ -109,7 +110,7 @@ export default class VelociousDatabaseMigration {
    * @param {string} tableName - Table name.
    * @param {string} columnName - Column name.
    * @param {string} columnType - Column type.
-   * @param {import("../table-data/table-column.js").TableColumnArgsType} [args] - Options object.
+   * @param {AddColumnArgsType} [args] - Options object.
    * @returns {Promise<void>} - Resolves when complete.
    */
   async addColumn(tableName, columnName, columnType, args) {

package/build/database/pool/async-tracked-multi-connection.js

@@ -55,6 +55,15 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
    */
   _testSharedConnectionRegistration = undefined
 
+  /** Attempt-owned shared connections keyed by resolved physical configuration. */
+  _testSharedConnectionsByReuseKey = new Map()
+
+  /**
+   * Concurrent providers selected by live async join context.
+   * @type {Map<import("./base.js").TestSharedConnectionRegistration, {matches: () => boolean, provider: () => import("../drivers/base.js").default | undefined}>}
+   */
+  _testSharedConnectionProviders = new Map()
+
   /**
    * Connections.
    * @type {import("../drivers/base.js").default[]} */
@@ -173,15 +182,16 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
   /**
    * Spawns and times a physical connection without retaining its configuration.
    * @param {import("../../configuration-types.js").DatabaseConfigurationType} config - Resolved database configuration.
+   * @param {string} [reuseKey] - Exact resolved physical identity.
    * @returns {Promise<import("../drivers/base.js").default>} - Connected driver.
    */
-  async spawnConnectionWithConfiguration(config) {
+  async spawnConnectionWithConfiguration(config, reuseKey) {
     const startedAt = this.nowMs()
     const profileContext = currentTestProfileContext(this.configuration)
     let failed = true
 
     try {
-      const connection = await super.spawnConnectionWithConfiguration(config)
+      const connection = await super.spawnConnectionWithConfiguration(config, reuseKey)
 
       failed = false
       const liveConnectionCount = this.liveConnectionCount() - this.connectionsBeingSpawned + 1
@@ -249,6 +259,30 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
     if (this.connections.includes(connection)) await this.handleCheckedInIdleConnection()
   }
 
+  /**
+   * Permanently removes and closes a checked-out connection.
+   * @param {import("../drivers/base.js").default} connection - Connection that must not return to the pool.
+   */
+  async discard(connection) {
+    const id = connection.getIdSeq()
+    const errors = []
+
+    this.untrackConnectionInUse(connection, id)
+    try {
+      await this.closeConnection(connection)
+    } catch (error) {
+      errors.push(error)
+    }
+    try {
+      await this.drainPendingCheckouts()
+    } catch (error) {
+      errors.push(error)
+    }
+
+    if (errors.length === 1) throw errors[0]
+    if (errors.length > 1) throw new AggregateError(errors, "Failed to discard a database connection")
+  }
+
   /**
    * Runs close checked out connection after checkin failure.
    * @param {import("../drivers/base.js").default} connection - Connection that failed check-in cleanup.
@@ -517,7 +551,7 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
     try {
       const environmentHandler = this.configuration.getEnvironmentHandler()
       const connection = await environmentHandler.runWithTestProfileContext(profileContext, async () => {
-        return await this.spawnConnectionWithConfiguration(databaseConfig)
+        return await this.spawnConnectionWithConfiguration(databaseConfig, this.getConfigurationReuseKey(databaseConfig))
       })
 
       this.stampConnectionForConfigurationReuseKey(connection, reuseKey)
@@ -885,6 +919,13 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
 
     if (!actualCallback) throw new Error("withConnection requires a callback")
 
+    const testSharedConnection = this.activeTestSharedConnection()
+    if (testSharedConnection && this.connectionMatchesCurrentConfiguration(testSharedConnection)) {
+      return await this.asyncLocalStorage.run(testSharedConnection.getIdSeq(), async () => {
+        return await actualCallback(testSharedConnection)
+      })
+    }
+
     const connection = await this.checkout(options)
     const id = connection.getIdSeq()
 
@@ -1079,12 +1120,46 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
     return registration
   }
 
+  /**
+   * Registers a provider selected by the current live async join context.
+   * @param {{matches: () => boolean, provider: () => import("../drivers/base.js").default | undefined}} args - Context selector and provider.
+   * @returns {import("./base.js").TestSharedConnectionRegistration} - Opaque scoped registration handle.
+   */
+  registerTestSharedConnectionProvider(args) {
+    const registration = {owner: Symbol("test-shared-connection-context-provider")}
+    this._testSharedConnectionProviders.set(registration, args)
+    return registration
+  }
+
+  /**
+   * Registers an attempt-owned connection for exactly one physical configuration.
+   * @param {import("../drivers/base.js").default} connection - Attempt-owned connection.
+   * @param {string} reuseKey - Resolved physical configuration identity.
+   * @returns {import("./base.js").TestSharedConnectionRegistration} - Opaque registration handle.
+   */
+  setTestSharedConnectionForConfiguration(connection, reuseKey) {
+    const registration = {owner: Symbol("test-shared-physical-connection")}
+
+    this._testSharedConnectionsByReuseKey.set(reuseKey, {connection, registration})
+    return registration
+  }
+
   /**
    * Clears the current shared connection registration. A supplied stale registration
    * cannot clear a provider installed by a newer lifecycle.
    * @param {import("./base.js").TestSharedConnectionRegistration} [registration] - Opaque registration handle to clear conditionally.
    * @returns {void} */
   clearTestSharedConnection(registration) {
+    if (registration && this._testSharedConnectionProviders.delete(registration)) return
+    if (registration) {
+      for (const [reuseKey, entry] of this._testSharedConnectionsByReuseKey) {
+        if (entry.registration !== registration) continue
+        this._testSharedConnectionsByReuseKey.delete(reuseKey)
+        return
+      }
+    } else {
+      this._testSharedConnectionsByReuseKey.clear()
+    }
     if (registration && registration !== this._testSharedConnectionRegistration) return
 
     this._testSharedConnection = undefined
@@ -1103,18 +1178,40 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
    * @returns {T} - Callback result.
    */
   runWithTestSharedConnection(callback) {
-    const connection = this.testSharedConnection()
+    const connection = this.activeTestSharedConnection()
 
     if (!connection) return callback()
 
     return this.asyncLocalStorage.run(connection.getIdSeq(), callback)
   }
 
+  /**
+   * Resolves a test-shared connection only while its checkout ID is still owned by this pool.
+   * Fallback-only registrations have no checkout ID and must enter the normal checkout path.
+   * @returns {import("../drivers/base.js").default | undefined} - Active shared connection.
+   */
+  activeTestSharedConnection() {
+    const connection = this.testSharedConnection()
+    const id = connection?.getIdSeq()
+
+    if (typeof id !== "number") return
+    if (this.connectionsInUse[id] !== connection) return
+
+    return connection
+  }
+
   /**
    * Resolves the connection currently eligible for in-process test request sharing.
    * @returns {import("../drivers/base.js").default | undefined} - Shared connection.
    */
   testSharedConnection() {
+    for (const {matches, provider} of this._testSharedConnectionProviders.values()) {
+      if (matches()) return provider()
+    }
+    const reuseKey = this.getConfigurationReuseKey()
+    const physicalRegistration = this._testSharedConnectionsByReuseKey.get(reuseKey)
+
+    if (physicalRegistration) return physicalRegistration.connection
     return this._testSharedConnectionProvider
       ? this._testSharedConnectionProvider()
       : this._testSharedConnection

package/build/database/pool/base.js

@@ -126,6 +126,16 @@ class VelociousDatabasePoolBase {
     throw new Error("'checkin' not implemented")
   }
 
+  /**
+   * Permanently discards an attempt-owned checked-out connection.
+   * @abstract
+   * @param {import("../drivers/base.js").default} _connection - Connection that must not return to the pool.
+   * @returns {Promise<void>} - Resolves after the connection is closed and removed from pool ownership.
+   */
+  discard(_connection) {
+    throw new Error("'discard' not implemented")
+  }
+
   /**
    * Runs checkout.
    * @abstract
@@ -175,6 +185,26 @@ class VelociousDatabasePoolBase {
     return undefined
   }
 
+  /**
+   * Registers a test shared connection selected by the caller's live async context.
+   * Base pools that do not track async context ignore it.
+   * @param {{matches: () => boolean, provider: () => import("../drivers/base.js").default | undefined}} _args - Context selector and connection provider.
+   * @returns {TestSharedConnectionRegistration | undefined} - Opaque scoped registration handle.
+   */
+  registerTestSharedConnectionProvider(_args) {
+    return undefined
+  }
+
+  /**
+   * Registers a test connection for one resolved physical database configuration.
+   * @param {import("../drivers/base.js").default} _connection - Attempt-owned connection.
+   * @param {string} _reuseKey - Resolved physical configuration identity.
+   * @returns {TestSharedConnectionRegistration | undefined} - Opaque registration handle when supported.
+   */
+  setTestSharedConnectionForConfiguration(_connection, _reuseKey) {
+    return undefined
+  }
+
   /**
    * Clears the shared connection or provider set for in-process test requests. No-op by default.
    * When a registration is provided, clears only if it is still the active registration.
@@ -337,7 +367,7 @@ class VelociousDatabasePoolBase {
    */
   async spawnConnectionForConfiguration(databaseConfiguration) {
     const reuseKey = this.getConfigurationReuseKey(databaseConfiguration)
-    const connection = await this.spawnConnectionWithConfiguration(databaseConfiguration)
+    const connection = await this.spawnConnectionWithConfiguration(databaseConfiguration, reuseKey)
 
     this.stampConnectionForConfigurationReuseKey(connection, reuseKey)
 
@@ -368,21 +398,21 @@ class VelociousDatabasePoolBase {
   /**
    * Runs spawn connection with configuration.
    * @param {import("../../configuration-types.js").DatabaseConfigurationType} config - Configuration object.
+   * @param {string} [reuseKey] - Exact resolved physical identity.
    * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the spawn connection with configuration.
    */
-  async spawnConnectionWithConfiguration(config) {
+  async spawnConnectionWithConfiguration(config, reuseKey) {
     const DriverClass = config.driver || this.driverClass
 
     if (!DriverClass) throw new Error("No driver class set in database pool or in given config")
 
-    const sharedConnection = config.tenantOnly
-      ? undefined
-      : await this.configuration.getEnvironmentHandler().createTestSharedTransactionConnection({
-        DriverClass,
-        config,
-        configuration: this.configuration,
-        databaseIdentifier: this.identifier
-      })
+    const sharedConnection = await this.configuration.getEnvironmentHandler().createTestSharedTransactionConnection({
+      DriverClass,
+      config,
+      configuration: this.configuration,
+      databaseIdentifier: this.identifier,
+      reuseKey
+    })
     const connection = sharedConnection || new DriverClass(config, this.configuration)
 
     try {
@@ -395,6 +425,18 @@ class VelociousDatabasePoolBase {
     return connection
   }
 
+  /**
+   * Checks out a connection for an already-resolved physical configuration.
+   * Multi-configuration pools override this for explicit tenant registrations.
+   * @param {import("../../configuration-types.js").DatabaseConfigurationType} _databaseConfiguration - Captured configuration.
+   * @param {ConnectionCheckoutOptions} [_options] - Checkout options.
+   * @param {{retain: boolean}} [_args] - Pool-specific retention behavior.
+   * @returns {Promise<import("../drivers/base.js").default>} - Checked-out connection.
+   */
+  async checkoutForConfiguration(_databaseConfiguration, _options, _args) {
+    throw new Error("Database pool does not support captured configuration checkout")
+  }
+
   /**
    * Runs close connection after failed connect.
    * @param {import("../drivers/base.js").default} connection - Connection to close.

package/build/database/pool/single-multi-use.js

@@ -45,6 +45,8 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
   /** @type {Set<() => boolean>} */
   capacityWaiters = new Set()
   closeGeneration = 0
+  /** @type {Map<string, {connection: import("../drivers/base.js").default, registration: import("./base.js").TestSharedConnectionRegistration}>} */
+  testSharedConnectionsByReuseKey = new Map()
 
   /**
    * Checks a connection back into its keyed physical entry.
@@ -80,6 +82,24 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
     if (!entry.lifecycleRetained && (!entry.retained || this.capacityWaiters.size > 0)) await this.removeAndCloseEntry(entry)
   }
 
+  /**
+   * Permanently removes and closes a checked-out connection.
+   * @param {import("../drivers/base.js").default} connection - Connection that must not return to the pool.
+   */
+  async discard(connection) {
+    const entry = this.entryForConnection(connection)
+
+    if (entry) {
+      this.activeCheckoutCount -= entry.activeCheckoutCount
+      entry.activeCheckoutCount = 0
+      entry.checkoutNames = []
+      await this.removeAndCloseEntry(entry)
+      return
+    }
+
+    await connection.close()
+  }
+
   /**
    * Checks out the ambient configuration and retains it as the single mutable
    * browser fallback connection.
@@ -93,11 +113,11 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
   /**
    * Checks out an explicitly captured physical configuration.
    * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Captured configuration.
-   * @param {import("./base.js").ConnectionCheckoutOptions} options - Checkout options.
-   * @param {{retain: boolean}} args - Whether this becomes the ambient retained connection.
+   * @param {import("./base.js").ConnectionCheckoutOptions} [options] - Checkout options.
+   * @param {{retain: boolean}} [args] - Whether this becomes the ambient retained connection.
    * @returns {Promise<import("../drivers/base.js").default>} - Checked-out connection.
    */
-  async checkoutForConfiguration(databaseConfiguration, options, {retain}) {
+  async checkoutForConfiguration(databaseConfiguration, options = {}, {retain} = {retain: false}) {
     const reuseKey = this.getConfigurationReuseKey(databaseConfiguration)
     let entry = this.connectionEntries.get(reuseKey)
 
@@ -460,6 +480,7 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
 
     this.connectionEntries.clear()
     this.connectionEntrySpawnPromises.clear()
+    this.testSharedConnectionsByReuseKey.clear()
     this.connection = undefined
     this.activeCheckoutCount = 0
 
@@ -476,6 +497,46 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
     return this.connection
   }
 
+  /**
+   * Registers an attempt-owned connection for exactly one physical configuration.
+   * @param {import("../drivers/base.js").default} connection - Attempt-owned connection.
+   * @param {string} reuseKey - Resolved physical configuration identity.
+   * @returns {import("./base.js").TestSharedConnectionRegistration} - Opaque registration handle.
+   */
+  setTestSharedConnectionForConfiguration(connection, reuseKey) {
+    const registration = {owner: Symbol("test-shared-physical-connection")}
+
+    this.testSharedConnectionsByReuseKey.set(reuseKey, {connection, registration})
+    return registration
+  }
+
+  /**
+   * Clears an attempt-owned shared physical connection without revoking a newer owner.
+   * @param {import("./base.js").TestSharedConnectionRegistration} [registration] - Registration to clear conditionally.
+   */
+  clearTestSharedConnection(registration) {
+    if (!registration) {
+      this.testSharedConnectionsByReuseKey.clear()
+      return
+    }
+
+    for (const [reuseKey, entry] of this.testSharedConnectionsByReuseKey) {
+      if (entry.registration !== registration) continue
+      this.testSharedConnectionsByReuseKey.delete(reuseKey)
+      return
+    }
+  }
+
+  /**
+   * Resolves the attempt-owned connection for the current physical configuration.
+   * @returns {import("../drivers/base.js").default | undefined} - Shared connection.
+   */
+  testSharedConnection() {
+    const reuseKey = this.getConfigurationReuseKey()
+
+    return this.testSharedConnectionsByReuseKey.get(reuseKey)?.connection
+  }
+
   /**
    * Returns the current context fallback connection when it is not suppressed.
    * @returns {import("../drivers/base.js").default | undefined} - Current fallback connection.
@@ -483,7 +544,7 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
   getCurrentContextConnection() {
     if (this.suppressedConnectionContextCount > 0) return undefined
 
-    return this.connection
+    return this.testSharedConnection() || this.connection
   }
 
   /**

package/build/environment-handlers/base.js

@@ -31,7 +31,7 @@ export default class VelociousEnvironmentHandlerBase {
   /**
    * Node test runtimes may replace a physical child connection with a broker
    * proxy. Other environments never participate in this test-only protocol.
-   * @param {{DriverClass: typeof import("../database/drivers/base.js").default, config: import("../configuration-types.js").DatabaseConfigurationType, configuration: import("../configuration.js").default, databaseIdentifier: string}} _args - Connection details.
+   * @param {{DriverClass: typeof import("../database/drivers/base.js").default, config: import("../configuration-types.js").DatabaseConfigurationType, configuration: import("../configuration.js").default, databaseIdentifier: string, reuseKey?: string}} _args - Connection details.
    * @returns {Promise<import("../database/drivers/base.js").default | undefined>} - Optional proxy.
    */
   async createTestSharedTransactionConnection(_args) { return undefined }

package/build/environment-handlers/node.js

@@ -40,7 +40,7 @@ import InitializerFromRequireContext from "../database/initializer-from-require-
 import toImportSpecifier from "../utils/to-import-specifier.js"
 import {validateTimeZone} from "../time-zone.js"
 import AttachmentPathSource from "./node/attachment-path-source.js"
-import { createSharedTransactionProxyDriver, sharedTransactionBrokerConfig } from "../testing/shared-transaction-proxy-driver.js"
+import { automaticSharedTransactionBrokerOmits, createSharedTransactionProxyDriver, sharedTransactionBrokerConfig } from "../testing/shared-transaction-proxy-driver.js"
 
 /**
  * Defines this typedef.
@@ -95,6 +95,8 @@ export default class VelociousEnvironmentHandlerNode extends Base{
    * @returns {typeof import("../database/pool/base.js").default} - Pool type for this context.
    */
   resolveTestSharedTransactionPoolType({configuredPoolType, databaseIdentifier}) {
+    const databaseConfiguration = this.getConfiguration().getDatabaseIdentifier(databaseIdentifier)
+    if (databaseConfiguration.tenantOnly && automaticSharedTransactionBrokerOmits(databaseIdentifier)) return configuredPoolType
     if (!sharedTransactionBrokerConfig(databaseIdentifier)) return configuredPoolType
 
     return AsyncTrackedMultiConnectionPool
@@ -102,13 +104,17 @@ export default class VelociousEnvironmentHandlerNode extends Base{
 
   /**
    * Creates a test-only child proxy when TestRunner supplied an active broker.
-   * @param {{DriverClass: typeof import("../database/drivers/base.js").default, config: import("../configuration-types.js").DatabaseConfigurationType, configuration: import("../configuration.js").default, databaseIdentifier: string}} args - Connection details.
+   * @param {{DriverClass: typeof import("../database/drivers/base.js").default, config: import("../configuration-types.js").DatabaseConfigurationType, configuration: import("../configuration.js").default, databaseIdentifier: string, reuseKey?: string}} args - Connection details.
    * @returns {Promise<import("../database/drivers/base.js").default | undefined>} - Optional proxy.
    */
-  async createTestSharedTransactionConnection({DriverClass, config, configuration, databaseIdentifier}) {
+  async createTestSharedTransactionConnection({DriverClass, config, configuration, databaseIdentifier, reuseKey}) {
+    if (config.tenantOnly && automaticSharedTransactionBrokerOmits(databaseIdentifier)) return undefined
     const brokerConfig = sharedTransactionBrokerConfig(databaseIdentifier)
     if (!brokerConfig) return undefined
-    return createSharedTransactionProxyDriver(DriverClass, config, configuration, databaseIdentifier, brokerConfig)
+    return createSharedTransactionProxyDriver(DriverClass, config, configuration, databaseIdentifier, {
+      ...brokerConfig,
+      reuseKey: brokerConfig.allowDynamicIdentities ? reuseKey : undefined
+    })
   }
 
   /**

package/build/src/background-jobs/client.d.ts

@@ -1,13 +1,16 @@
 import BackgroundJobsSocketRequest from "./socket-request.js";
 export default class BackgroundJobsClient {
     configurationPromise: Promise<import("../configuration.js").default>;
+    enqueueTimeoutMs: number;
     /**
      * Runs constructor.
      * @param {object} [args] - Options.
      * @param {import("../configuration.js").default} [args.configuration] - Configuration.
+     * @param {number} [args.enqueueTimeoutMs] - Maximum time to wait for an enqueue acknowledgement in milliseconds (default: 5000).
      */
-    constructor({ configuration }?: {
+    constructor({ configuration, enqueueTimeoutMs }?: {
         configuration?: import("../configuration.js").default;
+        enqueueTimeoutMs?: number;
     });
     /**
      * Builds a one-shot client socket request from the resolved configuration.

package/build/src/background-jobs/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/client.js"],"names":[],"mappings":"AAGA,OAAO,2BAA2B,MAAM,qBAAqB,CAAA;AAE7D,MAAM,CAAC,OAAO,OAAO,oBAAoB;IAOhC,oBAAoB;IAN3B;;;;OAIG;IACH,YAAY,EAAC,aAAa,EAAC,AAHxB,CAEF,EADE;QAAqD,aAAa,AAAlE,CACF,EADU,OAAO,qBAAqB,EAAE,OAAO,CAC/C;KAC+B,EAE/B;IAED;;;OAGG;IACG,QAAQ,IAFD,OAAO,CAAC,2BAA2B,CAAC,CAOhD;IAED;;;;;;;OAOG;IACG,OAAO,CAAC,EAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAC,EALnC;QAAqB,OAAO,EAApB,MAAM,CACd;QAAmD,IAAI,EAA/C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;QAAyD,OAAO,AAAhE,CACA,EADQ,OAAO,YAAY,EAAE,oBAAoB,CACjD;KAEmC,GAFzB,OAAO,CAAC,MAAM,CAAC,CAyB3B;IAED;;;;;;;;OAQG;IACG,gBAAgB,CAAC,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAC,EANzD;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAqB,OAAO,EAApB,MAAM,CACd;QAAmD,IAAI,EAA/C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;QAAyD,OAAO,AAAhE,CACA,EADQ,OAAO,YAAY,EAAE,oBAAoB,CACjD;KAEyD,GAF/C,OAAO,CAAC,OAAO,YAAY,EAAE,8BAA8B,CAAC,CAwBxE;IAED;;;;;OAKG;IACG,eAAe,CAAC,EAAC,WAAW,EAAC,EAHhC;QAAqB,WAAW,EAAxB,MAAM,CACd;KAEgC,GAFtB,OAAO,CAAC,OAAO,YAAY,EAAE,+BAA+B,CAAC,CAoBzE;CACF"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/client.js"],"names":[],"mappings":"AAIA,OAAO,2BAA2B,MAAM,qBAAqB,CAAA;AAI7D,MAAM,CAAC,OAAO,OAAO,oBAAoB;IAQhC,oBAAoB;IACpB,gBAAgB;IARvB;;;;;OAKG;IACH,YAAY,EAAC,aAAa,EAAE,gBAA6C,EAAC,AAJvE,CAGF,EAFE;QAAqD,aAAa,AAAlE,CACA,EADQ,OAAO,qBAAqB,EAAE,OAAO,CAC7C;QAAsB,gBAAgB,AAAtC,CACF,EADU,MAAM,CAChB;KAC8E,EAG9E;IAED;;;OAGG;IACG,QAAQ,IAFD,OAAO,CAAC,2BAA2B,CAAC,CAOhD;IAED;;;;;;;OAOG;IACG,OAAO,CAAC,EAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAC,EALnC;QAAqB,OAAO,EAApB,MAAM,CACd;QAAmD,IAAI,EAA/C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;QAAyD,OAAO,AAAhE,CACA,EADQ,OAAO,YAAY,EAAE,oBAAoB,CACjD;KAEmC,GAFzB,OAAO,CAAC,MAAM,CAAC,CA6B3B;IAED;;;;;;;;OAQG;IACG,gBAAgB,CAAC,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAC,EANzD;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAqB,OAAO,EAApB,MAAM,CACd;QAAmD,IAAI,EAA/C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;QAAyD,OAAO,AAAhE,CACA,EADQ,OAAO,YAAY,EAAE,oBAAoB,CACjD;KAEyD,GAF/C,OAAO,CAAC,OAAO,YAAY,EAAE,8BAA8B,CAAC,CAwBxE;IAED;;;;;OAKG;IACG,eAAe,CAAC,EAAC,WAAW,EAAC,EAHhC;QAAqB,WAAW,EAAxB,MAAM,CACd;KAEgC,GAFtB,OAAO,CAAC,OAAO,YAAY,EAAE,+BAA+B,CAAC,CAoBzE;CACF"}