velocious 1.0.698 → 1.0.700

package/build/src/testing/velocious-attempt-executor.js

@@ -132,6 +132,20 @@ export default class VelociousAttemptExecutor {
         testArgs.registerTransactionalTenant = async (args) => {
             await testRunner.registerTransactionalTenant(args, transactionalTenantRegistrations);
         };
+        /** @type {import("./test-runner.js").TenantCleanupRegistration[]} */
+        const tenantCleanupRegistrations = [];
+        /** @type {import("./test-tenant-database-pool.js").TestTenantPoolLease[]} */
+        const testTenantPoolLeases = [];
+        testArgs.registerTenantForCleanup = (args) => {
+            testRunner.registerTenantForCleanup(args, tenantCleanupRegistrations);
+        };
+        testArgs.acquireTestTenant = async (args = {}) => {
+            const databaseIdentifier = args.databaseIdentifier ?? testRunner.singleTestTenantPoolIdentifier();
+            const pool = testRunner.getTestTenantPool(databaseIdentifier);
+            const lease = await pool.acquire({ tenant: args.tenant });
+            testTenantPoolLeases.push(lease);
+            return lease;
+        };
         const profiler = testRunner._profiler;
         const profileTestData = {
             ...test,
@@ -229,6 +243,20 @@ export default class VelociousAttemptExecutor {
                         catch (error) {
                             lifecycleErrors.push(error);
                         }
+                        try {
+                            await testRunner.cleanupTenantRegistrations(tenantCleanupRegistrations);
+                        }
+                        catch (error) {
+                            lifecycleErrors.push(error);
+                        }
+                        try {
+                            for (const lease of testTenantPoolLeases) {
+                                await testRunner.getTestTenantPool(lease.databaseIdentifier).release(lease);
+                            }
+                        }
+                        catch (error) {
+                            lifecycleErrors.push(error);
+                        }
                     }
                     if (testSharedConnectionsActive) {
                         try {
@@ -331,6 +359,20 @@ export default class VelociousAttemptExecutor {
                         testRunner.recordTimeoutCleanupFailure(cleanupError, "transactional tenant", recordedTimeoutCleanupErrors);
                     });
                 }
+                const poolRelease = (async () => {
+                    for (const lease of testTenantPoolLeases) {
+                        await testRunner.getTestTenantPool(lease.databaseIdentifier).release(lease);
+                    }
+                })();
+                const poolReleaseOutcome = await awaitSettledOrGrace(poolRelease, effectiveTimeoutMs ?? 60000);
+                if (poolReleaseOutcome.settled && poolReleaseOutcome.status === "rejected") {
+                    emergencyCleanupErrors.push(poolReleaseOutcome.reason);
+                }
+                else if (!poolReleaseOutcome.settled) {
+                    void poolRelease.catch((cleanupError) => {
+                        testRunner.recordTimeoutCleanupFailure(cleanupError, "test tenant pool lease release", recordedTimeoutCleanupErrors);
+                    });
+                }
                 if (emergencyCleanupErrors.length > 0) {
                     caughtError = new AggregateError([caughtError, ...emergencyCleanupErrors], "Test timeout and emergency cleanup failed", { cause: caughtError });
                 }
@@ -411,4 +453,4 @@ export default class VelociousAttemptExecutor {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"velocious-attempt-executor.js","sourceRoot":"","sources":["../../../src/testing/velocious-attempt-executor.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAA;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,aAAa,MAAM,6BAA6B,CAAA;AACvD,OAAO,EAAC,YAAY,IAAI,gBAAgB,EAAE,UAAU,IAAI,cAAc,EAAC,MAAM,aAAa,CAAA;AAE1F,uHAAuH;AAEvH;;;GAGG;AAEH;;;;;;GAMG;AACH,SAAS,cAAc,CAAC,OAAO,EAAE,SAAS,EAAE,eAAe;IACzD,MAAM,cAAc,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAA;IAC1E,+BAA+B;IAC/B,MAAM,YAAY,GAAG,IAAI,KAAK,CAAC,mBAAmB,cAAc,MAAM,eAAe,EAAE,CAAC,CAAA;IACxF,YAAY,CAAC,oBAAoB,GAAG,IAAI,CAAA;IAExC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,MAAM,OAAO,GAAG,cAAc,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,SAAS,CAAC,CAAA;QAErE,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YACvC,gBAAgB,CAAC,OAAO,CAAC,CAAA;YACzB,OAAO,CAAC,MAAM,CAAC,CAAA;QACjB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YACjB,gBAAgB,CAAC,OAAO,CAAC,CAAA;YACzB,MAAM,CAAC,KAAK,CAAC,CAAA;QACf,CAAC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAS,mBAAmB,CAAC,SAAS,EAAE,OAAO;IAC7C,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,IAAI,OAAO,GAAG,KAAK,CAAA;QACnB,MAAM,UAAU,GAAG,cAAc,CAAC,GAAG,EAAE;YACrC,IAAI,OAAO;gBAAE,OAAM;YAEnB,OAAO,GAAG,IAAI,CAAA;YACd,OAAO,CAAC,EAAC,OAAO,EAAE,KAAK,EAAC,CAAC,CAAA;QAC3B,CAAC,EAAE,OAAO,CAAC,CAAA;QAEX,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,IAAI,CAC7B,GAAG,EAAE;YACH,IAAI,OAAO;gBAAE,OAAM;YAEnB,OAAO,GAAG,IAAI,CAAA;YACd,gBAAgB,CAAC,UAAU,CAAC,CAAA;YAC5B,OAAO,CAAC,EAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAC,CAAC,CAAA;QAC/C,CAAC,EACD,CAAC,MAAM,EAAE,EAAE;YACT,IAAI,OAAO;gBAAE,OAAM;YAEnB,OAAO,GAAG,IAAI,CAAA;YACd,gBAAgB,CAAC,UAAU,CAAC,CAAA;YAC5B,OAAO,CAAC,EAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAC,CAAC,CAAA;QACtD,CAAC,CACF,CAAA;IACH,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;;;GAIG;AACH,SAAS,8BAA8B,CAAC,KAAK;IAC3C,IAAI,KAAK,YAAY,8BAA8B;QAAE,OAAO,IAAI,CAAA;IAChE,IAAI,KAAK,YAAY,cAAc,EAAE,CAAC;QACpC,OAAO,KAAK,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,8BAA8B,CAAC,WAAW,CAAC,CAAC,CAAA;IACpH,CAAC;IAED,OAAO,KAAK,CAAA;AACd,CAAC;AAED,MAAM,CAAC,OAAO,OAAO,wBAAwB;IAC3C;;;;OAIG;IACH,YAAY,EAAC,UAAU,EAAE,GAAG,QAAQ,EAAC;QACnC,aAAa,CAAC,QAAQ,CAAC,CAAA;QACvB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;IAC9B,CAAC;IAED;;;;OAIG;IACH,kBAAkB,CAAC,SAAS;QAC1B,OAAO,OAAO,SAAS,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAA;IAC7G,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,OAAO,CAAC,EAAC,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,QAAQ,EAAC;QAChI,aAAa,CAAC,QAAQ,CAAC,CAAA;QACvB,KAAK,OAAO,CAAA;QACZ,KAAK,cAAc,CAAA;QACnB,KAAK,KAAK,CAAA;QACV,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAA;QAClC,MAAM,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAA;QAC7D,MAAM,aAAa,GAAG,MAAM,UAAU,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAA;QAC9D,MAAM,EAAC,QAAQ,EAAE,QAAQ,EAAC,GAAG,aAAa,CAAA;QAC1C,MAAM,QAAQ,GAAG,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;QAC9C,MAAM,EAAC,YAAY,EAAE,eAAe,EAAC,GAAG,QAAQ,CAAA;QAChD,4CAA4C;QAC5C,IAAI,WAAW,CAAA;QACf,IAAI,MAAM,GAAG,KAAK,CAAA;QAClB,iEAAiE;QACjE,IAAI,aAAa,CAAA;QACjB,sJAAsJ;QACtJ,IAAI,iCAAiC,GAAG,EAAE,CAAA;QAC1C,IAAI,2BAA2B,GAAG,KAAK,CAAA;QACvC,yFAAyF;QACzF,IAAI,mCAAmC,CAAA;QACvC,yFAAyF;QACzF,IAAI,kCAAkC,CAAA;QACtC,2EAA2E;QAC3E,MAAM,gCAAgC,GAAG,EAAE,CAAA;QAC3C,8EAA8E;QAC9E,MAAM,mCAAmC,GAAG,EAAE,CAAA;QAC9C,MAAM,uBAAuB,GAAG,EAAC,OAAO,EAAE,KAAK,EAAC,CAAA;QAChD,yBAAyB;QACzB,MAAM,4BAA4B,GAAG,IAAI,GAAG,EAAE,CAAA;QAC9C,IAAI,mBAAmB,GAAG,KAAK,CAAA;QAC/B,IAAI,eAAe,GAAG,KAAK,CAAA;QAC3B,QAAQ,CAAC,2BAA2B,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE;YACpD,MAAM,UAAU,CAAC,2BAA2B,CAAC,IAAI,EAAE,gCAAgC,CAAC,CAAA;QACtF,CAAC,CAAA;QACD,MAAM,QAAQ,GAAG,UAAU,CAAC,SAAS,CAAA;QACrC,MAAM,eAAe,GAAG;YACtB,GAAG,IAAI;YACP,QAAQ,EAAE,QAAQ,CAAC,QAAQ;YAC3B,IAAI,EAAE,QAAQ,CAAC,IAAI;YACnB,aAAa,EAAE,QAAQ,CAAC,aAAa,IAAI,QAAQ,CAAC,aAAa;SAChE,CAAA;QACD,MAAM,cAAc,GAAG,QAAQ,EAAE,YAAY,CAAC;YAC5C,YAAY;YACZ,aAAa;YACb,QAAQ,EAAE,eAAe;YACzB,eAAe;SAChB,CAAC,CAAA;QAEF,IAAI,CAAC;YACH,MAAM,oBAAoB,GAAG,KAAK,IAAI,EAAE,CAAC,MAAM,UAAU,CAAC,oBAAoB,CAAC,QAAQ,EAAE,KAAK,IAAI,EAAE;gBAClG,MAAM,cAAc,GAAG,QAAQ,CAAC,gBAAgB,EAAE,WAAW,KAAK,IAAI,CAAA;gBACtE,MAAM,cAAc,GAAG,QAAQ,CAAC,gBAAgB,EAAE,QAAQ,IAAI,CAAC,cAAc,CAAA;gBAC7E,MAAM,wBAAwB,GAAG,cAAc,IAAI,QAAQ,CAAC,IAAI,IAAI,SAAS,CAAA;gBAC7E,MAAM,kBAAkB,GAAG,wBAAwB,IAAI,cAAc,CAAA;gBACrE,MAAM,cAAc,GAAG,KAAK,IAAI,EAAE;oBAChC,IAAI,wBAAwB,EAAE,CAAC;wBAC7B,iCAAiC,GAAG,UAAU,CAAC,6BAA6B,EAAE,CAAA;wBAC9E,2BAA2B,GAAG,IAAI,CAAA;oBACpC,CAAC;oBACD,8CAA8C;oBAC9C,MAAM,eAAe,GAAG,EAAE,CAAA;oBAC1B,IAAI,eAAe,GAAG,KAAK,CAAA;oBAE3B,IAAI,CAAC;wBACH,IAAI,wBAAwB,EAAE,CAAC;4BAC7B,kCAAkC,GAAG,MAAM,UAAU,CAAC,8BAA8B,EAAE,CAAA;wBACxF,CAAC;wBACD,eAAe,GAAG,IAAI,CAAA;wBAEtB,eAAe,EAAE,CAAA;wBACjB,MAAM,IAAI,CAAC,eAAe,CAAC,EAAC,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAC,CAAC,CAAA;wBAE1E,IAAI,wBAAwB,EAAE,CAAC;4BAC7B,MAAM,iBAAiB,GAAG,UAAU,CAAC,4BAA4B,CAAC,EAAC,gBAAgB,EAAE,IAAI,EAAC,CAAC,CAAA;4BAC3F,IAAI,kCAAkC,IAAI,CAAC,UAAU,CAAC,yCAAyC,CAAC,kCAAkC,EAAE,iBAAiB,CAAC,EAAE,CAAC;gCACvJ,UAAU,CAAC,0BAA0B,CAAC,iCAAiC,CAAC,CAAA;gCACxE,iCAAiC,GAAG,EAAE,CAAA;gCACtC,2BAA2B,GAAG,KAAK,CAAA;4BACrC,CAAC;4BAED,mCAAmC,GAAG,MAAM,UAAU,CAAC,4BAA4B,CAAC,kCAAkC,EAAE,iBAAiB,CAAC,CAAA;4BAC1I,kCAAkC,GAAG,SAAS,CAAA;4BAC9C,IAAI,mCAAmC,IAAI,CAAC,2BAA2B,EAAE,CAAC;gCACxE,iCAAiC,GAAG,UAAU,CAAC,6BAA6B,EAAE,CAAA;gCAC9E,2BAA2B,GAAG,IAAI,CAAA;4BACpC,CAAC;wBACH,CAAC;wBAED,UAAU,CAAC,gBAAgB,GAAG;4BAC5B,eAAe,EAAE,QAAQ;4BACzB,QAAQ,EAAE,QAAQ,CAAC,QAAQ,IAAI,WAAW;4BAC1C,IAAI,EAAE,QAAQ,CAAC,IAAI,IAAI,CAAC;yBACzB,CAAA;wBACD,MAAM,UAAU,CAAC,cAAc,CAAC,EAAC,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,CAAC,aAAa,IAAI,QAAQ,CAAC,QAAQ,EAAC,EAAE,KAAK,IAAI,EAAE;4BACtH,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAA;wBAC9B,CAAC,CAAC,CAAA;oBACJ,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;oBAC7B,CAAC;oBAED,IAAI,eAAe,EAAE,CAAC;wBACpB,IAAI,CAAC;4BACH,MAAM,UAAU,CAAC,gBAAgB,EAAE,CAAC,sBAAsB,EAAE,CAAA;wBAC9D,CAAC;wBAAC,OAAO,KAAK,EAAE,CAAC;4BACf,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;wBAC7B,CAAC;wBAED,IAAI,CAAC;4BACH,IAAI,2BAA2B,EAAE,CAAC;gCAChC,UAAU,CAAC,0BAA0B,CAAC,iCAAiC,CAAC,CAAA;gCACxE,iCAAiC,GAAG,EAAE,CAAA;gCACtC,2BAA2B,GAAG,KAAK,CAAA;4BACrC,CAAC;wBACH,CAAC;wBAAC,OAAO,KAAK,EAAE,CAAC;4BACf,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;wBAC7B,CAAC;wBAED,IAAI,CAAC;4BACH,MAAM,UAAU,CAAC,2BAA2B,CAAC,mCAAmC,IAAI,kCAAkC,CAAC,CAAA;4BACvH,mCAAmC,GAAG,SAAS,CAAA;4BAC/C,kCAAkC,GAAG,SAAS,CAAA;wBAChD,CAAC;wBAAC,OAAO,KAAK,EAAE,CAAC;4BACf,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;wBAC7B,CAAC;wBAED,IAAI,CAAC;4BACH,MAAM,IAAI,CAAC,cAAc,CAAC,EAAC,WAAW,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAC,CAAC,CAAA;wBACxF,CAAC;wBAAC,OAAO,KAAK,EAAE,CAAC;4BACf,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;wBAC7B,CAAC;wBAED,IAAI,CAAC;4BACH,MAAM,UAAU,CAAC,2BAA2B,CAAC,gCAAgC,CAAC,CAAA;wBAChF,CAAC;wBAAC,OAAO,KAAK,EAAE,CAAC;4BACf,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;wBAC7B,CAAC;oBACH,CAAC;oBAED,IAAI,2BAA2B,EAAE,CAAC;wBAChC,IAAI,CAAC;4BACH,UAAU,CAAC,0BAA0B,CAAC,iCAAiC,CAAC,CAAA;wBAC1E,CAAC;wBAAC,OAAO,KAAK,EAAE,CAAC;4BACf,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;wBAC7B,CAAC;wBACD,2BAA2B,GAAG,KAAK,CAAA;oBACrC,CAAC;oBAED,IAAI,eAAe,CAAC,MAAM,IAAI,CAAC;wBAAE,MAAM,eAAe,CAAC,CAAC,CAAC,CAAA;oBACzD,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;wBAC/B,MAAM,IAAI,cAAc,CAAC,eAAe,EAAE,mCAAmC,EAAE,EAAC,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,EAAC,CAAC,CAAA;oBAC7G,CAAC;gBACH,CAAC,CAAA;gBAED,IAAI,kBAAkB,EAAE,CAAC;oBACvB,MAAM,UAAU,CAAC,gBAAgB,EAAE,CAAC,iBAAiB,CAAC,EAAC,IAAI,EAAE,SAAS,eAAe,EAAE,EAAC,EAAE,cAAc,CAAC,CAAA;gBAC3G,CAAC;qBAAM,CAAC;oBACN,MAAM,cAAc,EAAE,CAAA;gBACxB,CAAC;YACH,CAAC,EAAE,mCAAmC,CAAC,CAAA;YACvC,MAAM,iBAAiB,GAAG,KAAK,IAAI,EAAE,CAAC,MAAM,UAAU,CAAC,gBAAgB,EAAE,CAAC,8BAA8B,CAAC,uBAAuB,EAAE,oBAAoB,CAAC,CAAA;YACvJ,aAAa,GAAG,cAAc,IAAI,QAAQ;gBACxC,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,cAAc,EAAE,iBAAiB,CAAC;gBACxD,CAAC,CAAC,iBAAiB,EAAE,CAAA;YAEvB,IAAI,kBAAkB,KAAK,SAAS,EAAE,CAAC;gBACrC,MAAM,cAAc,CAAC,aAAa,EAAE,kBAAkB,EAAE,eAAe,CAAC,CAAA;YAC1E,CAAC;iBAAM,CAAC;gBACN,MAAM,aAAa,CAAA;YACrB,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,GAAG,IAAI,CAAA;YACb,WAAW,GAAG,KAAK,CAAA;YACnB,MAAM,QAAQ,GAAG,OAAO,CAAC,+BAA+B,CAAC,CAAC,KAAK,CAAC,EAAE,oBAAoB,CAAC,CAAA;YACvF,eAAe,GAAG,QAAQ,CAAA;YAE1B,IAAI,QAAQ,IAAI,aAAa,EAAE,CAAC;gBAC9B,MAAM,sBAAsB,GAAG,EAAE,CAAA;gBAEjC,IAAI,cAAc,IAAI,QAAQ;oBAAE,QAAQ,CAAC,aAAa,CAAC,cAAc,EAAE,WAAW,CAAC,CAAA;gBACnF,MAAM,gBAAgB,GAAG,MAAM,mBAAmB,CAAC,aAAa,EAAE,kBAAkB,IAAI,KAAK,CAAC,CAAA;gBAE9F,IAAI,gBAAgB,CAAC,OAAO,IAAI,gBAAgB,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;oBACvE,sBAAsB,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAA;gBACtD,CAAC;gBAED,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;oBAC9B,uBAAuB,CAAC,OAAO,GAAG,IAAI,CAAA;oBACtC,KAAK,aAAa,CAAC,KAAK,CAAC,CAAC,YAAY,EAAE,EAAE;wBACxC,IAAI,8BAA8B,CAAC,YAAY,CAAC;4BAAE,OAAM;wBACxD,UAAU,CAAC,2BAA2B,CAAC,YAAY,EAAE,gBAAgB,EAAE,4BAA4B,CAAC,CAAA;oBACtG,CAAC,CAAC,CAAA;oBACF,MAAM,UAAU,GAAG,UAAU,CAAC,iCAAiC,CAAC,mCAAmC,CAAC,CAAA;oBACpG,MAAM,iBAAiB,GAAG,MAAM,mBAAmB,CAAC,UAAU,EAAE,kBAAkB,IAAI,KAAK,CAAC,CAAA;oBAC5F,MAAM,uBAAuB,GAAG,QAAQ,CAAC,gBAAgB,EAAE,WAAW,KAAK,IAAI,CAAA;oBAC/E,MAAM,qBAAqB,GAAG,QAAQ,CAAC,gBAAgB,EAAE,QAAQ,IAAI,CAAC,uBAAuB,CAAA;oBAE7F,mBAAmB,GAAG,UAAU,CAAC,iBAAiB,EAAE;2BAC/C,UAAU,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC;2BACpC,CAAC,uBAAuB,IAAI,qBAAqB,CAAC,CAAA;oBAEvD,IAAI,iBAAiB,CAAC,OAAO,IAAI,iBAAiB,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;wBACzE,sBAAsB,CAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAA;oBACvD,CAAC;yBAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,CAAC;wBACtC,KAAK,UAAU,CAAC,KAAK,CAAC,CAAC,YAAY,EAAE,EAAE;4BACrC,UAAU,CAAC,2BAA2B,CAAC,YAAY,EAAE,qCAAqC,EAAE,4BAA4B,CAAC,CAAA;wBAC3H,CAAC,CAAC,CAAA;oBACJ,CAAC;gBACH,CAAC;gBAED,IAAI,CAAC;oBACH,IAAI,2BAA2B,EAAE,CAAC;wBAChC,UAAU,CAAC,0BAA0B,CAAC,iCAAiC,CAAC,CAAA;wBACxE,iCAAiC,GAAG,EAAE,CAAA;wBACtC,2BAA2B,GAAG,KAAK,CAAA;oBACrC,CAAC;gBACH,CAAC;gBAAC,OAAO,YAAY,EAAE,CAAC;oBACtB,sBAAsB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;gBAC3C,CAAC;gBAED,MAAM,aAAa,GAAG,UAAU,CAAC,2BAA2B,CAAC,mCAAmC,IAAI,kCAAkC,CAAC,CAAA;gBACvI,MAAM,oBAAoB,GAAG,MAAM,mBAAmB,CAAC,aAAa,EAAE,kBAAkB,IAAI,KAAK,CAAC,CAAA;gBAElG,IAAI,oBAAoB,CAAC,OAAO,IAAI,oBAAoB,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;oBAC/E,sBAAsB,CAAC,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAA;gBAC1D,CAAC;qBAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,EAAE,CAAC;oBACzC,KAAK,aAAa,CAAC,KAAK,CAAC,CAAC,YAAY,EAAE,EAAE;wBACxC,UAAU,CAAC,2BAA2B,CAAC,YAAY,EAAE,2BAA2B,EAAE,4BAA4B,CAAC,CAAA;oBACjH,CAAC,CAAC,CAAA;gBACJ,CAAC;gBACD,mCAAmC,GAAG,SAAS,CAAA;gBAC/C,kCAAkC,GAAG,SAAS,CAAA;gBAC9C,MAAM,gBAAgB,GAAG,UAAU,CAAC,2BAA2B,CAAC,gCAAgC,EAAE,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC,CAAA;gBAClH,MAAM,uBAAuB,GAAG,MAAM,mBAAmB,CAAC,gBAAgB,EAAE,kBAAkB,IAAI,KAAK,CAAC,CAAA;gBAExG,IAAI,uBAAuB,CAAC,OAAO,IAAI,uBAAuB,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;oBACrF,sBAAsB,CAAC,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAA;gBAC7D,CAAC;qBAAM,IAAI,CAAC,uBAAuB,CAAC,OAAO,EAAE,CAAC;oBAC5C,KAAK,gBAAgB,CAAC,KAAK,CAAC,CAAC,YAAY,EAAE,EAAE;wBAC3C,UAAU,CAAC,2BAA2B,CAAC,YAAY,EAAE,sBAAsB,EAAE,4BAA4B,CAAC,CAAA;oBAC5G,CAAC,CAAC,CAAA;gBACJ,CAAC;gBAED,IAAI,sBAAsB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACtC,WAAW,GAAG,IAAI,cAAc,CAC9B,CAAC,WAAW,EAAE,GAAG,sBAAsB,CAAC,EACxC,2CAA2C,EAC3C,EAAC,KAAK,EAAE,WAAW,EAAC,CACrB,CAAA;gBACH,CAAC;YACH,CAAC;YAED,IAAI,mCAAmC,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,WAAW,CAAC,EAAE,CAAC;gBACzF,uBAAuB,CAAC,OAAO,GAAG,IAAI,CAAA;gBACtC,mBAAmB,GAAG,IAAI,CAAA;YAC5B,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,uBAAuB,CAAC,OAAO,GAAG,IAAI,CAAA;YAEtC,IAAI,cAAc,IAAI,QAAQ,EAAE,CAAC;gBAC/B,QAAQ,CAAC,aAAa,CAAC,cAAc,EAAE,MAAM;oBAC3C,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,QAAQ,CAAC;oBAC5C,CAAC,CAAC,QAAQ,CAAC,CAAA;YACf,CAAC;QACH,CAAC;QAED,UAAU,CAAC,oBAAoB,CAAC,IAAI,EAAE,aAAa,EAAE;YACnD,mBAAmB;YACnB,KAAK,EAAE,WAAW;YAClB,MAAM;SACP,CAAC,CAAA;QAEF,IAAI,MAAM;YAAE,MAAM,WAAW,CAAA;IAC/B,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,eAAe,CAAC,EAAC,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAC;QACtD,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;YAChC,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;YAEnD,MAAM,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC;gBACnC,KAAK,EAAE,YAAY;gBACnB,gBAAgB,EAAE,QAAQ,CAAC,gBAAgB;gBAC3C,kBAAkB,EAAE,QAAQ,CAAC,kBAAkB;gBAC/C,QAAQ,EAAE,QAAQ,CAAC,aAAa;aACjC,EAAE,KAAK,IAAI,EAAE;gBACZ,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAC,aAAa,EAAE,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAC,CAAC,CAAA;YAC9F,CAAC,CAAC,CAAA;QACJ,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,cAAc,CAAC,EAAC,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAC;QACpD,8CAA8C;QAC9C,MAAM,MAAM,GAAG,EAAE,CAAA;QAEjB,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;YAC/B,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;YAEnD,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC;oBACnC,KAAK,EAAE,WAAW;oBAClB,gBAAgB,EAAE,QAAQ,CAAC,gBAAgB;oBAC3C,kBAAkB,EAAE,QAAQ,CAAC,kBAAkB;oBAC/C,QAAQ,EAAE,QAAQ,CAAC,aAAa;iBACjC,EAAE,KAAK,IAAI,EAAE;oBACZ,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAC,aAAa,EAAE,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAC,CAAC,CAAA;gBAC9F,CAAC,CAAC,CAAA;YACJ,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YACpB,CAAC;QACH,CAAC;QAED,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC;YAAE,MAAM,MAAM,CAAC,CAAC,CAAC,CAAA;QACvC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACtB,MAAM,IAAI,cAAc,CAAC,MAAM,EAAE,iCAAiC,EAAE,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,EAAC,CAAC,CAAA;QACzF,CAAC;IACH,CAAC;CACF","sourcesContent":["// @ts-check\n\nimport { TestDatabaseAccessRevokedError } from \"../environment-handlers/base.js\"\nimport { clearDeliveries } from \"../mailer.js\"\nimport restArgsError from \"../utils/rest-args-error.js\"\nimport {clearTimeout as realClearTimeout, setTimeout as realSetTimeout} from \"node:timers\"\n\n/** @typedef {import(\"@velocious/testing/runner\").AttemptExecutorInput[\"beforeEach\"][number]} PackageHookDeclaration */\n\n/**\n * Marks one whole-lifecycle timeout while its underlying promise keeps running.\n * @typedef {Error & {velociousTestTimeout?: true}} TestTimeoutError\n */\n\n/**\n * Runs one promise with a lifecycle timeout.\n * @param {Promise<ReturnType<typeof JSON.parse>> | ReturnType<typeof JSON.parse>} promise - Promise or value.\n * @param {number} timeoutMs - Timeout in milliseconds.\n * @param {string} testDescription - Test description.\n * @returns {Promise<ReturnType<typeof JSON.parse>>} - Lifecycle result.\n */\nfunction runWithTimeout(promise, timeoutMs, testDescription) {\n  const timeoutSeconds = (timeoutMs / 1000).toFixed(3).replace(/\\.?0+$/, \"\")\n  /** @type {TestTimeoutError} */\n  const timeoutError = new Error(`Timed out after ${timeoutSeconds}s: ${testDescription}`)\n  timeoutError.velociousTestTimeout = true\n\n  return new Promise((resolve, reject) => {\n    const timeout = realSetTimeout(() => reject(timeoutError), timeoutMs)\n\n    Promise.resolve(promise).then((result) => {\n      realClearTimeout(timeout)\n      resolve(result)\n    }).catch((error) => {\n      realClearTimeout(timeout)\n      reject(error)\n    })\n  })\n}\n\n/**\n * Waits for detached lifecycle cleanup up to the timeout grace period.\n * @param {Promise<ReturnType<typeof JSON.parse>>} lifecycle - Detached lifecycle promise.\n * @param {number} graceMs - Maximum wait.\n * @returns {Promise<{settled: false} | {settled: true, status: \"fulfilled\"} | {settled: true, status: \"rejected\", reason: ReturnType<typeof JSON.parse>}>} - Settlement outcome.\n */\nfunction awaitSettledOrGrace(lifecycle, graceMs) {\n  return new Promise((resolve) => {\n    let settled = false\n    const graceTimer = realSetTimeout(() => {\n      if (settled) return\n\n      settled = true\n      resolve({settled: false})\n    }, graceMs)\n\n    Promise.resolve(lifecycle).then(\n      () => {\n        if (settled) return\n\n        settled = true\n        realClearTimeout(graceTimer)\n        resolve({settled: true, status: \"fulfilled\"})\n      },\n      (reason) => {\n        if (settled) return\n\n        settled = true\n        realClearTimeout(graceTimer)\n        resolve({settled: true, status: \"rejected\", reason})\n      }\n    )\n  })\n}\n\n/**\n * Checks whether a late lifecycle stopped only because its attempt access was revoked.\n * @param {ReturnType<typeof JSON.parse>} error - Lifecycle rejection.\n * @returns {boolean} - Whether every contained error is expected revocation.\n */\nfunction isTestDatabaseAccessRevocation(error) {\n  if (error instanceof TestDatabaseAccessRevokedError) return true\n  if (error instanceof AggregateError) {\n    return error.errors.length > 0 && error.errors.every((nestedError) => isTestDatabaseAccessRevocation(nestedError))\n  }\n\n  return false\n}\n\nexport default class VelociousAttemptExecutor {\n  /**\n   * Creates an executor for framework-owned attempt lifecycle work.\n   * @param {object} args - Constructor arguments.\n   * @param {import(\"./test-runner.js\").default} args.testRunner - Owning Velocious runner.\n   */\n  constructor({testRunner, ...restArgs}) {\n    restArgsError(restArgs)\n    this.testRunner = testRunner\n  }\n\n  /**\n   * Normalizes the legacy timeout contract at the framework adapter boundary.\n   * @param {number | undefined} timeoutMs - Declared package timeout.\n   * @returns {number | undefined} - Positive finite timeout, or no timeout.\n   */\n  normalizeTimeoutMs(timeoutMs) {\n    return typeof timeoutMs === \"number\" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined\n  }\n\n  /**\n   * Executes exactly one complete Velocious-owned test attempt.\n   * @param {import(\"@velocious/testing/runner\").AttemptExecutorInput} input - Package attempt.\n   * @returns {Promise<void>} - Resolves after one complete framework attempt.\n   */\n  async execute({afterEach, args, attemptNumber, beforeEach, context, defaultExecute, fullName, suite, test, timeoutMs, ...restArgs}) {\n    restArgsError(restArgs)\n    void context\n    void defaultExecute\n    void suite\n    const testRunner = this.testRunner\n    const effectiveTimeoutMs = this.normalizeTimeoutMs(timeoutMs)\n    const compatibility = await testRunner.testCompatibility(test)\n    const {testArgs, testData} = compatibility\n    const metadata = testRunner.testMetadata(test)\n    const {descriptions, testDescription} = metadata\n    /** @type {ReturnType<typeof JSON.parse>} */\n    let caughtError\n    let failed = false\n    /** @type {Promise<ReturnType<typeof JSON.parse>> | undefined} */\n    let testLifecycle\n    /** @type {{pool: import(\"../database/pool/base.js\").default, registration: import(\"../database/pool/base.js\").TestSharedConnectionRegistration}[]} */\n    let testSharedConnectionRegistrations = []\n    let testSharedConnectionsActive = false\n    /** @type {import(\"./test-runner.js\").SharedTransactionBrokerRegistration | undefined} */\n    let sharedTransactionBrokerRegistration\n    /** @type {import(\"./test-runner.js\").SharedTransactionBrokerRegistration | undefined} */\n    let sharedTransactionBrokerPreparation\n    /** @type {import(\"./test-runner.js\").TransactionalTenantRegistration[]} */\n    const transactionalTenantRegistrations = []\n    /** @type {import(\"./test-runner.js\").BrowserDummyConnectionRegistration[]} */\n    const browserDummyConnectionRegistrations = []\n    const testDatabaseAccessScope = {revoked: false}\n    /** @type {Set<Error>} */\n    const recordedTimeoutCleanupErrors = new Set()\n    let abortRemainingTests = false\n    let attemptTimedOut = false\n    testArgs.registerTransactionalTenant = async (args) => {\n      await testRunner.registerTransactionalTenant(args, transactionalTenantRegistrations)\n    }\n    const profiler = testRunner._profiler\n    const profileTestData = {\n      ...test,\n      filePath: testData.filePath,\n      line: testData.line,\n      ownerFilePath: testData.ownerFilePath ?? metadata.ownerFilePath\n    }\n    const profileAttempt = profiler?.startAttempt({\n      descriptions,\n      attemptNumber,\n      testData: profileTestData,\n      testDescription\n    })\n\n    try {\n      const runLifecycleCallback = async () => await testRunner.runWithDummyIfNeeded(testArgs, async () => {\n        const useTransaction = testArgs.databaseCleaning?.transaction === true\n        const shouldTruncate = testArgs.databaseCleaning?.truncate ?? !useTransaction\n        const useSharedTestConnections = useTransaction || testArgs.type == \"request\"\n        const useTestConnections = useSharedTestConnections || shouldTruncate\n        const runTestAttempt = async () => {\n          if (useSharedTestConnections) {\n            testSharedConnectionRegistrations = testRunner.activateTestSharedConnections()\n            testSharedConnectionsActive = true\n          }\n          /** @type {ReturnType<typeof JSON.parse>[]} */\n          const lifecycleErrors = []\n          let runCleanupHooks = false\n\n          try {\n            if (useSharedTestConnections) {\n              sharedTransactionBrokerPreparation = await testRunner.prepareSharedTransactionBroker()\n            }\n            runCleanupHooks = true\n\n            clearDeliveries()\n            await this.runBeforeEaches({beforeEaches: beforeEach, testArgs, testData})\n\n            if (useSharedTestConnections) {\n              const activeConnections = testRunner.sharedTransactionConnections({transactionsOnly: true})\n              if (sharedTransactionBrokerPreparation && !testRunner.sharedTransactionBrokerMatchesConnections(sharedTransactionBrokerPreparation, activeConnections)) {\n                testRunner.clearTestSharedConnections(testSharedConnectionRegistrations)\n                testSharedConnectionRegistrations = []\n                testSharedConnectionsActive = false\n              }\n\n              sharedTransactionBrokerRegistration = await testRunner.startSharedTransactionBroker(sharedTransactionBrokerPreparation, activeConnections)\n              sharedTransactionBrokerPreparation = undefined\n              if (sharedTransactionBrokerRegistration && !testSharedConnectionsActive) {\n                testSharedConnectionRegistrations = testRunner.activateTestSharedConnections()\n                testSharedConnectionsActive = true\n              }\n            }\n\n            testRunner._lastTestContext = {\n              fullDescription: fullName,\n              filePath: testData.filePath ?? \"<unknown>\",\n              line: testData.line ?? 0\n            }\n            await testRunner.runProfileSpan({phase: \"test body\", filePath: testData.ownerFilePath ?? testData.filePath}, async () => {\n              await test.callback(...args)\n            })\n          } catch (error) {\n            lifecycleErrors.push(error)\n          }\n\n          if (runCleanupHooks) {\n            try {\n              await testRunner.getConfiguration().awaitPendingBroadcasts()\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n\n            try {\n              if (testSharedConnectionsActive) {\n                testRunner.clearTestSharedConnections(testSharedConnectionRegistrations)\n                testSharedConnectionRegistrations = []\n                testSharedConnectionsActive = false\n              }\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n\n            try {\n              await testRunner.stopSharedTransactionBroker(sharedTransactionBrokerRegistration || sharedTransactionBrokerPreparation)\n              sharedTransactionBrokerRegistration = undefined\n              sharedTransactionBrokerPreparation = undefined\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n\n            try {\n              await this.runAfterEaches({afterEaches: [...afterEach].reverse(), testArgs, testData})\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n\n            try {\n              await testRunner.cleanupTransactionalTenants(transactionalTenantRegistrations)\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n          }\n\n          if (testSharedConnectionsActive) {\n            try {\n              testRunner.clearTestSharedConnections(testSharedConnectionRegistrations)\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n            testSharedConnectionsActive = false\n          }\n\n          if (lifecycleErrors.length == 1) throw lifecycleErrors[0]\n          if (lifecycleErrors.length > 1) {\n            throw new AggregateError(lifecycleErrors, \"Test lifecycle and cleanup failed\", {cause: lifecycleErrors[0]})\n          }\n        }\n\n        if (useTestConnections) {\n          await testRunner.getConfiguration().ensureConnections({name: `Test: ${testDescription}`}, runTestAttempt)\n        } else {\n          await runTestAttempt()\n        }\n      }, browserDummyConnectionRegistrations)\n      const lifecycleCallback = async () => await testRunner.getConfiguration().runWithTestDatabaseAccessScope(testDatabaseAccessScope, runLifecycleCallback)\n      testLifecycle = profileAttempt && profiler\n        ? profiler.runAttempt(profileAttempt, lifecycleCallback)\n        : lifecycleCallback()\n\n      if (effectiveTimeoutMs !== undefined) {\n        await runWithTimeout(testLifecycle, effectiveTimeoutMs, testDescription)\n      } else {\n        await testLifecycle\n      }\n    } catch (error) {\n      failed = true\n      caughtError = error\n      const timedOut = Boolean(/** @type {TestTimeoutError} */ (error)?.velociousTestTimeout)\n      attemptTimedOut = timedOut\n\n      if (timedOut && testLifecycle) {\n        const emergencyCleanupErrors = []\n\n        if (profileAttempt && profiler) profiler.finishAttempt(profileAttempt, \"timed-out\")\n        const lifecycleOutcome = await awaitSettledOrGrace(testLifecycle, effectiveTimeoutMs ?? 60000)\n\n        if (lifecycleOutcome.settled && lifecycleOutcome.status === \"rejected\") {\n          emergencyCleanupErrors.push(lifecycleOutcome.reason)\n        }\n\n        if (!lifecycleOutcome.settled) {\n          testDatabaseAccessScope.revoked = true\n          void testLifecycle.catch((cleanupError) => {\n            if (isTestDatabaseAccessRevocation(cleanupError)) return\n            testRunner.recordTimeoutCleanupFailure(cleanupError, \"test lifecycle\", recordedTimeoutCleanupErrors)\n          })\n          const quarantine = testRunner.quarantineBrowserDummyConnections(browserDummyConnectionRegistrations)\n          const quarantineOutcome = await awaitSettledOrGrace(quarantine, effectiveTimeoutMs ?? 60000)\n          const usesBrowserTransactions = testArgs.databaseCleaning?.transaction === true\n          const usesBrowserTruncation = testArgs.databaseCleaning?.truncate ?? !usesBrowserTransactions\n\n          abortRemainingTests = testRunner.isBrowserTestMode()\n            && testRunner.hasTag(testArgs, \"dummy\")\n            && (usesBrowserTransactions || usesBrowserTruncation)\n\n          if (quarantineOutcome.settled && quarantineOutcome.status === \"rejected\") {\n            emergencyCleanupErrors.push(quarantineOutcome.reason)\n          } else if (!quarantineOutcome.settled) {\n            void quarantine.catch((cleanupError) => {\n              testRunner.recordTimeoutCleanupFailure(cleanupError, \"browser dummy connection quarantine\", recordedTimeoutCleanupErrors)\n            })\n          }\n        }\n\n        try {\n          if (testSharedConnectionsActive) {\n            testRunner.clearTestSharedConnections(testSharedConnectionRegistrations)\n            testSharedConnectionRegistrations = []\n            testSharedConnectionsActive = false\n          }\n        } catch (cleanupError) {\n          emergencyCleanupErrors.push(cleanupError)\n        }\n\n        const brokerCleanup = testRunner.stopSharedTransactionBroker(sharedTransactionBrokerRegistration || sharedTransactionBrokerPreparation)\n        const brokerCleanupOutcome = await awaitSettledOrGrace(brokerCleanup, effectiveTimeoutMs ?? 60000)\n\n        if (brokerCleanupOutcome.settled && brokerCleanupOutcome.status === \"rejected\") {\n          emergencyCleanupErrors.push(brokerCleanupOutcome.reason)\n        } else if (!brokerCleanupOutcome.settled) {\n          void brokerCleanup.catch((cleanupError) => {\n            testRunner.recordTimeoutCleanupFailure(cleanupError, \"shared transaction broker\", recordedTimeoutCleanupErrors)\n          })\n        }\n        sharedTransactionBrokerRegistration = undefined\n        sharedTransactionBrokerPreparation = undefined\n        const emergencyCleanup = testRunner.cleanupTransactionalTenants(transactionalTenantRegistrations, {discard: true})\n        const emergencyCleanupOutcome = await awaitSettledOrGrace(emergencyCleanup, effectiveTimeoutMs ?? 60000)\n\n        if (emergencyCleanupOutcome.settled && emergencyCleanupOutcome.status === \"rejected\") {\n          emergencyCleanupErrors.push(emergencyCleanupOutcome.reason)\n        } else if (!emergencyCleanupOutcome.settled) {\n          void emergencyCleanup.catch((cleanupError) => {\n            testRunner.recordTimeoutCleanupFailure(cleanupError, \"transactional tenant\", recordedTimeoutCleanupErrors)\n          })\n        }\n\n        if (emergencyCleanupErrors.length > 0) {\n          caughtError = new AggregateError(\n            [caughtError, ...emergencyCleanupErrors],\n            \"Test timeout and emergency cleanup failed\",\n            {cause: caughtError}\n          )\n        }\n      }\n\n      if (browserDummyConnectionRegistrations.some((registration) => registration.quarantined)) {\n        testDatabaseAccessScope.revoked = true\n        abortRemainingTests = true\n      }\n    } finally {\n      testDatabaseAccessScope.revoked = true\n\n      if (profileAttempt && profiler) {\n        profiler.finishAttempt(profileAttempt, failed\n          ? (attemptTimedOut ? \"timed-out\" : \"failed\")\n          : \"passed\")\n      }\n    }\n\n    testRunner.recordAttemptOutcome(test, attemptNumber, {\n      abortRemainingTests,\n      error: caughtError,\n      failed\n    })\n\n    if (failed) throw caughtError\n  }\n\n  /**\n   * Runs before-each hooks in inherited declaration order.\n   * @param {object} args - Hook arguments.\n   * @param {PackageHookDeclaration[]} args.beforeEaches - Setup hooks.\n   * @param {import(\"./velocious-test-arguments.js\").TestArgs} args.testArgs - Stable test arguments.\n   * @param {import(\"./velocious-test-arguments.js\").TestData} args.testData - Test registration.\n   * @returns {Promise<void>} - Resolves after all setup hooks complete.\n   */\n  async runBeforeEaches({beforeEaches, testArgs, testData}) {\n    for (const hook of beforeEaches) {\n      const metadata = this.testRunner.hookMetadata(hook)\n\n      await this.testRunner.runProfileSpan({\n        phase: \"beforeEach\",\n        declarationIndex: metadata.declarationIndex,\n        declarationScopeId: metadata.declarationScopeId,\n        filePath: metadata.ownerFilePath\n      }, async () => {\n        await hook.callback({configuration: this.testRunner.getConfiguration(), testArgs, testData})\n      })\n    }\n  }\n\n  /**\n   * Runs every after-each hook while preserving all failures.\n   * @param {object} args - Hook arguments.\n   * @param {PackageHookDeclaration[]} args.afterEaches - Cleanup hooks.\n   * @param {import(\"./velocious-test-arguments.js\").TestArgs} args.testArgs - Stable test arguments.\n   * @param {import(\"./velocious-test-arguments.js\").TestData} args.testData - Test registration.\n   * @returns {Promise<void>} - Resolves after every cleanup hook settles.\n   */\n  async runAfterEaches({afterEaches, testArgs, testData}) {\n    /** @type {ReturnType<typeof JSON.parse>[]} */\n    const errors = []\n\n    for (const hook of afterEaches) {\n      const metadata = this.testRunner.hookMetadata(hook)\n\n      try {\n        await this.testRunner.runProfileSpan({\n          phase: \"afterEach\",\n          declarationIndex: metadata.declarationIndex,\n          declarationScopeId: metadata.declarationScopeId,\n          filePath: metadata.ownerFilePath\n        }, async () => {\n          await hook.callback({configuration: this.testRunner.getConfiguration(), testArgs, testData})\n        })\n      } catch (error) {\n        errors.push(error)\n      }\n    }\n\n    if (errors.length == 1) throw errors[0]\n    if (errors.length > 1) {\n      throw new AggregateError(errors, \"Multiple afterEach hooks failed\", {cause: errors[0]})\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"velocious-attempt-executor.js","sourceRoot":"","sources":["../../../src/testing/velocious-attempt-executor.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport { TestDatabaseAccessRevokedError } from \"../environment-handlers/base.js\"\nimport { clearDeliveries } from \"../mailer.js\"\nimport restArgsError from \"../utils/rest-args-error.js\"\nimport {clearTimeout as realClearTimeout, setTimeout as realSetTimeout} from \"node:timers\"\n\n/** @typedef {import(\"@velocious/testing/runner\").AttemptExecutorInput[\"beforeEach\"][number]} PackageHookDeclaration */\n\n/**\n * Marks one whole-lifecycle timeout while its underlying promise keeps running.\n * @typedef {Error & {velociousTestTimeout?: true}} TestTimeoutError\n */\n\n/**\n * Runs one promise with a lifecycle timeout.\n * @param {Promise<ReturnType<typeof JSON.parse>> | ReturnType<typeof JSON.parse>} promise - Promise or value.\n * @param {number} timeoutMs - Timeout in milliseconds.\n * @param {string} testDescription - Test description.\n * @returns {Promise<ReturnType<typeof JSON.parse>>} - Lifecycle result.\n */\nfunction runWithTimeout(promise, timeoutMs, testDescription) {\n  const timeoutSeconds = (timeoutMs / 1000).toFixed(3).replace(/\\.?0+$/, \"\")\n  /** @type {TestTimeoutError} */\n  const timeoutError = new Error(`Timed out after ${timeoutSeconds}s: ${testDescription}`)\n  timeoutError.velociousTestTimeout = true\n\n  return new Promise((resolve, reject) => {\n    const timeout = realSetTimeout(() => reject(timeoutError), timeoutMs)\n\n    Promise.resolve(promise).then((result) => {\n      realClearTimeout(timeout)\n      resolve(result)\n    }).catch((error) => {\n      realClearTimeout(timeout)\n      reject(error)\n    })\n  })\n}\n\n/**\n * Waits for detached lifecycle cleanup up to the timeout grace period.\n * @param {Promise<ReturnType<typeof JSON.parse>>} lifecycle - Detached lifecycle promise.\n * @param {number} graceMs - Maximum wait.\n * @returns {Promise<{settled: false} | {settled: true, status: \"fulfilled\"} | {settled: true, status: \"rejected\", reason: ReturnType<typeof JSON.parse>}>} - Settlement outcome.\n */\nfunction awaitSettledOrGrace(lifecycle, graceMs) {\n  return new Promise((resolve) => {\n    let settled = false\n    const graceTimer = realSetTimeout(() => {\n      if (settled) return\n\n      settled = true\n      resolve({settled: false})\n    }, graceMs)\n\n    Promise.resolve(lifecycle).then(\n      () => {\n        if (settled) return\n\n        settled = true\n        realClearTimeout(graceTimer)\n        resolve({settled: true, status: \"fulfilled\"})\n      },\n      (reason) => {\n        if (settled) return\n\n        settled = true\n        realClearTimeout(graceTimer)\n        resolve({settled: true, status: \"rejected\", reason})\n      }\n    )\n  })\n}\n\n/**\n * Checks whether a late lifecycle stopped only because its attempt access was revoked.\n * @param {ReturnType<typeof JSON.parse>} error - Lifecycle rejection.\n * @returns {boolean} - Whether every contained error is expected revocation.\n */\nfunction isTestDatabaseAccessRevocation(error) {\n  if (error instanceof TestDatabaseAccessRevokedError) return true\n  if (error instanceof AggregateError) {\n    return error.errors.length > 0 && error.errors.every((nestedError) => isTestDatabaseAccessRevocation(nestedError))\n  }\n\n  return false\n}\n\nexport default class VelociousAttemptExecutor {\n  /**\n   * Creates an executor for framework-owned attempt lifecycle work.\n   * @param {object} args - Constructor arguments.\n   * @param {import(\"./test-runner.js\").default} args.testRunner - Owning Velocious runner.\n   */\n  constructor({testRunner, ...restArgs}) {\n    restArgsError(restArgs)\n    this.testRunner = testRunner\n  }\n\n  /**\n   * Normalizes the legacy timeout contract at the framework adapter boundary.\n   * @param {number | undefined} timeoutMs - Declared package timeout.\n   * @returns {number | undefined} - Positive finite timeout, or no timeout.\n   */\n  normalizeTimeoutMs(timeoutMs) {\n    return typeof timeoutMs === \"number\" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined\n  }\n\n  /**\n   * Executes exactly one complete Velocious-owned test attempt.\n   * @param {import(\"@velocious/testing/runner\").AttemptExecutorInput} input - Package attempt.\n   * @returns {Promise<void>} - Resolves after one complete framework attempt.\n   */\n  async execute({afterEach, args, attemptNumber, beforeEach, context, defaultExecute, fullName, suite, test, timeoutMs, ...restArgs}) {\n    restArgsError(restArgs)\n    void context\n    void defaultExecute\n    void suite\n    const testRunner = this.testRunner\n    const effectiveTimeoutMs = this.normalizeTimeoutMs(timeoutMs)\n    const compatibility = await testRunner.testCompatibility(test)\n    const {testArgs, testData} = compatibility\n    const metadata = testRunner.testMetadata(test)\n    const {descriptions, testDescription} = metadata\n    /** @type {ReturnType<typeof JSON.parse>} */\n    let caughtError\n    let failed = false\n    /** @type {Promise<ReturnType<typeof JSON.parse>> | undefined} */\n    let testLifecycle\n    /** @type {{pool: import(\"../database/pool/base.js\").default, registration: import(\"../database/pool/base.js\").TestSharedConnectionRegistration}[]} */\n    let testSharedConnectionRegistrations = []\n    let testSharedConnectionsActive = false\n    /** @type {import(\"./test-runner.js\").SharedTransactionBrokerRegistration | undefined} */\n    let sharedTransactionBrokerRegistration\n    /** @type {import(\"./test-runner.js\").SharedTransactionBrokerRegistration | undefined} */\n    let sharedTransactionBrokerPreparation\n    /** @type {import(\"./test-runner.js\").TransactionalTenantRegistration[]} */\n    const transactionalTenantRegistrations = []\n    /** @type {import(\"./test-runner.js\").BrowserDummyConnectionRegistration[]} */\n    const browserDummyConnectionRegistrations = []\n    const testDatabaseAccessScope = {revoked: false}\n    /** @type {Set<Error>} */\n    const recordedTimeoutCleanupErrors = new Set()\n    let abortRemainingTests = false\n    let attemptTimedOut = false\n    testArgs.registerTransactionalTenant = async (args) => {\n      await testRunner.registerTransactionalTenant(args, transactionalTenantRegistrations)\n    }\n    /** @type {import(\"./test-runner.js\").TenantCleanupRegistration[]} */\n    const tenantCleanupRegistrations = []\n    /** @type {import(\"./test-tenant-database-pool.js\").TestTenantPoolLease[]} */\n    const testTenantPoolLeases = []\n    testArgs.registerTenantForCleanup = (args) => {\n      testRunner.registerTenantForCleanup(args, tenantCleanupRegistrations)\n    }\n    testArgs.acquireTestTenant = async (args = {}) => {\n      const databaseIdentifier = args.databaseIdentifier ?? testRunner.singleTestTenantPoolIdentifier()\n      const pool = testRunner.getTestTenantPool(databaseIdentifier)\n      const lease = await pool.acquire({tenant: args.tenant})\n      testTenantPoolLeases.push(lease)\n\n      return lease\n    }\n    const profiler = testRunner._profiler\n    const profileTestData = {\n      ...test,\n      filePath: testData.filePath,\n      line: testData.line,\n      ownerFilePath: testData.ownerFilePath ?? metadata.ownerFilePath\n    }\n    const profileAttempt = profiler?.startAttempt({\n      descriptions,\n      attemptNumber,\n      testData: profileTestData,\n      testDescription\n    })\n\n    try {\n      const runLifecycleCallback = async () => await testRunner.runWithDummyIfNeeded(testArgs, async () => {\n        const useTransaction = testArgs.databaseCleaning?.transaction === true\n        const shouldTruncate = testArgs.databaseCleaning?.truncate ?? !useTransaction\n        const useSharedTestConnections = useTransaction || testArgs.type == \"request\"\n        const useTestConnections = useSharedTestConnections || shouldTruncate\n        const runTestAttempt = async () => {\n          if (useSharedTestConnections) {\n            testSharedConnectionRegistrations = testRunner.activateTestSharedConnections()\n            testSharedConnectionsActive = true\n          }\n          /** @type {ReturnType<typeof JSON.parse>[]} */\n          const lifecycleErrors = []\n          let runCleanupHooks = false\n\n          try {\n            if (useSharedTestConnections) {\n              sharedTransactionBrokerPreparation = await testRunner.prepareSharedTransactionBroker()\n            }\n            runCleanupHooks = true\n\n            clearDeliveries()\n            await this.runBeforeEaches({beforeEaches: beforeEach, testArgs, testData})\n\n            if (useSharedTestConnections) {\n              const activeConnections = testRunner.sharedTransactionConnections({transactionsOnly: true})\n              if (sharedTransactionBrokerPreparation && !testRunner.sharedTransactionBrokerMatchesConnections(sharedTransactionBrokerPreparation, activeConnections)) {\n                testRunner.clearTestSharedConnections(testSharedConnectionRegistrations)\n                testSharedConnectionRegistrations = []\n                testSharedConnectionsActive = false\n              }\n\n              sharedTransactionBrokerRegistration = await testRunner.startSharedTransactionBroker(sharedTransactionBrokerPreparation, activeConnections)\n              sharedTransactionBrokerPreparation = undefined\n              if (sharedTransactionBrokerRegistration && !testSharedConnectionsActive) {\n                testSharedConnectionRegistrations = testRunner.activateTestSharedConnections()\n                testSharedConnectionsActive = true\n              }\n            }\n\n            testRunner._lastTestContext = {\n              fullDescription: fullName,\n              filePath: testData.filePath ?? \"<unknown>\",\n              line: testData.line ?? 0\n            }\n            await testRunner.runProfileSpan({phase: \"test body\", filePath: testData.ownerFilePath ?? testData.filePath}, async () => {\n              await test.callback(...args)\n            })\n          } catch (error) {\n            lifecycleErrors.push(error)\n          }\n\n          if (runCleanupHooks) {\n            try {\n              await testRunner.getConfiguration().awaitPendingBroadcasts()\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n\n            try {\n              if (testSharedConnectionsActive) {\n                testRunner.clearTestSharedConnections(testSharedConnectionRegistrations)\n                testSharedConnectionRegistrations = []\n                testSharedConnectionsActive = false\n              }\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n\n            try {\n              await testRunner.stopSharedTransactionBroker(sharedTransactionBrokerRegistration || sharedTransactionBrokerPreparation)\n              sharedTransactionBrokerRegistration = undefined\n              sharedTransactionBrokerPreparation = undefined\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n\n            try {\n              await this.runAfterEaches({afterEaches: [...afterEach].reverse(), testArgs, testData})\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n\n            try {\n              await testRunner.cleanupTransactionalTenants(transactionalTenantRegistrations)\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n\n            try {\n              await testRunner.cleanupTenantRegistrations(tenantCleanupRegistrations)\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n\n            try {\n              for (const lease of testTenantPoolLeases) {\n                await testRunner.getTestTenantPool(lease.databaseIdentifier).release(lease)\n              }\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n          }\n\n          if (testSharedConnectionsActive) {\n            try {\n              testRunner.clearTestSharedConnections(testSharedConnectionRegistrations)\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n            testSharedConnectionsActive = false\n          }\n\n          if (lifecycleErrors.length == 1) throw lifecycleErrors[0]\n          if (lifecycleErrors.length > 1) {\n            throw new AggregateError(lifecycleErrors, \"Test lifecycle and cleanup failed\", {cause: lifecycleErrors[0]})\n          }\n        }\n\n        if (useTestConnections) {\n          await testRunner.getConfiguration().ensureConnections({name: `Test: ${testDescription}`}, runTestAttempt)\n        } else {\n          await runTestAttempt()\n        }\n      }, browserDummyConnectionRegistrations)\n      const lifecycleCallback = async () => await testRunner.getConfiguration().runWithTestDatabaseAccessScope(testDatabaseAccessScope, runLifecycleCallback)\n      testLifecycle = profileAttempt && profiler\n        ? profiler.runAttempt(profileAttempt, lifecycleCallback)\n        : lifecycleCallback()\n\n      if (effectiveTimeoutMs !== undefined) {\n        await runWithTimeout(testLifecycle, effectiveTimeoutMs, testDescription)\n      } else {\n        await testLifecycle\n      }\n    } catch (error) {\n      failed = true\n      caughtError = error\n      const timedOut = Boolean(/** @type {TestTimeoutError} */ (error)?.velociousTestTimeout)\n      attemptTimedOut = timedOut\n\n      if (timedOut && testLifecycle) {\n        const emergencyCleanupErrors = []\n\n        if (profileAttempt && profiler) profiler.finishAttempt(profileAttempt, \"timed-out\")\n        const lifecycleOutcome = await awaitSettledOrGrace(testLifecycle, effectiveTimeoutMs ?? 60000)\n\n        if (lifecycleOutcome.settled && lifecycleOutcome.status === \"rejected\") {\n          emergencyCleanupErrors.push(lifecycleOutcome.reason)\n        }\n\n        if (!lifecycleOutcome.settled) {\n          testDatabaseAccessScope.revoked = true\n          void testLifecycle.catch((cleanupError) => {\n            if (isTestDatabaseAccessRevocation(cleanupError)) return\n            testRunner.recordTimeoutCleanupFailure(cleanupError, \"test lifecycle\", recordedTimeoutCleanupErrors)\n          })\n          const quarantine = testRunner.quarantineBrowserDummyConnections(browserDummyConnectionRegistrations)\n          const quarantineOutcome = await awaitSettledOrGrace(quarantine, effectiveTimeoutMs ?? 60000)\n          const usesBrowserTransactions = testArgs.databaseCleaning?.transaction === true\n          const usesBrowserTruncation = testArgs.databaseCleaning?.truncate ?? !usesBrowserTransactions\n\n          abortRemainingTests = testRunner.isBrowserTestMode()\n            && testRunner.hasTag(testArgs, \"dummy\")\n            && (usesBrowserTransactions || usesBrowserTruncation)\n\n          if (quarantineOutcome.settled && quarantineOutcome.status === \"rejected\") {\n            emergencyCleanupErrors.push(quarantineOutcome.reason)\n          } else if (!quarantineOutcome.settled) {\n            void quarantine.catch((cleanupError) => {\n              testRunner.recordTimeoutCleanupFailure(cleanupError, \"browser dummy connection quarantine\", recordedTimeoutCleanupErrors)\n            })\n          }\n        }\n\n        try {\n          if (testSharedConnectionsActive) {\n            testRunner.clearTestSharedConnections(testSharedConnectionRegistrations)\n            testSharedConnectionRegistrations = []\n            testSharedConnectionsActive = false\n          }\n        } catch (cleanupError) {\n          emergencyCleanupErrors.push(cleanupError)\n        }\n\n        const brokerCleanup = testRunner.stopSharedTransactionBroker(sharedTransactionBrokerRegistration || sharedTransactionBrokerPreparation)\n        const brokerCleanupOutcome = await awaitSettledOrGrace(brokerCleanup, effectiveTimeoutMs ?? 60000)\n\n        if (brokerCleanupOutcome.settled && brokerCleanupOutcome.status === \"rejected\") {\n          emergencyCleanupErrors.push(brokerCleanupOutcome.reason)\n        } else if (!brokerCleanupOutcome.settled) {\n          void brokerCleanup.catch((cleanupError) => {\n            testRunner.recordTimeoutCleanupFailure(cleanupError, \"shared transaction broker\", recordedTimeoutCleanupErrors)\n          })\n        }\n        sharedTransactionBrokerRegistration = undefined\n        sharedTransactionBrokerPreparation = undefined\n        const emergencyCleanup = testRunner.cleanupTransactionalTenants(transactionalTenantRegistrations, {discard: true})\n        const emergencyCleanupOutcome = await awaitSettledOrGrace(emergencyCleanup, effectiveTimeoutMs ?? 60000)\n\n        if (emergencyCleanupOutcome.settled && emergencyCleanupOutcome.status === \"rejected\") {\n          emergencyCleanupErrors.push(emergencyCleanupOutcome.reason)\n        } else if (!emergencyCleanupOutcome.settled) {\n          void emergencyCleanup.catch((cleanupError) => {\n            testRunner.recordTimeoutCleanupFailure(cleanupError, \"transactional tenant\", recordedTimeoutCleanupErrors)\n          })\n        }\n\n        const poolRelease = (async () => {\n          for (const lease of testTenantPoolLeases) {\n            await testRunner.getTestTenantPool(lease.databaseIdentifier).release(lease)\n          }\n        })()\n        const poolReleaseOutcome = await awaitSettledOrGrace(poolRelease, effectiveTimeoutMs ?? 60000)\n\n        if (poolReleaseOutcome.settled && poolReleaseOutcome.status === \"rejected\") {\n          emergencyCleanupErrors.push(poolReleaseOutcome.reason)\n        } else if (!poolReleaseOutcome.settled) {\n          void poolRelease.catch((cleanupError) => {\n            testRunner.recordTimeoutCleanupFailure(cleanupError, \"test tenant pool lease release\", recordedTimeoutCleanupErrors)\n          })\n        }\n\n        if (emergencyCleanupErrors.length > 0) {\n          caughtError = new AggregateError(\n            [caughtError, ...emergencyCleanupErrors],\n            \"Test timeout and emergency cleanup failed\",\n            {cause: caughtError}\n          )\n        }\n      }\n\n      if (browserDummyConnectionRegistrations.some((registration) => registration.quarantined)) {\n        testDatabaseAccessScope.revoked = true\n        abortRemainingTests = true\n      }\n    } finally {\n      testDatabaseAccessScope.revoked = true\n\n      if (profileAttempt && profiler) {\n        profiler.finishAttempt(profileAttempt, failed\n          ? (attemptTimedOut ? \"timed-out\" : \"failed\")\n          : \"passed\")\n      }\n    }\n\n    testRunner.recordAttemptOutcome(test, attemptNumber, {\n      abortRemainingTests,\n      error: caughtError,\n      failed\n    })\n\n    if (failed) throw caughtError\n  }\n\n  /**\n   * Runs before-each hooks in inherited declaration order.\n   * @param {object} args - Hook arguments.\n   * @param {PackageHookDeclaration[]} args.beforeEaches - Setup hooks.\n   * @param {import(\"./velocious-test-arguments.js\").TestArgs} args.testArgs - Stable test arguments.\n   * @param {import(\"./velocious-test-arguments.js\").TestData} args.testData - Test registration.\n   * @returns {Promise<void>} - Resolves after all setup hooks complete.\n   */\n  async runBeforeEaches({beforeEaches, testArgs, testData}) {\n    for (const hook of beforeEaches) {\n      const metadata = this.testRunner.hookMetadata(hook)\n\n      await this.testRunner.runProfileSpan({\n        phase: \"beforeEach\",\n        declarationIndex: metadata.declarationIndex,\n        declarationScopeId: metadata.declarationScopeId,\n        filePath: metadata.ownerFilePath\n      }, async () => {\n        await hook.callback({configuration: this.testRunner.getConfiguration(), testArgs, testData})\n      })\n    }\n  }\n\n  /**\n   * Runs every after-each hook while preserving all failures.\n   * @param {object} args - Hook arguments.\n   * @param {PackageHookDeclaration[]} args.afterEaches - Cleanup hooks.\n   * @param {import(\"./velocious-test-arguments.js\").TestArgs} args.testArgs - Stable test arguments.\n   * @param {import(\"./velocious-test-arguments.js\").TestData} args.testData - Test registration.\n   * @returns {Promise<void>} - Resolves after every cleanup hook settles.\n   */\n  async runAfterEaches({afterEaches, testArgs, testData}) {\n    /** @type {ReturnType<typeof JSON.parse>[]} */\n    const errors = []\n\n    for (const hook of afterEaches) {\n      const metadata = this.testRunner.hookMetadata(hook)\n\n      try {\n        await this.testRunner.runProfileSpan({\n          phase: \"afterEach\",\n          declarationIndex: metadata.declarationIndex,\n          declarationScopeId: metadata.declarationScopeId,\n          filePath: metadata.ownerFilePath\n        }, async () => {\n          await hook.callback({configuration: this.testRunner.getConfiguration(), testArgs, testData})\n        })\n      } catch (error) {\n        errors.push(error)\n      }\n    }\n\n    if (errors.length == 1) throw errors[0]\n    if (errors.length > 1) {\n      throw new AggregateError(errors, \"Multiple afterEach hooks failed\", {cause: errors[0]})\n    }\n  }\n}\n"]}

package/build/testing/test-runner.js

@@ -8,6 +8,7 @@ import { slowestTestResults } from "@velocious/testing/reporters"
 import { TestRunner as PackageTestRunner } from "@velocious/testing/runner"
 import Application from "../../src/application.js"
 import RequestClient from "./request-client.js"
+import Tenant from "../tenants/tenant.js"
 import picocolors from "picocolors"
 import restArgsError from "../utils/rest-args-error.js"
 import { testConfig } from "./test.js"
@@ -17,6 +18,7 @@ import { SHARED_TRANSACTION_BROKER_ENV } from "./shared-transaction-proxy-driver
 import VelociousAttemptExecutor from "./velocious-attempt-executor.js"
 import VelociousRunnerReporter, { AbortRemainingTestsError } from "./velocious-runner-reporter.js"
 import VelociousSuiteHookExecutor from "./velocious-suite-hook-executor.js"
+import TestTenantDatabasePool from "./test-tenant-database-pool.js"
 import VelociousTestArguments from "./velocious-test-arguments.js"
 
 /** @typedef {typeof defaultTestContext} PackageTestContext */
@@ -48,6 +50,18 @@ import VelociousTestArguments from "./velocious-test-arguments.js"
  * @property {number} [timeoutSeconds] - Timeout in seconds for the test.
  * @property {string} [type] - Test type identifier.
  * @property {(args: {databaseIdentifier: string, tenant: object}) => Promise<void>} [registerTransactionalTenant] - Registers one resolved tenant database transaction for this attempt.
+ * @property {(args?: {databaseIdentifier?: string, tenant?: object}) => Promise<TestTenantPoolLease>} [acquireTestTenant] - Leases one member of the configured test tenant database pool for this attempt (opt-in `testTenantPools` configuration).
+ * @property {(args: {databaseIdentifier: string, tenant: object}) => void} [registerTenantForCleanup] - Registers one active tenant database for the framework-owned end-of-attempt cleanup (drop + provider hooks) without hand-rolled afterEach bookkeeping.
+ */
+/**
+ * TestTenantPoolLease type (re-exported from the pool for TestArgs consumers).
+ * @typedef {import("./test-tenant-database-pool.js").TestTenantPoolLease} TestTenantPoolLease
+ */
+/**
+ * TenantCleanupRegistration type.
+ * @typedef {object} TenantCleanupRegistration
+ * @property {string} databaseIdentifier - Tenant database identifier to drop at attempt end.
+ * @property {ReturnType<typeof JSON.parse>} tenant - Tenant descriptor whose database must be dropped.
  */
 /**
  * BrowserDummyConnectionRegistration type.
@@ -201,6 +215,10 @@ export default class TestRunner {
     this._setupFiles = setupFiles || []
     this._timeoutMs = timeoutMs
     this._abortRemainingTests = false
+    /** @type {Map<string, TestTenantDatabasePool>} */
+    this._testTenantPools = new Map()
+    /** @type {Promise<void> | undefined} */
+    this._testTenantPoolTeardownPromise = undefined
 
     this._failedTests = 0
     this._successfulTests = 0
@@ -632,6 +650,81 @@ export default class TestRunner {
     return this._application
   }
 
+  /**
+   * Resolves the pool identifier when exactly one `testTenantPools` entry is
+   * configured, so `acquireTestTenant()` can omit it. Ambiguous or missing
+   * configuration fails loudly instead of guessing.
+   * @returns {string} - The single configured pool identifier.
+   */
+  singleTestTenantPoolIdentifier() {
+    const identifiers = Object.keys(this.getConfiguration().getTestTenantPools() || {})
+
+    if (identifiers.length === 0) {
+      throw new Error("acquireTestTenant requires a databaseIdentifier when no testTenantPools configuration is present")
+    }
+    if (identifiers.length > 1) {
+      throw new Error(`acquireTestTenant requires a databaseIdentifier when multiple testTenantPools are configured: ${identifiers.join(", ")}`)
+    }
+
+    return identifiers[0]
+  }
+
+  /**
+   * Returns the test tenant database pool for one configured `testTenantPools`
+   * identifier, creating it on first use. Throws when the identifier has no pool
+   * configuration — the pool stays strictly opt-in.
+   * @param {string} databaseIdentifier - Tenant database identifier.
+   * @returns {TestTenantDatabasePool} - The runner-owned pool.
+   */
+  getTestTenantPool(databaseIdentifier) {
+    const existingPool = this._testTenantPools.get(databaseIdentifier)
+
+    if (existingPool) return existingPool
+
+    const poolConfiguration = this.getConfiguration().getTestTenantPools()?.[databaseIdentifier]
+
+    if (!poolConfiguration) {
+      throw new Error(`No testTenantPools configuration for database identifier: ${databaseIdentifier}`)
+    }
+
+    const pool = new TestTenantDatabasePool({
+      configuration: this.getConfiguration(),
+      databaseIdentifier,
+      poolConfiguration
+    })
+    this._testTenantPools.set(databaseIdentifier, pool)
+
+    return pool
+  }
+
+  /**
+   * Tears down every test tenant database pool created during this run, exactly once.
+   * Safe to call from afterAll-style teardown and from the runner's own cleanup; the
+   * same promise is shared by concurrent callers.
+   * @returns {Promise<void>} - Resolves after all pools dropped their databases.
+   */
+  teardownTestTenantPools() {
+    this._testTenantPoolTeardownPromise ??= (async () => {
+      const pools = [...this._testTenantPools.values()]
+      this._testTenantPools.clear()
+
+      const errors = []
+
+      for (const pool of pools) {
+        try {
+          await pool.teardown()
+        } catch (error) {
+          errors.push(error)
+        }
+      }
+
+      if (errors.length === 1) throw errors[0]
+      if (errors.length > 1) throw new AggregateError(errors, "Failed to tear down test tenant database pools")
+    })()
+
+    return this._testTenantPoolTeardownPromise
+  }
+
   /**
    * Registers each non-tenant per-test connection as a dynamic candidate for in-process
    * request sharing. The pool evaluates transaction state when each request is dispatched,
@@ -822,6 +915,52 @@ export default class TestRunner {
     if (errors.length > 1) throw new AggregateError(errors, "Failed to clean up a transactional tenant test connection")
   }
 
+  /**
+   * Registers one tenant database for framework-owned end-of-attempt cleanup. The
+   * registration drops the tenant's database through the provider's `dropDatabase`
+   * hook (or the framework default) after the attempt's afterEach hooks and
+   * transactional tenant rollbacks finished, so consuming apps do not hand-roll a
+   * Map/afterEach bookkeeping layer for DDL that a test transaction cannot roll back.
+   * @param {{databaseIdentifier: string, tenant: object}} args - Tenant database identifier and tenant descriptor to drop at attempt end.
+   * @param {TenantCleanupRegistration[]} registrations - Current attempt registrations.
+   * @returns {void} - No return value.
+   */
+  registerTenantForCleanup({databaseIdentifier, tenant, ...restArgs}, registrations) {
+    restArgsError(restArgs)
+    if (!databaseIdentifier) throw new Error("registerTenantForCleanup requires a databaseIdentifier")
+    if (!tenant) throw new Error("registerTenantForCleanup requires a tenant")
+
+    const databaseConfiguration = this.getConfiguration().resolveDatabaseConfiguration(databaseIdentifier, tenant)
+
+    if (!databaseConfiguration.tenantOnly) {
+      throw new Error(`registerTenantForCleanup requires a tenantOnly database: ${databaseIdentifier}`)
+    }
+
+    registrations.push({databaseIdentifier, tenant})
+  }
+
+  /**
+   * Drops every tenant database registered for this attempt, in registration order.
+   * Each drop is attempted even when an earlier one failed; failures are surfaced
+   * (single error or AggregateError), never swallowed.
+   * @param {TenantCleanupRegistration[]} registrations - Attempt-owned registrations.
+   * @returns {Promise<void>} - Resolves after all registered tenants were dropped.
+   */
+  async cleanupTenantRegistrations(registrations) {
+    const errors = []
+
+    for (const {databaseIdentifier, tenant} of registrations) {
+      try {
+        await Tenant.drop({identifier: databaseIdentifier, tenant, configuration: this.getConfiguration()})
+      } catch (error) {
+        errors.push(error)
+      }
+    }
+
+    if (errors.length === 1) throw errors[0]
+    if (errors.length > 1) throw new AggregateError(errors, "Failed to drop tenant databases registered for cleanup")
+  }
+
   /**
    * Selects the current non-tenant connections eligible for shared transaction work.
    * @param {{transactionsOnly: boolean}} args - Selection options.
@@ -1374,6 +1513,12 @@ export default class TestRunner {
     } finally {
       process.off("unhandledRejection", onUnhandledRejection)
       process.off("uncaughtException", onUncaughtException)
+
+      try {
+        await this.teardownTestTenantPools()
+      } catch (error) {
+        this.recordTimeoutCleanupFailure(error, "test tenant pool teardown")
+      }
     }
   }
 
@@ -1385,6 +1530,13 @@ export default class TestRunner {
     const failureStart = this._suiteHookFailures.length
 
     await this._packageRunner?.cleanupActiveSuites()
+
+    try {
+      await this.teardownTestTenantPools()
+    } catch (error) {
+      this.recordTimeoutCleanupFailure(error, "test tenant pool teardown")
+    }
+
     this.throwAfterAllFailures(this._suiteHookFailures.slice(failureStart))
   }