velocious 1.0.590 → 1.0.591

package/README.md

@@ -2072,6 +2072,10 @@ Tests default to a 60-second timeout. Override per test with `{timeoutSeconds: 5
 
 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).
+
+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.
+
 # Writing a request test
 
 First create a test file under something like the following path 'src/routes/accounts/create-test.js' with something like the following content:

package/build/background-jobs/pooled-runner-broker-identity.js

@@ -0,0 +1,76 @@
+// @ts-check
+
+export default class PooledRunnerBrokerIdentity {
+  /**
+   * Creates a pooled runner identity coordinator.
+   * @param {{closeConnections: () => Promise<void>}} args - Connection cleanup hook.
+   */
+  constructor({closeConnections}) {
+    this.closeConnections = closeConnections
+    /** @type {string | undefined} */
+    this.activeIdentity = undefined
+    /** @type {{identity: string, promise: Promise<void>} | undefined} */
+    this.pending = undefined
+    this.activeUsers = 0
+  }
+
+  /**
+   * Gets the current prepared identity.
+   * @returns {string | undefined} - Current prepared identity.
+   */
+  current() { return this.activeIdentity }
+
+  /**
+   * Prepares one identity, sharing an in-flight same-identity rotation.
+   * @param {import("../testing/shared-transaction-proxy-driver.js").SharedTransactionBrokerJobConfig} config - Dispatch configuration.
+   * @returns {Promise<void>} - Resolves after stale connections close.
+   */
+  async prepare(config) {
+    const identity = JSON.stringify(config)
+    if (this.pending) {
+      if (this.pending.identity !== identity) throw new Error("Pooled runner cannot mix shared transaction broker capabilities concurrently")
+      return await this.pending.promise
+    }
+    if (this.activeIdentity === identity) return
+    if (this.activeUsers > 0) throw new Error("Pooled runner cannot mix shared transaction broker capabilities concurrently")
+    if (this.activeIdentity === undefined) {
+      this.activeIdentity = identity
+      return
+    }
+
+    const promise = this.rotate(identity)
+    this.pending = {identity, promise}
+    try {
+      await promise
+    } finally {
+      this.pending = undefined
+    }
+  }
+
+  /**
+   * Runs work while preventing a different identity from replacing its connections.
+   * @template T
+   * @param {import("../testing/shared-transaction-proxy-driver.js").SharedTransactionBrokerJobConfig} config - Dispatch configuration.
+   * @param {() => Promise<T>} callback - Job callback.
+   * @returns {Promise<T>} - Job result.
+   */
+  async run(config, callback) {
+    await this.prepare(config)
+    this.activeUsers++
+    try {
+      return await callback()
+    } finally {
+      this.activeUsers--
+    }
+  }
+
+  /**
+   * Rotates retained connection state to an identity.
+   * @param {string} identity - Target identity.
+   * @returns {Promise<void>} - Resolves after rotation.
+   */
+  async rotate(identity) {
+    await this.closeConnections()
+    this.activeIdentity = identity
+  }
+}

package/build/background-jobs/pooled-runner-child.js

@@ -3,6 +3,8 @@
 import runJobPayload, { BackgroundJobPerformedFailure } from "./job-runner.js"
 import { closeRunnerConnections, currentConfigurationOrNull } from "./runner-graceful-shutdown.js"
 import setRunnerProcessTitle from "./runner-process-title.js"
+import PooledRunnerBrokerIdentity from "./pooled-runner-broker-identity.js"
+import { runWithSharedTransactionBrokerConfig } from "../testing/shared-transaction-proxy-driver.js"
 
 const BASE_PROCESS_TITLE = "velocious background-jobs-runner"
 
@@ -33,6 +35,9 @@ async function shutdownRunner(exitCode) {
  * @type {Set<string>}
  */
 const runningJobIds = new Set()
+const brokerIdentity = new PooledRunnerBrokerIdentity({
+  closeConnections: async () => await closeRunnerConnections(currentConfigurationOrNull())
+})
 
 /**
  * Sets an aggregate process title from the current in-flight count. A child runs
@@ -51,11 +56,11 @@ function updateProcessTitle() {
 /**
  * Checks whether an IPC value is a runnable pooled job message.
  * @param {ReturnType<typeof JSON.parse>} message - IPC message.
- * @returns {message is {type: "job", payload: import("./types.js").BackgroundJobPayload & {id: string}}} - Whether this is a valid job message.
+ * @returns {message is {type: "job", payload: import("./types.js").BackgroundJobPayload & {id: string}, sharedTransactionBroker?: import("../testing/shared-transaction-proxy-driver.js").SharedTransactionBrokerJobConfig}} - Whether this is a valid job message.
  */
 function isJobMessage(message) {
   if (!message || typeof message !== "object") return false
-  const record = /** @type {{type?: ReturnType<typeof JSON.parse>, payload?: ReturnType<typeof JSON.parse>}} */ (message)
+  const record = /** @type {{type?: ReturnType<typeof JSON.parse>, payload?: ReturnType<typeof JSON.parse>, sharedTransactionBroker?: ReturnType<typeof JSON.parse>}} */ (message)
 
   return record.type === "job" && !!record.payload && typeof record.payload === "object" && typeof record.payload.id === "string"
 }
@@ -95,11 +100,16 @@ function sendOutcome({jobId, acknowledged, status, error}) {
  * per-job try/catch) ends the child, which the worker sees as an exit and
  * reclaims for the whole in-flight set.
  * @param {import("./types.js").BackgroundJobPayload & {id: string}} payload - Job payload.
+ * @param {import("../testing/shared-transaction-proxy-driver.js").SharedTransactionBrokerJobConfig} sharedTransactionBroker - Per-job broker configuration.
  * @returns {Promise<void>} - Resolves after reporting.
  */
-async function runJob(payload) {
+async function runJob(payload, sharedTransactionBroker) {
   try {
-    const status = await runJobPayload(payload, {closeConnections: false, manageProcessTitle: false})
+    const status = await runWithSharedTransactionBrokerConfig(sharedTransactionBroker, async () => {
+      return await brokerIdentity.run(sharedTransactionBroker, async () => {
+        return await runJobPayload(payload, {closeConnections: false, manageProcessTitle: false})
+      })
+    })
     await sendOutcome({jobId: payload.id, acknowledged: true, status})
   } catch (error) {
     if (error instanceof BackgroundJobPerformedFailure) {
@@ -125,7 +135,7 @@ function handleMessage(message) {
 
   runningJobIds.add(message.payload.id)
   updateProcessTitle()
-  void runJob(message.payload)
+  void runJob(message.payload, message.sharedTransactionBroker || {expected: false})
 }
 
 process.on("message", (message) => handleMessage(message))

package/build/background-jobs/store.js

@@ -6,6 +6,7 @@ import TableData from "../database/table-data/index.js"
 import VelociousError from "../velocious-error.js"
 import BackgroundJobRecord from "./job-record.js"
 import normalizeBackgroundJobError from "./normalize-error.js"
+import {coordinateSharedTransactionConnection} from "../testing/shared-transaction-connection-coordinator.js"
 
 /**
  * PreparedBackgroundJob type.
@@ -2376,23 +2377,19 @@ export default class BackgroundJobsStore {
    * @returns {Promise<T>} - Callback result.
    */
   async _withDb(callback) {
-    const pool = this.configuration.getDatabasePool(this.getDatabaseIdentifier())
-    let callbackCalled = false
-    /**
-     * Defines result.
-     * @type {T | undefined} */
-    let result
-
-    await pool.withConnection({name: "Background jobs store"}, async (db) => {
-      callbackCalled = true
-      result = await callback(db)
-    })
+    const databaseIdentifier = this.getDatabaseIdentifier()
+    const pool = this.configuration.getDatabasePool(databaseIdentifier)
 
-    if (!callbackCalled) {
-      throw new Error("Background jobs store callback was not invoked")
+    if (!pool.testSharedConnection()) {
+      return await pool.withConnection({name: "Background jobs store"}, callback)
     }
 
-    return /** @type {T} */ (result)
+    return await this.configuration.runWithTestSharedConnectionContexts(async () => {
+      return await this.configuration.ensureConnections({databaseIdentifiers: [databaseIdentifier], name: "Background jobs store"}, async (dbs) => {
+        const connection = dbs[databaseIdentifier]
+        return await coordinateSharedTransactionConnection(connection, async () => await callback(connection))
+      })
+    })
   }
 
   /**

package/build/background-jobs/worker.js

@@ -693,13 +693,26 @@ export default class BackgroundJobsWorker {
 
       state.inflight.set(payload.id, {payload, resolve, timeoutTimer})
       try {
-        child.send({type: "job", payload})
+        child.send({type: "job", payload, sharedTransactionBroker: this._pooledJobSharedTransactionBrokerConfig()})
       } catch (error) {
         void this._handlePooledChildFailure({child, error})
       }
     })
   }
 
+  /**
+   * Captures the current test attempt's broker mode at dispatch time. A warm
+   * pooled child must never rely on its immutable fork-time environment.
+   * @returns {import("../testing/shared-transaction-proxy-driver.js").SharedTransactionBrokerJobConfig} - Per-job broker configuration.
+   */
+  _pooledJobSharedTransactionBrokerConfig() {
+    const serialized = process.env.VELOCIOUS_TEST_SHARED_TRANSACTION_BROKER
+    if (!serialized) return {expected: false}
+
+    const config = JSON.parse(Buffer.from(serialized, "base64url").toString("utf8"))
+    return {...config, expected: true}
+  }
+
   /**
    * Selects a pooled child to run the next job, or undefined when every non-retiring
    * child is already full (the caller then lazily spawns one). Among children with a
@@ -792,7 +805,7 @@ export default class BackgroundJobsWorker {
     const config = configuration.getBackgroundJobsConfig()
     const child = fork(POOLED_RUNNER_ENTRY_PATH, [], {
       cwd: configuration.getDirectory(), execArgv: [], stdio: ["ignore", "ignore", "ignore", "ipc"],
-      env: Object.assign({}, process.env, {VELOCIOUS_ENV: configuration.getEnvironment(), VELOCIOUS_BACKGROUND_JOBS_HOST: config.host, VELOCIOUS_BACKGROUND_JOBS_PORT: `${config.port}`})
+      env: Object.assign({}, process.env, {VELOCIOUS_BACKGROUND_JOB_CHILD: "1", VELOCIOUS_ENV: configuration.getEnvironment(), VELOCIOUS_BACKGROUND_JOBS_HOST: config.host, VELOCIOUS_BACKGROUND_JOBS_PORT: `${config.port}`})
     })
     this.pooledChildren.add(child)
     this.inflightProcessChildren.add(child)
@@ -989,6 +1002,7 @@ export default class BackgroundJobsWorker {
       execArgv: [],
       stdio: ["ignore", "ignore", "ignore", "ipc"],
       env: Object.assign({}, process.env, {
+        VELOCIOUS_BACKGROUND_JOB_CHILD: "1",
         VELOCIOUS_ENV: configuration.getEnvironment(),
         VELOCIOUS_BACKGROUND_JOBS_HOST: backgroundJobsConfig.host,
         VELOCIOUS_BACKGROUND_JOBS_PORT: `${backgroundJobsConfig.port}`
@@ -1216,6 +1230,7 @@ export default class BackgroundJobsWorker {
       detached: true,
       stdio: "ignore",
       env: Object.assign({}, process.env, {
+        VELOCIOUS_BACKGROUND_JOB_CHILD: "1",
         VELOCIOUS_ENV: configuration.getEnvironment(),
         VELOCIOUS_BACKGROUND_JOBS_HOST: backgroundJobsConfig.host,
         VELOCIOUS_BACKGROUND_JOBS_PORT: `${backgroundJobsConfig.port}`,

package/build/database/pool/base.js

@@ -193,6 +193,15 @@ class VelociousDatabasePoolBase {
     return callback()
   }
 
+  /**
+   * Returns the connection registered for test-only in-process sharing.
+   * Base pools do not need a separate shared connection.
+   * @returns {import("../drivers/base.js").default | undefined} - Shared connection.
+   */
+  testSharedConnection() {
+    return undefined
+  }
+
   /**
    * Returns whether the current connection is pinned to an execution context.
    * @returns {boolean} - Whether the current connection can be reused by nested code.
@@ -349,7 +358,15 @@ class VelociousDatabasePoolBase {
 
     if (!DriverClass) throw new Error("No driver class set in database pool or in given config")
 
-    const connection = new DriverClass(config, this.configuration)
+    const sharedConnection = config.tenantOnly
+      ? undefined
+      : await this.configuration.getEnvironmentHandler().createTestSharedTransactionConnection({
+        DriverClass,
+        config,
+        configuration: this.configuration,
+        databaseIdentifier: this.identifier
+      })
+    const connection = sharedConnection || new DriverClass(config, this.configuration)
 
     try {
       await connection.connect()

package/build/environment-handlers/base.js

@@ -19,6 +19,14 @@ import {validateTimeZone} from "../time-zone.js"
  */
 
 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.
+   * @returns {Promise<import("../database/drivers/base.js").default | undefined>} - Optional proxy.
+   */
+  async createTestSharedTransactionConnection(_args) { return undefined }
+
   /**
    * Mutable ambient tenant used by runtimes without async-context storage.
    * @type {ReturnType<typeof JSON.parse> | undefined}

package/build/environment-handlers/node.js

@@ -36,6 +36,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"
 
 /**
  * Defines this typedef.
@@ -63,6 +64,17 @@ function pathWithinAllowedPrefixes(filePath, allowedPathPrefixes) {
 }
 
 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.
+   * @returns {Promise<import("../database/drivers/base.js").default | undefined>} - Optional proxy.
+   */
+  async createTestSharedTransactionConnection({DriverClass, config, configuration, databaseIdentifier}) {
+    const brokerConfig = sharedTransactionBrokerConfig(databaseIdentifier)
+    if (!brokerConfig) return undefined
+    return createSharedTransactionProxyDriver(DriverClass, config, configuration, databaseIdentifier, brokerConfig)
+  }
+
   /**
    * Timezone async local storage.
    * @type {import("node:async_hooks").AsyncLocalStorage<TimezoneStore> | undefined} */

package/build/src/background-jobs/pooled-runner-broker-identity.d.ts

@@ -0,0 +1,44 @@
+export default class PooledRunnerBrokerIdentity {
+    closeConnections: () => Promise<void>;
+    /** @type {string | undefined} */
+    activeIdentity: string | undefined;
+    /** @type {{identity: string, promise: Promise<void>} | undefined} */
+    pending: {
+        identity: string;
+        promise: Promise<void>;
+    } | undefined;
+    activeUsers: number;
+    /**
+     * Creates a pooled runner identity coordinator.
+     * @param {{closeConnections: () => Promise<void>}} args - Connection cleanup hook.
+     */
+    constructor({ closeConnections }: {
+        closeConnections: () => Promise<void>;
+    });
+    /**
+     * Gets the current prepared identity.
+     * @returns {string | undefined} - Current prepared identity.
+     */
+    current(): string | undefined;
+    /**
+     * Prepares one identity, sharing an in-flight same-identity rotation.
+     * @param {import("../testing/shared-transaction-proxy-driver.js").SharedTransactionBrokerJobConfig} config - Dispatch configuration.
+     * @returns {Promise<void>} - Resolves after stale connections close.
+     */
+    prepare(config: import("../testing/shared-transaction-proxy-driver.js").SharedTransactionBrokerJobConfig): Promise<void>;
+    /**
+     * Runs work while preventing a different identity from replacing its connections.
+     * @template T
+     * @param {import("../testing/shared-transaction-proxy-driver.js").SharedTransactionBrokerJobConfig} config - Dispatch configuration.
+     * @param {() => Promise<T>} callback - Job callback.
+     * @returns {Promise<T>} - Job result.
+     */
+    run<T>(config: import("../testing/shared-transaction-proxy-driver.js").SharedTransactionBrokerJobConfig, callback: () => Promise<T>): Promise<T>;
+    /**
+     * Rotates retained connection state to an identity.
+     * @param {string} identity - Target identity.
+     * @returns {Promise<void>} - Resolves after rotation.
+     */
+    rotate(identity: string): Promise<void>;
+}
+//# sourceMappingURL=pooled-runner-broker-identity.d.ts.map

package/build/src/background-jobs/pooled-runner-broker-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pooled-runner-broker-identity.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/pooled-runner-broker-identity.js"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,OAAO,0BAA0B;IAMtC,gBAAgB,QAHa,OAAO,CAAC,IAAI,CAAC;IAI/C,iCAAiC;IAC5B,cAAc,EADR,MAAM,GAAG,SAAS;IAE7B,qEAAqE;IAChE,OAAO,EADD;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;KAAC,GAAG,SAAS;IAE5D,WAAW;IAVlB;;;OAGG;IACH,YAAY,EAAC,gBAAgB,EAAC,EAFnB;QAAC,gBAAgB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;KAEnB,EAO7B;IAED;;;OAGG;IACH,OAAO,IAFM,MAAM,GAAG,SAAS,CAES;IAExC;;;;OAIG;IACG,OAAO,CAAC,MAAM,EAHT,OAAO,+CAA+C,EAAE,gCAG/C,GAFP,OAAO,CAAC,IAAI,CAAC,CAsBzB;IAED;;;;;;OAMG;IACG,GAAG,CALI,CAAC,EAKJ,MAAM,EAJL,OAAO,+CAA+C,EAAE,gCAInD,EAAE,QAAQ,EAHf,MAAM,OAAO,CAAC,CAAC,CAGA,GAFb,OAAO,CAAC,CAAC,CAAC,CAUtB;IAED;;;;OAIG;IACG,MAAM,CAAC,QAAQ,EAHV,MAGU,GAFR,OAAO,CAAC,IAAI,CAAC,CAKzB;CACF"}

package/build/src/background-jobs/pooled-runner-broker-identity.js

@@ -0,0 +1,76 @@
+// @ts-check
+export default class PooledRunnerBrokerIdentity {
+    /**
+     * Creates a pooled runner identity coordinator.
+     * @param {{closeConnections: () => Promise<void>}} args - Connection cleanup hook.
+     */
+    constructor({ closeConnections }) {
+        this.closeConnections = closeConnections;
+        /** @type {string | undefined} */
+        this.activeIdentity = undefined;
+        /** @type {{identity: string, promise: Promise<void>} | undefined} */
+        this.pending = undefined;
+        this.activeUsers = 0;
+    }
+    /**
+     * Gets the current prepared identity.
+     * @returns {string | undefined} - Current prepared identity.
+     */
+    current() { return this.activeIdentity; }
+    /**
+     * Prepares one identity, sharing an in-flight same-identity rotation.
+     * @param {import("../testing/shared-transaction-proxy-driver.js").SharedTransactionBrokerJobConfig} config - Dispatch configuration.
+     * @returns {Promise<void>} - Resolves after stale connections close.
+     */
+    async prepare(config) {
+        const identity = JSON.stringify(config);
+        if (this.pending) {
+            if (this.pending.identity !== identity)
+                throw new Error("Pooled runner cannot mix shared transaction broker capabilities concurrently");
+            return await this.pending.promise;
+        }
+        if (this.activeIdentity === identity)
+            return;
+        if (this.activeUsers > 0)
+            throw new Error("Pooled runner cannot mix shared transaction broker capabilities concurrently");
+        if (this.activeIdentity === undefined) {
+            this.activeIdentity = identity;
+            return;
+        }
+        const promise = this.rotate(identity);
+        this.pending = { identity, promise };
+        try {
+            await promise;
+        }
+        finally {
+            this.pending = undefined;
+        }
+    }
+    /**
+     * Runs work while preventing a different identity from replacing its connections.
+     * @template T
+     * @param {import("../testing/shared-transaction-proxy-driver.js").SharedTransactionBrokerJobConfig} config - Dispatch configuration.
+     * @param {() => Promise<T>} callback - Job callback.
+     * @returns {Promise<T>} - Job result.
+     */
+    async run(config, callback) {
+        await this.prepare(config);
+        this.activeUsers++;
+        try {
+            return await callback();
+        }
+        finally {
+            this.activeUsers--;
+        }
+    }
+    /**
+     * Rotates retained connection state to an identity.
+     * @param {string} identity - Target identity.
+     * @returns {Promise<void>} - Resolves after rotation.
+     */
+    async rotate(identity) {
+        await this.closeConnections();
+        this.activeIdentity = identity;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/background-jobs/pooled-runner-child.js

@@ -2,6 +2,8 @@
 import runJobPayload, { BackgroundJobPerformedFailure } from "./job-runner.js";
 import { closeRunnerConnections, currentConfigurationOrNull } from "./runner-graceful-shutdown.js";
 import setRunnerProcessTitle from "./runner-process-title.js";
+import PooledRunnerBrokerIdentity from "./pooled-runner-broker-identity.js";
+import { runWithSharedTransactionBrokerConfig } from "../testing/shared-transaction-proxy-driver.js";
 const BASE_PROCESS_TITLE = "velocious background-jobs-runner";
 setRunnerProcessTitle();
 let shuttingDown = false;
@@ -27,6 +29,9 @@ async function shutdownRunner(exitCode) {
  * @type {Set<string>}
  */
 const runningJobIds = new Set();
+const brokerIdentity = new PooledRunnerBrokerIdentity({
+    closeConnections: async () => await closeRunnerConnections(currentConfigurationOrNull())
+});
 /**
  * Sets an aggregate process title from the current in-flight count. A child runs
  * jobs concurrently, so a per-job title (which `runJobPayload` would snapshot and
@@ -42,12 +47,12 @@ function updateProcessTitle() {
 /**
  * Checks whether an IPC value is a runnable pooled job message.
  * @param {ReturnType<typeof JSON.parse>} message - IPC message.
- * @returns {message is {type: "job", payload: import("./types.js").BackgroundJobPayload & {id: string}}} - Whether this is a valid job message.
+ * @returns {message is {type: "job", payload: import("./types.js").BackgroundJobPayload & {id: string}, sharedTransactionBroker?: import("../testing/shared-transaction-proxy-driver.js").SharedTransactionBrokerJobConfig}} - Whether this is a valid job message.
  */
 function isJobMessage(message) {
     if (!message || typeof message !== "object")
         return false;
-    const record = /** @type {{type?: ReturnType<typeof JSON.parse>, payload?: ReturnType<typeof JSON.parse>}} */ (message);
+    const record = /** @type {{type?: ReturnType<typeof JSON.parse>, payload?: ReturnType<typeof JSON.parse>, sharedTransactionBroker?: ReturnType<typeof JSON.parse>}} */ (message);
     return record.type === "job" && !!record.payload && typeof record.payload === "object" && typeof record.payload.id === "string";
 }
 /**
@@ -83,11 +88,16 @@ function sendOutcome({ jobId, acknowledged, status, error }) {
  * per-job try/catch) ends the child, which the worker sees as an exit and
  * reclaims for the whole in-flight set.
  * @param {import("./types.js").BackgroundJobPayload & {id: string}} payload - Job payload.
+ * @param {import("../testing/shared-transaction-proxy-driver.js").SharedTransactionBrokerJobConfig} sharedTransactionBroker - Per-job broker configuration.
  * @returns {Promise<void>} - Resolves after reporting.
  */
-async function runJob(payload) {
+async function runJob(payload, sharedTransactionBroker) {
     try {
-        const status = await runJobPayload(payload, { closeConnections: false, manageProcessTitle: false });
+        const status = await runWithSharedTransactionBrokerConfig(sharedTransactionBroker, async () => {
+            return await brokerIdentity.run(sharedTransactionBroker, async () => {
+                return await runJobPayload(payload, { closeConnections: false, manageProcessTitle: false });
+            });
+        });
         await sendOutcome({ jobId: payload.id, acknowledged: true, status });
     }
     catch (error) {
@@ -115,10 +125,10 @@ function handleMessage(message) {
         return;
     runningJobIds.add(message.payload.id);
     updateProcessTitle();
-    void runJob(message.payload);
+    void runJob(message.payload, message.sharedTransactionBroker || { expected: false });
 }
 process.on("message", (message) => handleMessage(message));
 process.once("disconnect", () => void shutdownRunner(0));
 for (const signal of ["SIGTERM", "SIGINT"])
     process.once(signal, () => void shutdownRunner(1));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pooled-runner-child.js","sourceRoot":"","sources":["../../../src/background-jobs/pooled-runner-child.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport runJobPayload, { BackgroundJobPerformedFailure } from \"./job-runner.js\"\nimport { closeRunnerConnections, currentConfigurationOrNull } from \"./runner-graceful-shutdown.js\"\nimport setRunnerProcessTitle from \"./runner-process-title.js\"\n\nconst BASE_PROCESS_TITLE = \"velocious background-jobs-runner\"\n\nsetRunnerProcessTitle()\n\nlet shuttingDown = false\n\n/**\n * Closes the runner's connections — releasing any advisory lock a killed-mid-pass\n * job still holds — before exiting, instead of leaving a half-open session that\n * keeps the lock until the DB server's `wait_timeout`.\n * @param {number} exitCode - Process exit code.\n * @returns {Promise<void>}\n */\nasync function shutdownRunner(exitCode) {\n  if (shuttingDown) return\n  shuttingDown = true\n\n  await closeRunnerConnections(currentConfigurationOrNull())\n  process.exit(exitCode)\n}\n\n/**\n * Ids of jobs currently running in this child. A pooled child runs up to\n * `pooledRunnerConcurrency` jobs at once (the worker only dispatches within that\n * bound); the set dedupes a redelivered job id and lets each job settle\n * independently.\n * @type {Set<string>}\n */\nconst runningJobIds = new Set()\n\n/**\n * Sets an aggregate process title from the current in-flight count. A child runs\n * jobs concurrently, so a per-job title (which `runJobPayload` would snapshot and\n * restore around a single job) cannot represent the process — interleaved\n * completions would leave a stale label. Recomputing from `runningJobIds.size` is\n * concurrency-safe and honest: `ps`/`top` show how many jobs the child is running.\n * @returns {void}\n */\nfunction updateProcessTitle() {\n  const count = runningJobIds.size\n\n  process.title = count > 0 ? `${BASE_PROCESS_TITLE}: ${count} ${count === 1 ? \"job\" : \"jobs\"}` : BASE_PROCESS_TITLE\n}\n\n/**\n * Checks whether an IPC value is a runnable pooled job message.\n * @param {ReturnType<typeof JSON.parse>} message - IPC message.\n * @returns {message is {type: \"job\", payload: import(\"./types.js\").BackgroundJobPayload & {id: string}}} - Whether this is a valid job message.\n */\nfunction isJobMessage(message) {\n  if (!message || typeof message !== \"object\") return false\n  const record = /** @type {{type?: ReturnType<typeof JSON.parse>, payload?: ReturnType<typeof JSON.parse>}} */ (message)\n\n  return record.type === \"job\" && !!record.payload && typeof record.payload === \"object\" && typeof record.payload.id === \"string\"\n}\n\n/**\n * Sends the terminal outcome after the main/DB report has been acknowledged or rejected.\n * @param {object} args - Outcome.\n * @param {string} args.jobId - Job id.\n * @param {boolean} args.acknowledged - Whether the terminal report was acknowledged.\n * @param {\"completed\" | \"failed\" | \"rescheduled\"} [args.status] - Acknowledged outcome.\n * @param {Error} [args.error] - Reporting error when acknowledgement was not obtained.\n * @returns {Promise<void>} - Resolves after IPC accepts the message.\n */\nfunction sendOutcome({jobId, acknowledged, status, error}) {\n  return new Promise((resolve) => {\n    if (!process.send) {\n      resolve(undefined)\n      return\n    }\n\n    process.send({\n      type: \"job-outcome\",\n      jobId,\n      acknowledged,\n      status,\n      rssBytes: process.memoryUsage().rss,\n      error: error?.message\n    }, () => resolve(undefined))\n  })\n}\n\n/**\n * Runs one job concurrently with any siblings and reports its own terminal\n * outcome. A single job's unexpected failure reports that job for reclamation\n * (`acknowledged: false`) but does NOT take down the child — its concurrent\n * siblings keep running. Only a process-level fault (which escapes every\n * per-job try/catch) ends the child, which the worker sees as an exit and\n * reclaims for the whole in-flight set.\n * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} payload - Job payload.\n * @returns {Promise<void>} - Resolves after reporting.\n */\nasync function runJob(payload) {\n  try {\n    const status = await runJobPayload(payload, {closeConnections: false, manageProcessTitle: false})\n    await sendOutcome({jobId: payload.id, acknowledged: true, status})\n  } catch (error) {\n    if (error instanceof BackgroundJobPerformedFailure) {\n      await sendOutcome({jobId: payload.id, acknowledged: true, status: \"failed\"})\n    } else {\n      const reportError = error instanceof Error ? error : new Error(String(error))\n      console.error(\"Pooled background job runner failed before terminal acknowledgement:\", reportError)\n      await sendOutcome({jobId: payload.id, acknowledged: false, error: reportError})\n    }\n  } finally {\n    runningJobIds.delete(payload.id)\n    updateProcessTitle()\n  }\n}\n\n/**\n * Handles a job message, starting it alongside any concurrent siblings.\n * @param {ReturnType<typeof JSON.parse>} message - IPC message.\n * @returns {void}\n */\nfunction handleMessage(message) {\n  if (!isJobMessage(message) || runningJobIds.has(message.payload.id)) return\n\n  runningJobIds.add(message.payload.id)\n  updateProcessTitle()\n  void runJob(message.payload)\n}\n\nprocess.on(\"message\", (message) => handleMessage(message))\nprocess.once(\"disconnect\", () => void shutdownRunner(0))\nfor (const signal of [\"SIGTERM\", \"SIGINT\"]) process.once(signal, () => void shutdownRunner(1))\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pooled-runner-child.js","sourceRoot":"","sources":["../../../src/background-jobs/pooled-runner-child.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,aAAa,EAAE,EAAE,6BAA6B,EAAE,MAAM,iBAAiB,CAAA;AAC9E,OAAO,EAAE,sBAAsB,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAA;AAClG,OAAO,qBAAqB,MAAM,2BAA2B,CAAA;AAC7D,OAAO,0BAA0B,MAAM,oCAAoC,CAAA;AAC3E,OAAO,EAAE,oCAAoC,EAAE,MAAM,+CAA+C,CAAA;AAEpG,MAAM,kBAAkB,GAAG,kCAAkC,CAAA;AAE7D,qBAAqB,EAAE,CAAA;AAEvB,IAAI,YAAY,GAAG,KAAK,CAAA;AAExB;;;;;;GAMG;AACH,KAAK,UAAU,cAAc,CAAC,QAAQ;IACpC,IAAI,YAAY;QAAE,OAAM;IACxB,YAAY,GAAG,IAAI,CAAA;IAEnB,MAAM,sBAAsB,CAAC,0BAA0B,EAAE,CAAC,CAAA;IAC1D,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;AACxB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,aAAa,GAAG,IAAI,GAAG,EAAE,CAAA;AAC/B,MAAM,cAAc,GAAG,IAAI,0BAA0B,CAAC;IACpD,gBAAgB,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,sBAAsB,CAAC,0BAA0B,EAAE,CAAC;CACzF,CAAC,CAAA;AAEF;;;;;;;GAOG;AACH,SAAS,kBAAkB;IACzB,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAA;IAEhC,OAAO,CAAC,KAAK,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,kBAAkB,KAAK,KAAK,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,kBAAkB,CAAA;AACpH,CAAC;AAED;;;;GAIG;AACH,SAAS,YAAY,CAAC,OAAO;IAC3B,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAA;IACzD,MAAM,MAAM,GAAG,uJAAuJ,CAAC,CAAC,OAAO,CAAC,CAAA;IAEhL,OAAO,MAAM,CAAC,IAAI,KAAK,KAAK,IAAI,CAAC,CAAC,MAAM,CAAC,OAAO,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,IAAI,OAAO,MAAM,CAAC,OAAO,CAAC,EAAE,KAAK,QAAQ,CAAA;AACjI,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,WAAW,CAAC,EAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAC;IACvD,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YAClB,OAAO,CAAC,SAAS,CAAC,CAAA;YAClB,OAAM;QACR,CAAC;QAED,OAAO,CAAC,IAAI,CAAC;YACX,IAAI,EAAE,aAAa;YACnB,KAAK;YACL,YAAY;YACZ,MAAM;YACN,QAAQ,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,GAAG;YACnC,KAAK,EAAE,KAAK,EAAE,OAAO;SACtB,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAA;IAC9B,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,KAAK,UAAU,MAAM,CAAC,OAAO,EAAE,uBAAuB;IACpD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,oCAAoC,CAAC,uBAAuB,EAAE,KAAK,IAAI,EAAE;YAC5F,OAAO,MAAM,cAAc,CAAC,GAAG,CAAC,uBAAuB,EAAE,KAAK,IAAI,EAAE;gBAClE,OAAO,MAAM,aAAa,CAAC,OAAO,EAAE,EAAC,gBAAgB,EAAE,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAC,CAAC,CAAA;YAC3F,CAAC,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;QACF,MAAM,WAAW,CAAC,EAAC,KAAK,EAAE,OAAO,CAAC,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAC,CAAC,CAAA;IACpE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,6BAA6B,EAAE,CAAC;YACnD,MAAM,WAAW,CAAC,EAAC,KAAK,EAAE,OAAO,CAAC,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAC,CAAC,CAAA;QAC9E,CAAC;aAAM,CAAC;YACN,MAAM,WAAW,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;YAC7E,OAAO,CAAC,KAAK,CAAC,sEAAsE,EAAE,WAAW,CAAC,CAAA;YAClG,MAAM,WAAW,CAAC,EAAC,KAAK,EAAE,OAAO,CAAC,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAC,CAAC,CAAA;QACjF,CAAC;IACH,CAAC;YAAS,CAAC;QACT,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;QAChC,kBAAkB,EAAE,CAAA;IACtB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,OAAO;IAC5B,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QAAE,OAAM;IAE3E,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IACrC,kBAAkB,EAAE,CAAA;IACpB,KAAK,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,uBAAuB,IAAI,EAAC,QAAQ,EAAE,KAAK,EAAC,CAAC,CAAA;AACpF,CAAC;AAED,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAA;AAC1D,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,GAAG,EAAE,CAAC,KAAK,cAAc,CAAC,CAAC,CAAC,CAAC,CAAA;AACxD,KAAK,MAAM,MAAM,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC;IAAE,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,KAAK,cAAc,CAAC,CAAC,CAAC,CAAC,CAAA","sourcesContent":["// @ts-check\n\nimport runJobPayload, { BackgroundJobPerformedFailure } from \"./job-runner.js\"\nimport { closeRunnerConnections, currentConfigurationOrNull } from \"./runner-graceful-shutdown.js\"\nimport setRunnerProcessTitle from \"./runner-process-title.js\"\nimport PooledRunnerBrokerIdentity from \"./pooled-runner-broker-identity.js\"\nimport { runWithSharedTransactionBrokerConfig } from \"../testing/shared-transaction-proxy-driver.js\"\n\nconst BASE_PROCESS_TITLE = \"velocious background-jobs-runner\"\n\nsetRunnerProcessTitle()\n\nlet shuttingDown = false\n\n/**\n * Closes the runner's connections — releasing any advisory lock a killed-mid-pass\n * job still holds — before exiting, instead of leaving a half-open session that\n * keeps the lock until the DB server's `wait_timeout`.\n * @param {number} exitCode - Process exit code.\n * @returns {Promise<void>}\n */\nasync function shutdownRunner(exitCode) {\n  if (shuttingDown) return\n  shuttingDown = true\n\n  await closeRunnerConnections(currentConfigurationOrNull())\n  process.exit(exitCode)\n}\n\n/**\n * Ids of jobs currently running in this child. A pooled child runs up to\n * `pooledRunnerConcurrency` jobs at once (the worker only dispatches within that\n * bound); the set dedupes a redelivered job id and lets each job settle\n * independently.\n * @type {Set<string>}\n */\nconst runningJobIds = new Set()\nconst brokerIdentity = new PooledRunnerBrokerIdentity({\n  closeConnections: async () => await closeRunnerConnections(currentConfigurationOrNull())\n})\n\n/**\n * Sets an aggregate process title from the current in-flight count. A child runs\n * jobs concurrently, so a per-job title (which `runJobPayload` would snapshot and\n * restore around a single job) cannot represent the process — interleaved\n * completions would leave a stale label. Recomputing from `runningJobIds.size` is\n * concurrency-safe and honest: `ps`/`top` show how many jobs the child is running.\n * @returns {void}\n */\nfunction updateProcessTitle() {\n  const count = runningJobIds.size\n\n  process.title = count > 0 ? `${BASE_PROCESS_TITLE}: ${count} ${count === 1 ? \"job\" : \"jobs\"}` : BASE_PROCESS_TITLE\n}\n\n/**\n * Checks whether an IPC value is a runnable pooled job message.\n * @param {ReturnType<typeof JSON.parse>} message - IPC message.\n * @returns {message is {type: \"job\", payload: import(\"./types.js\").BackgroundJobPayload & {id: string}, sharedTransactionBroker?: import(\"../testing/shared-transaction-proxy-driver.js\").SharedTransactionBrokerJobConfig}} - Whether this is a valid job message.\n */\nfunction isJobMessage(message) {\n  if (!message || typeof message !== \"object\") return false\n  const record = /** @type {{type?: ReturnType<typeof JSON.parse>, payload?: ReturnType<typeof JSON.parse>, sharedTransactionBroker?: ReturnType<typeof JSON.parse>}} */ (message)\n\n  return record.type === \"job\" && !!record.payload && typeof record.payload === \"object\" && typeof record.payload.id === \"string\"\n}\n\n/**\n * Sends the terminal outcome after the main/DB report has been acknowledged or rejected.\n * @param {object} args - Outcome.\n * @param {string} args.jobId - Job id.\n * @param {boolean} args.acknowledged - Whether the terminal report was acknowledged.\n * @param {\"completed\" | \"failed\" | \"rescheduled\"} [args.status] - Acknowledged outcome.\n * @param {Error} [args.error] - Reporting error when acknowledgement was not obtained.\n * @returns {Promise<void>} - Resolves after IPC accepts the message.\n */\nfunction sendOutcome({jobId, acknowledged, status, error}) {\n  return new Promise((resolve) => {\n    if (!process.send) {\n      resolve(undefined)\n      return\n    }\n\n    process.send({\n      type: \"job-outcome\",\n      jobId,\n      acknowledged,\n      status,\n      rssBytes: process.memoryUsage().rss,\n      error: error?.message\n    }, () => resolve(undefined))\n  })\n}\n\n/**\n * Runs one job concurrently with any siblings and reports its own terminal\n * outcome. A single job's unexpected failure reports that job for reclamation\n * (`acknowledged: false`) but does NOT take down the child — its concurrent\n * siblings keep running. Only a process-level fault (which escapes every\n * per-job try/catch) ends the child, which the worker sees as an exit and\n * reclaims for the whole in-flight set.\n * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} payload - Job payload.\n * @param {import(\"../testing/shared-transaction-proxy-driver.js\").SharedTransactionBrokerJobConfig} sharedTransactionBroker - Per-job broker configuration.\n * @returns {Promise<void>} - Resolves after reporting.\n */\nasync function runJob(payload, sharedTransactionBroker) {\n  try {\n    const status = await runWithSharedTransactionBrokerConfig(sharedTransactionBroker, async () => {\n      return await brokerIdentity.run(sharedTransactionBroker, async () => {\n        return await runJobPayload(payload, {closeConnections: false, manageProcessTitle: false})\n      })\n    })\n    await sendOutcome({jobId: payload.id, acknowledged: true, status})\n  } catch (error) {\n    if (error instanceof BackgroundJobPerformedFailure) {\n      await sendOutcome({jobId: payload.id, acknowledged: true, status: \"failed\"})\n    } else {\n      const reportError = error instanceof Error ? error : new Error(String(error))\n      console.error(\"Pooled background job runner failed before terminal acknowledgement:\", reportError)\n      await sendOutcome({jobId: payload.id, acknowledged: false, error: reportError})\n    }\n  } finally {\n    runningJobIds.delete(payload.id)\n    updateProcessTitle()\n  }\n}\n\n/**\n * Handles a job message, starting it alongside any concurrent siblings.\n * @param {ReturnType<typeof JSON.parse>} message - IPC message.\n * @returns {void}\n */\nfunction handleMessage(message) {\n  if (!isJobMessage(message) || runningJobIds.has(message.payload.id)) return\n\n  runningJobIds.add(message.payload.id)\n  updateProcessTitle()\n  void runJob(message.payload, message.sharedTransactionBroker || {expected: false})\n}\n\nprocess.on(\"message\", (message) => handleMessage(message))\nprocess.once(\"disconnect\", () => void shutdownRunner(0))\nfor (const signal of [\"SIGTERM\", \"SIGINT\"]) process.once(signal, () => void shutdownRunner(1))\n"]}