@whatwg-node/server 0.10.0-alpha-20240726141316-c6ce93b3598457ebe73b3b725986723af8f5e609 → 0.10.0-alpha-20241123133536-975c9068dde45574fcfa26567e4bab96f45d1f85

package/cjs/createServerAdapter.js

@@ -3,12 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createServerAdapter = createServerAdapter;
 const tslib_1 = require("tslib");
 /* eslint-disable @typescript-eslint/ban-types */
+const disposablestack_1 = require("@whatwg-node/disposablestack");
 const DefaultFetchAPI = tslib_1.__importStar(require("@whatwg-node/fetch"));
 const utils_js_1 = require("./utils.js");
 const uwebsockets_js_1 = require("./uwebsockets.js");
-async function handleWaitUntils(waitUntilPromises) {
-    await Promise.allSettled(waitUntilPromises);
-}
 // Required for envs like nextjs edge runtime
 function isRequestAccessible(serverContext) {
     try {
@@ -29,6 +27,36 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         : serverAdapterBaseObject.handle;
     const onRequestHooks = [];
     const onResponseHooks = [];
+    const waitUntilPromises = new Set();
+    const disposableStack = new disposablestack_1.AsyncDisposableStack();
+    const signals = new Set();
+    function registerSignal(signal) {
+        signals.add(signal);
+        signal.addEventListener('abort', () => {
+            signals.delete(signal);
+        });
+    }
+    disposableStack.defer(() => {
+        for (const signal of signals) {
+            signal.sendAbort();
+        }
+    });
+    function handleWaitUntils() {
+        return Promise.allSettled(waitUntilPromises).then(() => { }, () => { });
+    }
+    disposableStack.defer(handleWaitUntils);
+    function waitUntil(promiseLike) {
+        // If it is a Node.js environment, we should register the disposable stack to handle process termination events
+        if (globalThis.process) {
+            (0, utils_js_1.ensureDisposableStackRegisteredForTerminateEvents)(disposableStack);
+        }
+        waitUntilPromises.add(promiseLike.then(() => {
+            waitUntilPromises.delete(promiseLike);
+        }, err => {
+            console.error(`Unexpected error while waiting: ${err.message || err}`);
+            waitUntilPromises.delete(promiseLike);
+        }));
+    }
     if (options?.plugins != null) {
         for (const plugin of options.plugins) {
             if (plugin.onRequest) {
@@ -107,20 +135,21 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         }
         : givenHandleRequest;
     // TODO: Remove this on the next major version
-    function handleNodeRequestAndResponse(nodeRequest, nodeResponseOrContainer, ...ctx) {
-        const nodeResponse = nodeResponseOrContainer.raw || nodeResponseOrContainer;
+    function handleNodeRequest(nodeRequest, ...ctx) {
         const serverContext = ctx.length > 1 ? (0, utils_js_1.completeAssign)(...ctx) : ctx[0] || {};
-        const request = (0, utils_js_1.normalizeNodeRequest)(nodeRequest, nodeResponse, fetchAPI.Request);
+        const request = (0, utils_js_1.normalizeNodeRequest)(nodeRequest, fetchAPI, registerSignal);
         return handleRequest(request, serverContext);
     }
+    function handleNodeRequestAndResponse(nodeRequest, nodeResponseOrContainer, ...ctx) {
+        const nodeResponse = nodeResponseOrContainer.raw || nodeResponseOrContainer;
+        utils_js_1.nodeRequestResponseMap.set(nodeRequest, nodeResponse);
+        return handleNodeRequest(nodeRequest, ...ctx);
+    }
     function requestListener(nodeRequest, nodeResponse, ...ctx) {
-        const waitUntilPromises = [];
         const defaultServerContext = {
             req: nodeRequest,
             res: nodeResponse,
-            waitUntil(cb) {
-                waitUntilPromises.push(cb.catch(err => console.error(err)));
-            },
+            waitUntil,
         };
         let response$;
         try {
@@ -145,19 +174,17 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         }
     }
     function handleUWS(res, req, ...ctx) {
-        const waitUntilPromises = [];
         const defaultServerContext = {
             res,
             req,
-            waitUntil(cb) {
-                waitUntilPromises.push(cb.catch(err => console.error(err)));
-            },
+            waitUntil,
         };
         const filteredCtxParts = ctx.filter(partCtx => partCtx != null);
         const serverContext = filteredCtxParts.length > 0
             ? (0, utils_js_1.completeAssign)(defaultServerContext, ...ctx)
             : defaultServerContext;
         const signal = new utils_js_1.ServerAdapterRequestAbortSignal();
+        registerSignal(signal);
         const originalResEnd = res.end.bind(res);
         let resEnded = false;
         res.end = function (data) {
@@ -189,7 +216,7 @@ function createServerAdapter(serverAdapterBaseObject, options) {
                 .catch((e) => (0, utils_js_1.handleErrorFromRequestHandler)(e, fetchAPI.Response))
                 .then(response => {
                 if (!signal.aborted && !resEnded) {
-                    return (0, uwebsockets_js_1.sendResponseToUwsOpts)(res, response, signal);
+                    return (0, uwebsockets_js_1.sendResponseToUwsOpts)(res, response, signal, fetchAPI);
                 }
             })
                 .catch(err => {
@@ -198,7 +225,7 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         }
         try {
             if (!signal.aborted && !resEnded) {
-                return (0, uwebsockets_js_1.sendResponseToUwsOpts)(res, response$, signal);
+                return (0, uwebsockets_js_1.sendResponseToUwsOpts)(res, response$, signal, fetchAPI);
             }
         }
         catch (err) {
@@ -218,17 +245,12 @@ function createServerAdapter(serverAdapterBaseObject, options) {
     }
     function handleRequestWithWaitUntil(request, ...ctx) {
         const filteredCtxParts = ctx.filter(partCtx => partCtx != null);
-        let waitUntilPromises;
         const serverContext = filteredCtxParts.length > 1
             ? (0, utils_js_1.completeAssign)({}, ...filteredCtxParts)
             : (0, utils_js_1.isolateObject)(filteredCtxParts[0], filteredCtxParts[0] == null || filteredCtxParts[0].waitUntil == null
-                ? (waitUntilPromises = [])
+                ? waitUntil
                 : undefined);
-        const response$ = handleRequest(request, serverContext);
-        if (waitUntilPromises?.length) {
-            return handleWaitUntils(waitUntilPromises).then(() => response$);
-        }
-        return response$;
+        return handleRequest(request, serverContext);
     }
     const fetchFn = (input, ...maybeCtx) => {
         if (typeof input === 'string' || 'href' in input) {
@@ -275,11 +297,19 @@ function createServerAdapter(serverAdapterBaseObject, options) {
     const adapterObj = {
         handleRequest: handleRequestWithWaitUntil,
         fetch: fetchFn,
+        handleNodeRequest,
         handleNodeRequestAndResponse,
         requestListener,
         handleEvent,
         handleUWS,
         handle: genericRequestHandler,
+        disposableStack,
+        [disposablestack_1.DisposableSymbols.asyncDispose]() {
+            return disposableStack.disposeAsync();
+        },
+        dispose() {
+            return disposableStack.disposeAsync();
+        },
     };
     const serverAdapter = new Proxy(genericRequestHandler, {
         // It should have all the attributes of the handler function and the server instance

package/cjs/plugins/useContentEncoding.js

@@ -21,7 +21,7 @@ function useContentEncoding() {
                     for (const contentEncoding of contentEncodings) {
                         newBody = newBody.pipeThrough(new fetchAPI.DecompressionStream(contentEncoding));
                     }
-                    const newRequest = new fetchAPI.Request(request.url, {
+                    request = new fetchAPI.Request(request.url, {
                         body: newBody,
                         cache: request.cache,
                         credentials: request.credentials,
@@ -38,7 +38,7 @@ function useContentEncoding() {
                         // @ts-ignore - not in the TS types yet
                         duplex: 'half',
                     });
-                    setRequest(newRequest);
+                    setRequest(request);
                 }
             }
             const acceptEncoding = request.headers.get('accept-encoding');
@@ -46,7 +46,8 @@ function useContentEncoding() {
                 encodingMap.set(request, acceptEncoding.split(','));
             }
         },
-        onResponse({ request, response, setResponse, fetchAPI }) {
+        onResponse({ request, response, setResponse, fetchAPI, serverContext }) {
+            const waitUntil = serverContext.waitUntil?.bind(serverContext) || (() => { });
             // Hack for avoiding to create whatwg-node to create a readable stream until it's needed
             if (response['bodyInit'] || response.body) {
                 const encodings = encodingMap.get(request);
@@ -60,21 +61,15 @@ function useContentEncoding() {
                             const bufOfRes = response._buffer;
                             if (bufOfRes) {
                                 const writer = compressionStream.writable.getWriter();
-                                writer.write(bufOfRes);
-                                writer.close();
-                                const reader = compressionStream.readable.getReader();
-                                return Promise.resolve().then(async () => {
-                                    const chunks = [];
-                                    while (true) {
-                                        const { done, value } = await reader.read();
-                                        if (done) {
-                                            reader.releaseLock();
-                                            break;
-                                        }
-                                        else if (value) {
-                                            chunks.push(...value);
-                                        }
-                                    }
+                                waitUntil(writer.write(bufOfRes));
+                                waitUntil(writer.close());
+                                const uint8Arrays$ = (0, utils_js_1.isReadable)(compressionStream.readable['readable'])
+                                    ? collectReadableValues(compressionStream.readable['readable'])
+                                    : (0, utils_js_1.isAsyncIterable)(compressionStream.readable)
+                                        ? collectAsyncIterableValues(compressionStream.readable)
+                                        : collectReadableStreamValues(compressionStream.readable);
+                                return uint8Arrays$.then(uint8Arrays => {
+                                    const chunks = uint8Arrays.flatMap(uint8Array => [...uint8Array]);
                                     const uint8Array = new Uint8Array(chunks);
                                     const newHeaders = new fetchAPI.Headers(response.headers);
                                     newHeaders.set('content-encoding', supportedEncoding);
@@ -85,6 +80,7 @@ function useContentEncoding() {
                                     });
                                     utils_js_1.decompressedResponseMap.set(compressedResponse, response);
                                     setResponse(compressedResponse);
+                                    waitUntil(compressionStream.writable.close());
                                 });
                             }
                         }
@@ -105,3 +101,33 @@ function useContentEncoding() {
         },
     };
 }
+function collectReadableValues(readable) {
+    const values = [];
+    readable.on('data', value => values.push(value));
+    return new Promise((resolve, reject) => {
+        readable.once('end', () => resolve(values));
+        readable.once('error', reject);
+    });
+}
+async function collectAsyncIterableValues(asyncIterable) {
+    const values = [];
+    for await (const value of asyncIterable) {
+        values.push(value);
+    }
+    return values;
+}
+async function collectReadableStreamValues(readableStream) {
+    const reader = readableStream.getReader();
+    const values = [];
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            reader.releaseLock();
+            break;
+        }
+        else if (value) {
+            values.push(value);
+        }
+    }
+    return values;
+}

package/cjs/plugins/useErrorHandling.js

@@ -24,13 +24,17 @@ function createDefaultErrorResponse(ResponseCtor) {
     return new ResponseCtor(null, { status: 500 });
 }
 class HTTPError extends Error {
+    status;
+    message;
+    headers;
+    details;
+    name = 'HTTPError';
     constructor(status = 500, message, headers = {}, details) {
         super(message);
         this.status = status;
         this.message = message;
         this.headers = headers;
         this.details = details;
-        this.name = 'HTTPError';
         Error.captureStackTrace(this, HTTPError);
     }
 }

package/cjs/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decompressedResponseMap = exports.ServerAdapterRequestAbortSignal = void 0;
+exports.decompressedResponseMap = exports.nodeRequestResponseMap = exports.ServerAdapterRequestAbortSignal = void 0;
 exports.isAsyncIterable = isAsyncIterable;
 exports.normalizeNodeRequest = normalizeNodeRequest;
 exports.isReadable = isReadable;
@@ -19,7 +19,7 @@ exports.createDeferredPromise = createDeferredPromise;
 exports.handleAbortSignalAndPromiseResponse = handleAbortSignalAndPromiseResponse;
 exports.getSupportedEncodings = getSupportedEncodings;
 exports.handleResponseDecompression = handleResponseDecompression;
-const fetch_1 = require("@whatwg-node/fetch");
+exports.ensureDisposableStackRegisteredForTerminateEvents = ensureDisposableStackRegisteredForTerminateEvents;
 function isAsyncIterable(body) {
     return (body != null && typeof body === 'object' && typeof body[Symbol.asyncIterator] === 'function');
 }
@@ -70,11 +70,9 @@ function isRequestBody(body) {
     return false;
 }
 class ServerAdapterRequestAbortSignal extends EventTarget {
-    constructor() {
-        super(...arguments);
-        this.aborted = false;
-        this._onabort = null;
-    }
+    aborted = false;
+    _onabort = null;
+    reason;
     throwIfAborted() {
         if (this.aborted) {
             throw this.reason;
@@ -103,17 +101,20 @@ class ServerAdapterRequestAbortSignal extends EventTarget {
 }
 exports.ServerAdapterRequestAbortSignal = ServerAdapterRequestAbortSignal;
 let bunNodeCompatModeWarned = false;
-function normalizeNodeRequest(nodeRequest, nodeResponse, RequestCtor) {
+exports.nodeRequestResponseMap = new WeakMap();
+function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
     const rawRequest = nodeRequest.raw || nodeRequest.req || nodeRequest;
     let fullUrl = buildFullUrl(rawRequest);
     if (nodeRequest.query) {
-        const url = new fetch_1.URL(fullUrl);
+        const url = new fetchAPI.URL(fullUrl);
         for (const key in nodeRequest.query) {
             url.searchParams.set(key, nodeRequest.query[key]);
         }
         fullUrl = url.toString();
     }
     let signal;
+    const nodeResponse = exports.nodeRequestResponseMap.get(nodeRequest);
+    exports.nodeRequestResponseMap.delete(nodeRequest);
     let normalizedHeaders = nodeRequest.headers;
     if (nodeRequest.headers?.[':method']) {
         normalizedHeaders = {};
@@ -126,8 +127,10 @@ function normalizeNodeRequest(nodeRequest, nodeResponse, RequestCtor) {
     if (nodeResponse?.once) {
         let sendAbortSignal;
         // If ponyfilled
-        if (RequestCtor !== globalThis.Request) {
-            signal = new ServerAdapterRequestAbortSignal();
+        if (fetchAPI.Request !== globalThis.Request) {
+            const newSignal = new ServerAdapterRequestAbortSignal();
+            registerSignal?.(newSignal);
+            signal = newSignal;
             sendAbortSignal = () => signal.sendAbort();
         }
         else {
@@ -148,7 +151,7 @@ function normalizeNodeRequest(nodeRequest, nodeResponse, RequestCtor) {
         });
     }
     if (nodeRequest.method === 'GET' || nodeRequest.method === 'HEAD') {
-        return new RequestCtor(fullUrl, {
+        return new fetchAPI.Request(fullUrl, {
             method: nodeRequest.method,
             headers: normalizedHeaders,
             signal,
@@ -163,14 +166,14 @@ function normalizeNodeRequest(nodeRequest, nodeResponse, RequestCtor) {
     const maybeParsedBody = nodeRequest.body;
     if (maybeParsedBody != null && Object.keys(maybeParsedBody).length > 0) {
         if (isRequestBody(maybeParsedBody)) {
-            return new RequestCtor(fullUrl, {
+            return new fetchAPI.Request(fullUrl, {
                 method: nodeRequest.method,
                 headers: normalizedHeaders,
                 body: maybeParsedBody,
                 signal,
             });
         }
-        const request = new RequestCtor(fullUrl, {
+        const request = new fetchAPI.Request(fullUrl, {
             method: nodeRequest.method,
             headers: normalizedHeaders,
             signal,
@@ -198,7 +201,7 @@ function normalizeNodeRequest(nodeRequest, nodeResponse, RequestCtor) {
             console.warn(`You use Bun Node compatibility mode, which is not recommended!
 It will affect your performance. Please check our Bun integration recipe, and avoid using 'http' for your server implementation.`);
         }
-        return new RequestCtor(fullUrl, {
+        return new fetchAPI.Request(fullUrl, {
             method: nodeRequest.method,
             headers: normalizedHeaders,
             duplex: 'half',
@@ -222,7 +225,7 @@ It will affect your performance. Please check our Bun integration recipe, and av
         });
     }
     // perf: instead of spreading the object, we can just pass it as is and it performs better
-    return new RequestCtor(fullUrl, {
+    return new fetchAPI.Request(fullUrl, {
         method: nodeRequest.method,
         headers: normalizedHeaders,
         body: rawRequest,
@@ -260,11 +263,26 @@ function endResponse(serverResponse) {
     serverResponse.end(null, null, null);
 }
 async function sendAsyncIterable(serverResponse, asyncIterable) {
+    let closed = false;
+    const closeEventListener = () => {
+        closed = true;
+    };
+    serverResponse.once('error', closeEventListener);
+    serverResponse.once('close', closeEventListener);
+    serverResponse.once('finish', () => {
+        serverResponse.removeListener('close', closeEventListener);
+    });
     for await (const chunk of asyncIterable) {
+        if (closed) {
+            break;
+        }
         if (!serverResponse
             // @ts-expect-error http and http2 writes are actually compatible
             .write(chunk)) {
-            break;
+            if (closed) {
+                break;
+            }
+            await new Promise(resolve => serverResponse.once('drain', resolve));
         }
     }
     endResponse(serverResponse);
@@ -275,7 +293,7 @@ function sendNodeResponse(fetchResponse, serverResponse, nodeRequest) {
     }
     if (!fetchResponse) {
         serverResponse.statusCode = 404;
-        serverResponse.end();
+        endResponse(serverResponse);
         return;
     }
     serverResponse.statusCode = fetchResponse.status;
@@ -324,10 +342,31 @@ function sendNodeResponse(fetchResponse, serverResponse, nodeRequest) {
         fetchBody.pipe(serverResponse);
         return;
     }
+    if (isReadableStream(fetchBody)) {
+        return sendReadableStream(serverResponse, fetchBody);
+    }
     if (isAsyncIterable(fetchBody)) {
         return sendAsyncIterable(serverResponse, fetchBody);
     }
 }
+async function sendReadableStream(serverResponse, readableStream) {
+    const reader = readableStream.getReader();
+    serverResponse.req.once('error', err => {
+        reader.cancel(err);
+    });
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        if (!serverResponse
+            // @ts-expect-error http and http2 writes are actually compatible
+            .write(value)) {
+            await new Promise(resolve => serverResponse.once('drain', resolve));
+        }
+    }
+    endResponse(serverResponse);
+}
 function isRequestInit(val) {
     return (val != null &&
         typeof val === 'object' &&
@@ -404,77 +443,18 @@ function handleErrorFromRequestHandler(error, ResponseCtor) {
         status: error.status || 500,
     });
 }
-function isolateObject(originalCtx, waitUntilPromises) {
+function isolateObject(originalCtx, waitUntilFn) {
     if (originalCtx == null) {
-        return {};
-    }
-    const extraProps = {};
-    const deletedProps = new Set();
-    return new Proxy(originalCtx, {
-        get(originalCtx, prop) {
-            if (waitUntilPromises != null && prop === 'waitUntil') {
-                return function waitUntil(promise) {
-                    waitUntilPromises.push(promise.catch(err => console.error(err)));
-                };
-            }
-            const extraPropVal = extraProps[prop];
-            if (extraPropVal != null) {
-                if (typeof extraPropVal === 'function') {
-                    return extraPropVal.bind(extraProps);
-                }
-                return extraPropVal;
-            }
-            if (deletedProps.has(prop)) {
-                return undefined;
-            }
-            return originalCtx[prop];
-        },
-        set(_originalCtx, prop, value) {
-            extraProps[prop] = value;
-            return true;
-        },
-        has(originalCtx, prop) {
-            if (waitUntilPromises != null && prop === 'waitUntil') {
-                return true;
-            }
-            if (deletedProps.has(prop)) {
-                return false;
-            }
-            if (prop in extraProps) {
-                return true;
-            }
-            return prop in originalCtx;
-        },
-        defineProperty(_originalCtx, prop, descriptor) {
-            return Reflect.defineProperty(extraProps, prop, descriptor);
-        },
-        deleteProperty(_originalCtx, prop) {
-            if (prop in extraProps) {
-                return Reflect.deleteProperty(extraProps, prop);
-            }
-            deletedProps.add(prop);
-            return true;
-        },
-        ownKeys(originalCtx) {
-            const extraKeys = Reflect.ownKeys(extraProps);
-            const originalKeys = Reflect.ownKeys(originalCtx);
-            const deletedKeys = Array.from(deletedProps);
-            const allKeys = new Set(extraKeys.concat(originalKeys.filter(keys => !deletedKeys.includes(keys))));
-            if (waitUntilPromises != null) {
-                allKeys.add('waitUntil');
-            }
-            return Array.from(allKeys);
-        },
-        getOwnPropertyDescriptor(originalCtx, prop) {
-            if (prop in extraProps) {
-                return Reflect.getOwnPropertyDescriptor(extraProps, prop);
-            }
-            if (deletedProps.has(prop)) {
-                return undefined;
-            }
-            return Reflect.getOwnPropertyDescriptor(originalCtx, prop);
-        },
-    });
+        if (waitUntilFn == null) {
+            return {};
+        }
+        return {
+            waitUntil: waitUntilFn,
+        };
+    }
+    return completeAssign(Object.create(originalCtx), {
+        waitUntil: waitUntilFn,
+    }, originalCtx);
 }
 function createDeferredPromise() {
     let resolveFn;
@@ -516,22 +496,27 @@ function getSupportedEncodings(fetchAPI) {
     let supportedEncodings = supportedEncodingsByFetchAPI.get(fetchAPI);
     if (!supportedEncodings) {
         const possibleEncodings = ['deflate', 'gzip', 'deflate-raw', 'br'];
-        supportedEncodings = possibleEncodings.filter(encoding => {
-            // deflate-raw is not supported in Node.js >v20
-            if (globalThis.process?.version?.startsWith('v2') &&
-                fetchAPI.DecompressionStream === globalThis.DecompressionStream &&
-                encoding === 'deflate-raw') {
-                return false;
-            }
-            try {
-                // eslint-disable-next-line no-new
-                new fetchAPI.DecompressionStream(encoding);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        });
+        if (fetchAPI.DecompressionStream?.['supportedFormats']) {
+            supportedEncodings = fetchAPI.DecompressionStream['supportedFormats'];
+        }
+        else {
+            supportedEncodings = possibleEncodings.filter(encoding => {
+                // deflate-raw is not supported in Node.js >v20
+                if (globalThis.process?.version?.startsWith('v2') &&
+                    fetchAPI.DecompressionStream === globalThis.DecompressionStream &&
+                    encoding === 'deflate-raw') {
+                    return false;
+                }
+                try {
+                    // eslint-disable-next-line no-new
+                    new fetchAPI.DecompressionStream(encoding);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
         supportedEncodingsByFetchAPI.set(fetchAPI, supportedEncodings);
     }
     return supportedEncodings;
@@ -562,3 +547,30 @@ function handleResponseDecompression(response, fetchAPI) {
     }
     return decompressedResponse;
 }
+const terminateEvents = ['SIGINT', 'SIGTERM', 'exit'];
+const disposableStacks = new Set();
+let eventListenerRegistered = false;
+function ensureEventListenerForDisposableStacks() {
+    if (eventListenerRegistered) {
+        return;
+    }
+    eventListenerRegistered = true;
+    for (const event of terminateEvents) {
+        globalThis.process.once(event, function terminateHandler() {
+            return Promise.allSettled([...disposableStacks].map(stack => stack.disposeAsync().catch(e => {
+                console.error('Error while disposing:', e);
+            })));
+        });
+    }
+}
+function ensureDisposableStackRegisteredForTerminateEvents(disposableStack) {
+    if (globalThis.process) {
+        ensureEventListenerForDisposableStacks();
+        if (!disposableStacks.has(disposableStack)) {
+            disposableStacks.add(disposableStack);
+            disposableStack.defer(() => {
+                disposableStacks.delete(disposableStack);
+            });
+        }
+    }
+}