jest-doctor 0.0.3 → 0.0.5

package/dist/createEnvMixin.d.ts

@@ -55,6 +55,7 @@ declare const createEnvMixin: <EnvironmentConstructor extends JestDoctorConstruc
             totalDelay: number;
         };
         tearDownError?: Error;
+        asyncIdToPromise: Map<number, Promise<unknown>>;
         setup(): Promise<void>;
         handleEvent(event: unknown, state: unknown): Promise<void>;
         handleTestEvent: JestEnvironment["handleTestEvent"];

package/dist/createEnvMixin.js

@@ -21,7 +21,7 @@ const hook_1 = __importDefault(require("./patch/hook"));
 const getAllAfterEach_1 = __importDefault(require("./utils/getAllAfterEach"));
 const normalizeOptions_1 = __importDefault(require("./utils/normalizeOptions"));
 const getReporterTmpDir_1 = __importDefault(require("./utils/getReporterTmpDir"));
-const promise_1 = __importDefault(require("./patch/promise"));
+const promiseConcurrency_1 = __importDefault(require("./patch/promiseConcurrency"));
 const createEnvMixin = (Environment) => {
     // @ts-expect-error strange ts rule where constructor arguments should be any[] where again TypeScript complains
     return class Base extends Environment {
@@ -38,6 +38,7 @@ const createEnvMixin = (Environment) => {
         testPath;
         aggregatedReport;
         tearDownError;
+        asyncIdToPromise = new Map();
         constructor(config, context) {
             super(config, context);
             this.testPath = context.testPath.replace(/\W/g, '_');
@@ -55,8 +56,7 @@ const createEnvMixin = (Environment) => {
                 : '';
             this.options = (0, normalizeOptions_1.default)(config.projectConfig.testEnvironmentOptions);
             (0, initLeakRecord_1.default)(this, consts_1.MAIN_THREAD);
-            if (this.options.report.promises &&
-                this.options.report.promises.patch === 'async_hooks') {
+            if (this.options.report.promises) {
                 this.asyncHookCleaner = (0, createAsyncHookCleaner_1.default)(this);
                 this.asyncHookDetector = (0, createAsyncHookDetector_1.default)(this);
             }
@@ -72,8 +72,8 @@ const createEnvMixin = (Environment) => {
             if (report.console) {
                 (0, console_1.default)(this, report.console);
             }
-            if (report.promises && report.promises.patch === 'promise') {
-                (0, promise_1.default)(this);
+            if (report.promises) {
+                (0, promiseConcurrency_1.default)(this);
             }
         }
         // unfortunately @jest/types doesn't export the necessary types,
@@ -99,6 +99,14 @@ const createEnvMixin = (Environment) => {
                 (0, hook_1.default)(this, 'beforeAll');
                 (0, hook_1.default)(this, 'afterEach');
                 (0, hook_1.default)(this, 'afterAll');
+                Object.assign(circusEvent.runtimeGlobals, {
+                    it: this.global.it,
+                    test: this.global.test,
+                    beforeEach: this.global.beforeEach,
+                    beforeAll: this.global.beforeAll,
+                    afterEach: this.global.afterEach,
+                    afterAll: this.global.afterAll,
+                });
             }
             await super.handleEvent?.(circusEvent, circusState);
         }

package/dist/env/jsdom.d.ts

@@ -33,6 +33,7 @@ declare const _default: {
             totalDelay: number;
         };
         tearDownError?: Error;
+        asyncIdToPromise: Map<number, Promise<unknown>>;
         setup(): Promise<void>;
         handleEvent(event: unknown, state: unknown): Promise<void>;
         handleTestEvent: import("@jest/environment").JestEnvironment["handleTestEvent"];

package/dist/env/node.d.ts

@@ -33,6 +33,7 @@ declare const _default: {
             totalDelay: number;
         };
         tearDownError?: Error;
+        asyncIdToPromise: Map<number, Promise<unknown>>;
         setup(): Promise<void>;
         handleEvent(event: unknown, state: unknown): Promise<void>;
         handleTestEvent: import("@jest/environment").JestEnvironment["handleTestEvent"];

package/dist/patch/console.js

@@ -24,7 +24,7 @@ const patchConsole = (that, consoleOptions) => {
             if (!(0, exports.isIgnored)(message, consoleOptions.ignore)) {
                 that.leakRecords.get(that.currentTestName)?.console.push({
                     method: consoleMethod,
-                    stack: (0, getStack_1.default)(env.console[consoleMethod]),
+                    stack: (0, getStack_1.default)(env.console[consoleMethod], 'Console.' + consoleMethod),
                     testName: that.currentTestName,
                     message,
                 });

package/dist/patch/fakeTimers.js

@@ -30,7 +30,7 @@ const patchFakeTimers = (that) => {
                 fakeTimeout?.set(timerId, {
                     type: 'fakeTimeout',
                     delay: delay || 0,
-                    stack: (0, getStack_1.default)(that.global.setTimeout),
+                    stack: (0, getStack_1.default)(that.global.setTimeout, 'setTimeout'),
                     testName: that.currentTestName,
                 });
                 return timerId;
@@ -40,7 +40,7 @@ const patchFakeTimers = (that) => {
                 that.leakRecords.get(that.currentTestName)?.fakeTimers.set(intervalId, {
                     type: 'fakeInterval',
                     delay: delay || 0,
-                    stack: (0, getStack_1.default)(that.global.setInterval),
+                    stack: (0, getStack_1.default)(that.global.setInterval, 'setInterval'),
                     testName: that.currentTestName,
                 });
                 return intervalId;

package/dist/patch/promiseConcurrency.d.ts

@@ -0,0 +1,3 @@
+import { JestDoctorEnvironment } from '../types';
+declare const patchPromiseConcurrency: (that: JestDoctorEnvironment) => void;
+export default patchPromiseConcurrency;

package/dist/patch/promiseConcurrency.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const patchPromiseConcurrency = (that) => {
+    const env = that.global;
+    const concurrencyFactor = (fn) => (concurrentPromises) => {
+        const promises = that.leakRecords.get(that.currentTestName)?.promises;
+        return fn(concurrentPromises).finally(() => {
+            if (promises) {
+                concurrentPromises.forEach((concurrentPromise) => {
+                    const leak = promises.get(concurrentPromise);
+                    if (leak) {
+                        const asyncId = leak?.asyncId;
+                        that.asyncIdToPromise.delete(asyncId);
+                        that.promiseOwner.delete(asyncId);
+                        promises.delete(concurrentPromise);
+                        // Promise.race and Promise.any will create a new Promise for every entry that needs to be deleted
+                        promises.forEach((childLeak, key) => {
+                            if (childLeak.parentAsyncId === asyncId) {
+                                that.asyncIdToPromise.delete(childLeak.asyncId);
+                                that.promiseOwner.delete(childLeak.asyncId);
+                                promises.delete(key);
+                            }
+                        });
+                    }
+                });
+            }
+        });
+    };
+    env.Promise.race = concurrencyFactor(env.Promise.race.bind(env.Promise));
+    env.Promise.any = concurrencyFactor(env.Promise.any.bind(env.Promise));
+};
+exports.default = patchPromiseConcurrency;

package/dist/patch/timers.js

@@ -22,7 +22,7 @@ const timers = (that) => {
         leakRecord?.timers.set(timerId, {
             type: 'timeout',
             delay: delay || 0,
-            stack: (0, getStack_1.default)(env.setTimeout),
+            stack: (0, getStack_1.default)(env.setTimeout, 'fake setTimeout'),
             testName: owner,
         });
         return timerId;
@@ -41,7 +41,7 @@ const timers = (that) => {
         that.leakRecords.get(owner)?.timers.set(intervalId, {
             type: 'interval',
             delay: delay || 0,
-            stack: (0, getStack_1.default)(env.setInterval),
+            stack: (0, getStack_1.default)(env.setInterval, 'fake setInterval'),
             testName: that.currentTestName,
         });
         return intervalId;

package/dist/reporter.js

@@ -15,7 +15,6 @@ const isAlive = (pid) => {
         return true;
     }
     catch (error) {
-        console.log(error.code);
         return error.code !== 'ESRCH';
     }
 };

package/dist/requireEnvironment.d.ts

@@ -34,6 +34,7 @@ declare const requireEnvironment: (envName: string) => {
             totalDelay: number;
         };
         tearDownError?: Error;
+        asyncIdToPromise: Map<number, Promise<unknown>>;
         setup(): Promise<void>;
         handleEvent(event: unknown, state: unknown): Promise<void>;
         handleTestEvent: import("@jest/environment").JestEnvironment["handleTestEvent"];

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 import type { ModernFakeTimers } from '@jest/fake-timers';
 import { JestEnvironment } from '@jest/environment';
 import initOriginal from './utils/initOriginal';
+import type { AsyncHook } from 'node:async_hooks';
 export interface TimerRecord {
     type: 'timeout' | 'interval' | 'fakeTimeout' | 'fakeInterval';
     delay: number;
@@ -10,6 +11,8 @@ export interface TimerRecord {
 export interface PromiseRecord {
     stack: string;
     testName: string;
+    asyncId: number;
+    parentAsyncId: number;
 }
 export interface ConsoleRecord {
     method: keyof Console;
@@ -18,7 +21,7 @@ export interface ConsoleRecord {
     message: string;
 }
 export interface LeakRecord {
-    promises: Map<number | Promise<unknown>, PromiseRecord>;
+    promises: Map<Promise<unknown>, PromiseRecord>;
     timers: Map<NodeJS.Timeout, TimerRecord>;
     console: ConsoleRecord[];
     totalDelay: number;
@@ -39,9 +42,8 @@ export interface FakeTimers extends Omit<ModernFakeTimers, '_fakeTimers'> {
     };
 }
 export type TimerIsolation = 'afterEach' | 'immediate';
-export type OnError = boolean | 'throw' | 'warn';
+export type OnError = false | 'throw' | 'warn';
 export type ThrowOrWarn = 'throw' | 'warn';
-export type Patch = 'async_hooks' | 'promise';
 export interface ConsoleOptions {
     onError: ThrowOrWarn;
     methods: Array<keyof Console>;
@@ -53,11 +55,9 @@ export interface NormalizedOptions {
         console: NormalizedConsoleOptions;
         timers: OnError;
         fakeTimers: OnError;
-        promises: false | {
-            onError: ThrowOrWarn;
-            patch: Patch;
-        };
+        promises: OnError;
     };
+    verbose: boolean;
     delayThreshold: number;
     timerIsolation: TimerIsolation;
     clearTimers: boolean;
@@ -67,17 +67,14 @@ export type RawConsoleOptions = boolean | {
     methods?: Array<keyof Console>;
     ignore?: string | RegExp | Array<string | RegExp>;
 };
-export type RawPromise = boolean | {
-    onError?: ThrowOrWarn;
-    patch?: Patch;
-};
 export interface RawOptions {
     report?: {
         console?: RawConsoleOptions;
         timers?: OnError;
         fakeTimers?: OnError;
-        promises?: RawPromise;
+        promises?: OnError;
     };
+    verbose?: boolean;
     delayThreshold?: number;
     timerIsolation?: TimerIsolation;
     clearTimers?: boolean;
@@ -100,5 +97,7 @@ export interface JestDoctorEnvironment {
     currentAfterEachCount: number;
     options: NormalizedOptions;
     aggregatedReport: AggregatedReport;
+    asyncIdToPromise: Map<number, Promise<unknown>>;
+    asyncHookDetector?: AsyncHook;
 }
 export {};

package/dist/utils/createAsyncHookCleaner.js

@@ -5,10 +5,15 @@ const createAsyncHookCleaner = (that) => {
     return (0, node_async_hooks_1.createHook)({
         promiseResolve(asyncId) {
             const owner = that.promiseOwner.get(asyncId);
-            if (!owner)
+            if (!owner) {
                 return;
-            that.leakRecords.get(owner)?.promises.delete(asyncId);
-            that.promiseOwner.delete(asyncId);
+            }
+            const promise = that.asyncIdToPromise.get(asyncId);
+            if (promise) {
+                that.leakRecords.get(owner)?.promises.delete(promise);
+                that.promiseOwner.delete(asyncId);
+                that.asyncIdToPromise.delete(asyncId);
+            }
         },
     });
 };

package/dist/utils/createAsyncHookDetector.js

@@ -6,14 +6,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_async_hooks_1 = require("node:async_hooks");
 const getStack_1 = __importDefault(require("./getStack"));
 const createAsyncHookDetector = (that) => {
-    const init = (asyncId, type) => {
-        if (type !== 'PROMISE')
+    const init = (asyncId, type, parentAsyncId, resource) => {
+        if (type !== 'PROMISE') {
             return;
+        }
+        const promise = resource;
         const owner = that.currentTestName;
         that.promiseOwner.set(asyncId, owner);
-        that.leakRecords.get(owner)?.promises.set(asyncId, {
-            stack: (0, getStack_1.default)(init),
+        that.asyncIdToPromise.set(asyncId, promise);
+        that.leakRecords.get(owner)?.promises.set(promise, {
+            stack: (0, getStack_1.default)(init, 'Promise'),
             testName: owner,
+            asyncId,
+            parentAsyncId,
         });
     };
     return (0, node_async_hooks_1.createHook)({ init });

package/dist/utils/getStack.d.ts

@@ -1,2 +1,2 @@
-declare const getStack: (stackFrom: Function) => string;
+declare const getStack: (stackFrom: Function, prefix: string) => string;
 export default getStack;

package/dist/utils/getStack.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const getStack = (stackFrom) => {
+const getStack = (stackFrom, prefix) => {
     const error = {
         stack: '',
     };
     Error.captureStackTrace(error, stackFrom);
-    return error.stack;
+    return prefix + ' ' + error.stack.replace(/\\/g, '/');
 };
 exports.default = getStack;

package/dist/utils/normalizeOptions.d.ts

@@ -1,3 +1,3 @@
 import { NormalizedOptions, RawOptions } from '../types';
-export declare function normalizeOptions(raw: RawOptions): NormalizedOptions;
+export declare function normalizeOptions(raw?: RawOptions): NormalizedOptions;
 export default normalizeOptions;

package/dist/utils/normalizeOptions.js

@@ -1,6 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeOptions = normalizeOptions;
+const zod = __importStar(require("zod"));
 const DEFAULTS = {
     report: {
         console: {
@@ -10,56 +44,56 @@ const DEFAULTS = {
         },
         timers: 'throw',
         fakeTimers: 'throw',
-        promises: {
-            onError: 'throw',
-            patch: 'async_hooks',
-        },
+        promises: 'throw',
     },
+    verbose: false,
     delayThreshold: 0,
     timerIsolation: 'afterEach',
     clearTimers: true,
 };
-const normalizeConsole = (rawConsole) => {
-    if (rawConsole === undefined || rawConsole === true) {
-        return DEFAULTS.report.console;
-    }
-    if (typeof rawConsole === 'object') {
-        return {
-            onError: rawConsole.onError ?? DEFAULTS.report.console.onError,
-            methods: rawConsole.methods ?? DEFAULTS.report.console.methods,
-            ignore: Array.isArray(rawConsole.ignore)
-                ? rawConsole.ignore
-                : rawConsole.ignore === undefined
-                    ? []
-                    : [rawConsole.ignore],
-        };
-    }
-    return false;
-};
-const normalizePromise = (rawPromise) => {
-    if (rawPromise === undefined || rawPromise === true) {
-        return DEFAULTS.report.promises;
+const onError = zod
+    .union([zod.literal(false), zod.enum(['throw', 'warn'])])
+    .default('throw');
+const schema = zod
+    .object({
+    report: zod
+        .object({
+        console: zod
+            .union([
+            zod.literal(false),
+            zod.object({
+                onError: zod.enum(['throw', 'warn']).default('throw'),
+                methods: zod
+                    .array(zod.enum(['log', 'warn', 'error', 'info', 'debug']))
+                    .default(DEFAULTS.report.console.methods),
+                ignore: zod
+                    .union([
+                    zod.string(),
+                    zod.instanceof(RegExp),
+                    zod.array(zod.union([zod.string(), zod.instanceof(RegExp)])),
+                ])
+                    .transform((value) => (Array.isArray(value) ? value : [value]))
+                    .default([]),
+            }),
+        ])
+            .default(DEFAULTS.report.console),
+        timers: onError,
+        fakeTimers: onError,
+        promises: onError,
+    })
+        .default(DEFAULTS.report),
+    verbose: zod.boolean().default(false),
+    delayThreshold: zod.int().gte(0).default(0),
+    timerIsolation: zod.enum(['afterEach', 'immediate']).default('afterEach'),
+    clearTimers: zod.boolean().default(true),
+})
+    .default(DEFAULTS);
+function normalizeOptions(raw) {
+    try {
+        return schema.parse(raw || {});
     }
-    if (typeof rawPromise === 'object') {
-        return {
-            onError: rawPromise.onError ?? DEFAULTS.report.promises.onError,
-            patch: rawPromise.patch ?? DEFAULTS.report.promises.patch,
-        };
+    catch (error) {
+        throw zod.prettifyError(error);
     }
-    return false;
-};
-function normalizeOptions(raw) {
-    const report = raw.report ?? {};
-    return {
-        report: {
-            console: normalizeConsole(report.console),
-            timers: report.timers ?? DEFAULTS.report.timers,
-            fakeTimers: report.fakeTimers ?? DEFAULTS.report.fakeTimers,
-            promises: normalizePromise(report.promises),
-        },
-        delayThreshold: raw.delayThreshold ?? DEFAULTS.delayThreshold,
-        timerIsolation: raw.timerIsolation ?? DEFAULTS.timerIsolation,
-        clearTimers: raw.clearTimers ?? DEFAULTS.clearTimers,
-    };
 }
 exports.default = normalizeOptions;

package/dist/utils/reportLeaks.js

@@ -13,8 +13,7 @@ const reportLeaks = (that, leakRecord) => {
                 leakRecord[property].values().next().value?.stack,
             ].join('\n');
             const option = that.options.report[property];
-            if (option === 'throw' ||
-                (typeof option === 'object' && option.onError === 'throw')) {
+            if (option === 'throw') {
                 const error = new Error();
                 error.stack = message;
                 throw error;
@@ -33,6 +32,19 @@ const reportLeaks = (that, leakRecord) => {
         that.aggregatedReport.fakeTimers += leakRecord.fakeTimers.size;
         that.aggregatedReport.totalDelay += leakRecord.totalDelay;
     }
+    if (that.options.verbose) {
+        const messages = [];
+        const addLeak = (leak) => {
+            messages.push(leak.stack);
+        };
+        leakRecord.promises.forEach(addLeak);
+        leakRecord.timers.forEach(addLeak);
+        leakRecord.fakeTimers.forEach(addLeak);
+        leakRecord.console.forEach(addLeak);
+        if (messages.length) {
+            node_console_1.default.log(messages.join('\n'));
+        }
+    }
     try {
         if (leakRecord.console.length) {
             const message = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jest-doctor",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "jest environment for leak detection",
   "license": "MIT",
   "author": "Stephan Dum",
@@ -38,11 +38,11 @@
     "@types/react": "^19.2.8",
     "@types/react-dom": "^19.2.3",
     "c8": "^10.1.3",
-    "cross-env": "^10.1.0",
     "cross-spawn": "^7.0.6",
     "eslint": "^9.39.2",
-    "istanbul-lib-report": "^3.0.1",
     "jest": "30.2.0",
+    "jest-environment-jsdom": "^30.2.0",
+    "jest-environment-node": "^30.2.0",
     "memfs": "^4.52.0",
     "nyc": "^17.1.0",
     "react": "^19.2.3",
@@ -63,7 +63,8 @@
     }
   },
   "dependencies": {
-    "chalk": "4.1.2"
+    "chalk": "4.1.2",
+    "zod": "^4.3.5"
   },
   "scripts": {
     "typecheck": "tsc",

package/readme.md

@@ -40,12 +40,8 @@ The environment can be configured through jest config `testEnvironmentOptions`:
 - **report**: an object defining which leaks should be tracked and reported
   - **timers**: `false | 'warn' | 'trow'` (default `throw`) whether normal setTimeout and setInterval should be reported and how
   - **fakeTimers**: `false | 'warn' | 'trow'` (default `throw`) same as timers but for fake api
-  - **promises**: `false` or object
-      - **onError**: `'warn' | 'trow'` (default `throw`) indicating if promises should be reported and how
-      - **patch**: `'async_hooks' | 'promise'` (default `async_hooks`) controls how to patch promises
-          - **async_hooks**: uses node async_hook API to detect any promise generation, robust solution but with an overhead.
-          - **promise**: overwrites the global Promise object which is faster but will not detect: internal promises, async await, native API promises!
-  -  **console**: `false` or object (default object)
+  - **promises**: `false | 'warn' | 'trow'` (default `throw`) indicating if promises should be reported and how
+  - **console**: `false` or object (default object)
       - **onError**: `'warn' | 'trow'` (default `throw`) how to handle reporting
       - **methods**: `keyof Console` (default all methods) which console methods should be tracked
       - **ignore**: `string | regexp | Array<string | regexp>` (default: []) allows to excluded console output from tracking
@@ -67,9 +63,7 @@ export default {
       },
       timers: 'warn',
       fakeTimers: 'warn',
-      promises: {
-        onErro: 'warn',
-      },
+      promises:  'warn',
     },
     delayThreshold: 1000,
     timerIsolation: 'afterEach',
@@ -100,9 +94,11 @@ Promise.resolve().then(() => {
   /* i am not tracked as unresolved */
 });
 ```
-- injectGlobals must be used for totalDelay and test attribution to work, because imports from jest can not be patched! Also this could give a wrong sense of confidence because one test could have open timers or promises that resolve while running other tests and are not present in the final report.
+- Promise.race and Promise.any can only accept unchained promises, or they will report the chained promise as open.
 ```js
-import { expect, it, describe, beforeEach /*...*/ } from '@jest/globals';
+const p1 = Promise.resolve().then(() => { /* not allowed */});
+const p2 = Promise.resolve();
+await Promise.race([p1, p2]);
 ```
 
 - console, setTimeout / setInterval can also be imported and will not participate in leak detection in these cases, but this can also serve as exit hatch if needed.

package/dist/patch/promise.d.ts

@@ -1,3 +0,0 @@
-import { JestDoctorEnvironment } from '../types';
-declare const patchPromise: (that: JestDoctorEnvironment) => void;
-export default patchPromise;

package/dist/patch/promise.js

@@ -1,34 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const getStack_1 = __importDefault(require("../utils/getStack"));
-const patchPromise = (that) => {
-    const OriginalPromise = that.global.Promise;
-    class TrackedPromise extends OriginalPromise {
-        constructor(executor) {
-            let resolveRef;
-            let rejectRef;
-            super((resolve, reject) => {
-                resolveRef = resolve;
-                rejectRef = reject;
-            });
-            const promiseLeaks = that.leakRecords.get(that.currentTestName)?.promises;
-            promiseLeaks?.set(this, {
-                testName: that.currentTestName,
-                stack: (0, getStack_1.default)(that.global.Promise),
-            });
-            executor((value) => {
-                promiseLeaks?.delete(this);
-                resolveRef(value);
-            }, (reason) => {
-                promiseLeaks?.delete(this);
-                rejectRef(reason);
-            });
-        }
-    }
-    Object.assign(Promise, OriginalPromise);
-    that.global.Promise = TrackedPromise;
-};
-exports.default = patchPromise;