@trpc/server 11.0.0-alpha-tmp-subscription-connection-state.489 → 11.0.0-alpha-tmp-12-06-react.665

package/dist/vendor/unpromise/unpromise.mjs

@@ -0,0 +1,289 @@
+/* eslint-disable @typescript-eslint/unbound-method */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+var _computedKey;
+/** Memory safe (weakmapped) cache of the ProxyPromise for each Promise,
+ * which is retained for the lifetime of the original Promise.
+ */ const subscribableCache = new WeakMap();
+/** A NOOP function allowing a consistent interface for settled
+ * SubscribedPromises (settled promises are not subscribed - they resolve
+ * immediately). */ const NOOP = ()=>{
+// noop
+};
+_computedKey = Symbol.toStringTag;
+let _computedKey1 = _computedKey;
+/**
+ * Every `Promise<T>` can be shadowed by a single `ProxyPromise<T>`. It is
+ * created once, cached and reused throughout the lifetime of the Promise. Get a
+ * Promise's ProxyPromise using `Unpromise.proxy(promise)`.
+ *
+ * The `ProxyPromise<T>` attaches handlers to the original `Promise<T>`
+ * `.then()` and `.catch()` just once. Promises derived from it use a
+ * subscription- (and unsubscription-) based mechanism that monitors these
+ * handlers.
+ *
+ * Every time you call `.subscribe()`, `.then()` `.catch()` or `.finally()` on a
+ * `ProxyPromise<T>` it returns a `SubscribedPromise<T>` having an additional
+ * `unsubscribe()` method. Calling `unsubscribe()` detaches reference chains
+ * from the original, potentially long-lived Promise, eliminating memory leaks.
+ *
+ * This approach can eliminate the memory leaks that otherwise come about from
+ * repeated `race()` or `any()` calls invoking `.then()` and `.catch()` multiple
+ * times on the same long-lived native Promise (subscriptions which can never be
+ * cleaned up).
+ *
+ * `Unpromise.race(promises)` is a reference implementation of `Promise.race`
+ * avoiding memory leaks when using long-lived unsettled Promises.
+ *
+ * `Unpromise.any(promises)` is a reference implementation of `Promise.any`
+ * avoiding memory leaks when using long-lived unsettled Promises.
+ *
+ * `Unpromise.resolve(promise)` returns an ephemeral `SubscribedPromise<T>` for
+ * any given `Promise<T>` facilitating arbitrary async/await patterns. Behind
+ * the scenes, `resolve` is implemented simply as
+ * `Unpromise.proxy(promise).subscribe()`. Don't forget to call `.unsubscribe()`
+ * to tidy up!
+ *
+ */ class Unpromise {
+    /** Create a promise that mitigates uncontrolled subscription to a long-lived
+   * Promise via .then() and .catch() - otherwise a source of memory leaks.
+   *
+   * The returned promise has an `unsubscribe()` method which can be called when
+   * the Promise is no longer being tracked by application logic, and which
+   * ensures that there is no reference chain from the original promise to the
+   * new one, and therefore no memory leak.
+   *
+   * If original promise has not yet settled, this adds a new unique promise
+   * that listens to then/catch events, along with an `unsubscribe()` method to
+   * detach it.
+   *
+   * If original promise has settled, then creates a new Promise.resolve() or
+   * Promise.reject() and provided unsubscribe is a noop.
+   *
+   * If you call `unsubscribe()` before the returned Promise has settled, it
+   * will never settle.
+   */ subscribe() {
+        // in all cases we will combine some promise with its unsubscribe function
+        let promise;
+        let unsubscribe;
+        const { settlement } = this;
+        if (settlement === null) {
+            // not yet settled - subscribe new promise. Expect eventual settlement
+            if (this.subscribers === null) {
+                // invariant - it is not settled, so it must have subscribers
+                throw new Error("Unpromise settled but still has subscribers");
+            }
+            const subscriber = withResolvers();
+            this.subscribers = listWithMember(this.subscribers, subscriber);
+            promise = subscriber.promise;
+            unsubscribe = ()=>{
+                if (this.subscribers !== null) {
+                    this.subscribers = listWithoutMember(this.subscribers, subscriber);
+                }
+            };
+        } else {
+            // settled - don't create subscribed promise. Just resolve or reject
+            const { status } = settlement;
+            if (status === "fulfilled") {
+                promise = Promise.resolve(settlement.value);
+            } else {
+                promise = Promise.reject(settlement.reason);
+            }
+            unsubscribe = NOOP;
+        }
+        // extend promise signature with the extra method
+        return Object.assign(promise, {
+            unsubscribe
+        });
+    }
+    /** STANDARD PROMISE METHODS (but returning a SubscribedPromise) */ then(onfulfilled, onrejected) {
+        const subscribed = this.subscribe();
+        const { unsubscribe } = subscribed;
+        return Object.assign(subscribed.then(onfulfilled, onrejected), {
+            unsubscribe
+        });
+    }
+    catch(onrejected) {
+        const subscribed = this.subscribe();
+        const { unsubscribe } = subscribed;
+        return Object.assign(subscribed.catch(onrejected), {
+            unsubscribe
+        });
+    }
+    finally(onfinally) {
+        const subscribed = this.subscribe();
+        const { unsubscribe } = subscribed;
+        return Object.assign(subscribed.finally(onfinally), {
+            unsubscribe
+        });
+    }
+    /** Unpromise STATIC METHODS */ /** Create or Retrieve the proxy Unpromise (a re-used Unpromise for the VM lifetime
+   * of the provided Promise reference) */ static proxy(promise) {
+        const cached = Unpromise.getSubscribablePromise(promise);
+        return typeof cached !== "undefined" ? cached : Unpromise.createSubscribablePromise(promise);
+    }
+    /** Create and store an Unpromise keyed by an original Promise. */ static createSubscribablePromise(promise) {
+        const created = new Unpromise(promise);
+        subscribableCache.set(promise, created); // resolve promise to unpromise
+        subscribableCache.set(created, created); // resolve the unpromise to itself
+        return created;
+    }
+    /** Retrieve a previously-created Unpromise keyed by an original Promise. */ static getSubscribablePromise(promise) {
+        return subscribableCache.get(promise);
+    }
+    /** Promise STATIC METHODS */ /** Lookup the Unpromise for this promise, and derive a SubscribedPromise from
+   * it (that can be later unsubscribed to eliminate Memory leaks) */ static resolve(value) {
+        const promise = typeof value === "object" && value !== null && "then" in value && typeof value.then === "function" ? value : Promise.resolve(value);
+        return Unpromise.proxy(promise).subscribe();
+    }
+    static async any(values) {
+        const valuesArray = Array.isArray(values) ? values : [
+            ...values
+        ];
+        const subscribedPromises = valuesArray.map(Unpromise.resolve);
+        try {
+            return await Promise.any(subscribedPromises);
+        } finally{
+            subscribedPromises.forEach(({ unsubscribe })=>{
+                unsubscribe();
+            });
+        }
+    }
+    static async race(values) {
+        const valuesArray = Array.isArray(values) ? values : [
+            ...values
+        ];
+        const subscribedPromises = valuesArray.map(Unpromise.resolve);
+        try {
+            return await Promise.race(subscribedPromises);
+        } finally{
+            subscribedPromises.forEach(({ unsubscribe })=>{
+                unsubscribe();
+            });
+        }
+    }
+    /** Create a race of SubscribedPromises that will fulfil to a single winning
+   * Promise (in a 1-Tuple). Eliminates memory leaks from long-lived promises
+   * accumulating .then() and .catch() subscribers. Allows simple logic to
+   * consume the result, like...
+   * ```ts
+   * const [ winner ] = await Unpromise.race([ promiseA, promiseB ]);
+   * if(winner === promiseB){
+   *   const result = await promiseB;
+   *   // do the thing
+   * }
+   * ```
+   * */ static async raceReferences(promises) {
+        // map each promise to an eventual 1-tuple containing itself
+        const selfPromises = promises.map(resolveSelfTuple);
+        // now race them. They will fulfil to a readonly [P] or reject.
+        try {
+            return await Promise.race(selfPromises);
+        } finally{
+            for (const promise of selfPromises){
+                // unsubscribe proxy promises when the race is over to mitigate memory leaks
+                promise.unsubscribe();
+            }
+        }
+    }
+    constructor(arg){
+        /** INSTANCE IMPLEMENTATION */ /** The promise shadowed by this Unpromise<T>  */ _define_property(this, "promise", void 0);
+        /** Promises expecting eventual settlement (unless unsubscribed first). This list is deleted
+   * after the original promise settles - no further notifications will be issued. */ _define_property(this, "subscribers", []);
+        /** The Promise's settlement (recorded when it fulfils or rejects). This is consulted when
+   * calling .subscribe() .then() .catch() .finally() to see if an immediately-resolving Promise
+   * can be returned, and therefore subscription can be bypassed. */ _define_property(this, "settlement", null);
+        /** TOSTRING SUPPORT */ _define_property(this, _computedKey1, "Unpromise");
+        // handle either a Promise or a Promise executor function
+        if (typeof arg === "function") {
+            this.promise = new Promise(arg);
+        } else {
+            this.promise = arg;
+        }
+        // subscribe for eventual fulfilment and rejection
+        // handle PromiseLike objects (that at least have .then)
+        const thenReturn = this.promise.then((value)=>{
+            // atomically record fulfilment and detach subscriber list
+            const { subscribers } = this;
+            this.subscribers = null;
+            this.settlement = {
+                status: "fulfilled",
+                value
+            };
+            // notify fulfilment to subscriber list
+            subscribers?.forEach(({ resolve })=>{
+                resolve(value);
+            });
+        });
+        // handle Promise (that also have a .catch behaviour)
+        if ("catch" in thenReturn) {
+            thenReturn.catch((reason)=>{
+                // atomically record rejection and detach subscriber list
+                const { subscribers } = this;
+                this.subscribers = null;
+                this.settlement = {
+                    status: "rejected",
+                    reason
+                };
+                // notify rejection to subscriber list
+                subscribers?.forEach(({ reject })=>{
+                    reject(reason);
+                });
+            });
+        }
+    }
+}
+/** Promises a 1-tuple containing the original promise when it resolves. Allows
+ * awaiting the eventual Promise ***reference*** (easy to destructure and
+ * exactly compare with ===). Avoids resolving to the Promise ***value*** (which
+ * may be ambiguous and therefore hard to identify as the winner of a race).
+ * You can call unsubscribe on the Promise to mitigate memory leaks.
+ * */ function resolveSelfTuple(promise) {
+    return Unpromise.proxy(promise).then(()=>[
+            promise
+        ]);
+}
+/** VENDORED (Future) PROMISE UTILITIES */ /** Reference implementation of https://github.com/tc39/proposal-promise-with-resolvers */ function withResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((_resolve, _reject)=>{
+        resolve = _resolve;
+        reject = _reject;
+    });
+    return {
+        promise,
+        resolve,
+        reject
+    };
+}
+/** IMMUTABLE LIST OPERATIONS */ function listWithMember(arr, member) {
+    return [
+        ...arr,
+        member
+    ];
+}
+function listWithoutIndex(arr, index) {
+    return [
+        ...arr.slice(0, index),
+        ...arr.slice(index + 1)
+    ];
+}
+function listWithoutMember(arr, member) {
+    const index = arr.indexOf(member);
+    if (index !== -1) {
+        return listWithoutIndex(arr, index);
+    }
+    return arr;
+}
+
+export { Unpromise, resolveSelfTuple };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "11.0.0-alpha-tmp-subscription-connection-state.489+04c141d1b",
+  "version": "11.0.0-alpha-tmp-12-06-react.665+f3677f632",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -18,7 +18,7 @@
     "dev": "pnpm build --watch",
     "codegen-entrypoints": "tsx entrypoints.script.ts",
     "benchmark": "tsc --project tsconfig.benchmark.json",
-    "lint": "eslint --cache --ext \".js,.ts,.tsx\" --ignore-path ../../.gitignore src",
+    "lint": "eslint --cache src",
     "ts-watch": "tsc --watch"
   },
   "exports": {
@@ -110,38 +110,38 @@
     "rpc",
     "shared",
     "unstable-core-do-not-import",
-    "!**/*.test.*"
+    "!**/*.test.*",
+    "!**/__tests__"
   ],
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
     "@fastify/websocket": "^10.0.1",
-    "@tanstack/react-query": "^5.51.11",
+    "@tanstack/react-query": "^5.59.15",
     "@types/aws-lambda": "^8.10.137",
     "@types/express": "^4.17.17",
     "@types/hash-sum": "^1.0.0",
-    "@types/node": "^20.10.0",
-    "@types/react": "^18.3.1",
-    "@types/react-dom": "^18.3.0",
+    "@types/node": "^22.9.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
     "@types/ws": "^8.2.0",
     "devalue": "^5.0.0",
-    "eslint": "^8.57.0",
+    "eslint": "^9.13.0",
     "express": "^4.17.1",
     "fastify": "^4.16.0",
-    "fastify-plugin": "^4.5.0",
+    "fastify-plugin": "^5.0.0",
     "hash-sum": "^2.0.0",
     "myzod": "^1.3.1",
-    "next": "^14.2.5",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "rollup": "^4.9.5",
+    "next": "^15.0.4",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "rollup": "^4.24.4",
     "superjson": "^1.12.4",
     "superstruct": "^2.0.0",
-    "tslib": "^2.5.0",
     "tsx": "^4.0.0",
-    "typescript": "^5.5.3",
-    "valibot": "^0.37.0",
+    "typescript": "^5.7.0",
+    "valibot": "^0.42.0",
     "ws": "^8.0.0",
     "yup": "^1.0.0",
     "zod": "^3.0.0"
@@ -149,5 +149,8 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "04c141d1b4bb50631826aa956a874ba1d363f492"
+  "peerDependencies": {
+    "typescript": ">=5.6.2"
+  },
+  "gitHead": "f3677f6326d62400c29d1c358db9f3a68a0dd27d"
 }

package/src/@trpc/server/http.ts

@@ -18,9 +18,7 @@ export type {
 } from '../../unstable-core-do-not-import';
 
 export {
-  getBatchStreamFormatter,
   octetInputParser,
   parseConnectionParamsFromUnknown,
   parseConnectionParamsFromString,
-  toURL,
 } from '../../unstable-core-do-not-import';

package/src/@trpc/server/index.ts

@@ -42,6 +42,8 @@ export {
    */
   sse,
   tracked,
+  type TrackedEnvelope,
+  isTrackedEnvelope,
 } from '../../unstable-core-do-not-import';
 
 export type {

package/src/adapters/aws-lambda/getPlanner.ts

@@ -29,8 +29,8 @@ function determinePayloadFormat(event: LambdaEvent): string {
 export type inferAPIGWReturn<TEvent> = TEvent extends APIGatewayProxyEvent
   ? APIGatewayProxyResult
   : TEvent extends APIGatewayProxyEventV2
-  ? APIGatewayProxyStructuredResultV2
-  : never;
+    ? APIGatewayProxyStructuredResultV2
+    : never;
 
 interface Processor<TEvent extends LambdaEvent> {
   getTRPCPath: (event: TEvent) => string;

package/src/adapters/aws-lambda/index.ts

@@ -33,12 +33,11 @@ export type CreateAWSLambdaContextOptions<TEvent extends LambdaEvent> = {
 export type AWSLambdaOptions<
   TRouter extends AnyRouter,
   TEvent extends LambdaEvent,
-> =
-  | HTTPBaseHandlerOptions<TRouter, TEvent> &
-      CreateContextCallback<
-        inferRouterContext<AnyRouter>,
-        AWSLambdaCreateContextFn<TRouter, TEvent>
-      >;
+> = HTTPBaseHandlerOptions<TRouter, TEvent> &
+  CreateContextCallback<
+    inferRouterContext<AnyRouter>,
+    AWSLambdaCreateContextFn<TRouter, TEvent>
+  >;
 
 export type AWSLambdaCreateContextFn<
   TRouter extends AnyRouter,

package/src/adapters/express.ts

@@ -9,11 +9,13 @@
  */
 import type * as express from 'express';
 import type { AnyRouter } from '../@trpc/server';
+// eslint-disable-next-line no-restricted-imports
+import { run } from '../unstable-core-do-not-import';
 import type {
   NodeHTTPCreateContextFnOptions,
   NodeHTTPHandlerOptions,
 } from './node-http';
-import { nodeHTTPRequestHandler } from './node-http';
+import { internal_exceptionHandler, nodeHTTPRequestHandler } from './node-http';
 
 export type CreateExpressContextOptions = NodeHTTPCreateContextFnOptions<
   express.Request,
@@ -23,14 +25,24 @@ export type CreateExpressContextOptions = NodeHTTPCreateContextFnOptions<
 export function createExpressMiddleware<TRouter extends AnyRouter>(
   opts: NodeHTTPHandlerOptions<TRouter, express.Request, express.Response>,
 ): express.Handler {
-  return async (req, res) => {
-    const endpoint = req.path.slice(1);
+  return (req, res) => {
+    let path = '';
+    run(async () => {
+      path = req.path.slice(1);
 
-    await nodeHTTPRequestHandler({
-      ...(opts as any),
-      req,
-      res,
-      path: endpoint,
-    });
+      await nodeHTTPRequestHandler({
+        ...(opts as any),
+        req,
+        res,
+        path,
+      });
+    }).catch(
+      internal_exceptionHandler({
+        req,
+        res,
+        path,
+        ...opts,
+      }),
+    );
   };
 }

package/src/adapters/fastify/fastifyRequestHandler.ts

@@ -60,7 +60,7 @@ export async function fastifyRequestHandler<
   if ('body' in opts.req) {
     incomingMessage.body = opts.req.body;
   }
-  const req = incomingMessageToRequest(incomingMessage, {
+  const req = incomingMessageToRequest(incomingMessage, opts.res.raw, {
     maxBodySize: null,
   });
 

package/src/adapters/fastify/fastifyTRPCPlugin.ts

@@ -14,7 +14,11 @@ import type { AnyRouter } from '../../@trpc/server';
 // @trpc/server/http
 import type { NodeHTTPCreateContextFnOptions } from '../node-http';
 // @trpc/server/ws
-import { getWSConnectionHandler, type WSSHandlerOptions } from '../ws';
+import {
+  getWSConnectionHandler,
+  handleKeepAlive,
+  type WSSHandlerOptions,
+} from '../ws';
 import type { FastifyHandlerOptions } from './fastifyRequestHandler';
 import { fastifyRequestHandler } from './fastifyRequestHandler';
 
@@ -57,13 +61,20 @@ export function fastifyTRPCPlugin<TRouter extends AnyRouter>(
   });
 
   if (opts.useWSS) {
+    const trpcOptions =
+      opts.trpcOptions as unknown as WSSHandlerOptions<TRouter>;
+
     const onConnection = getWSConnectionHandler<TRouter>({
-      ...(opts.trpcOptions as unknown as WSSHandlerOptions<TRouter>),
+      ...trpcOptions,
     });
 
-    fastify.get(prefix ?? '/', { websocket: true }, (socket, req) =>
-      onConnection(socket, req.raw),
-    );
+    fastify.get(prefix ?? '/', { websocket: true }, async (socket, req) => {
+      await onConnection(socket, req.raw);
+      if (trpcOptions?.keepAlive?.enabled) {
+        const { pingMs, pongWaitMs } = trpcOptions.keepAlive;
+        handleKeepAlive(socket, pingMs, pongWaitMs);
+      }
+    });
   }
 
   done();

package/src/adapters/fetch/fetchRequestHandler.ts

@@ -11,7 +11,7 @@
 
 import type { AnyRouter } from '../../@trpc/server';
 import type { ResolveHTTPRequestOptionsContextFn } from '../../@trpc/server/http';
-import { resolveResponse, toURL } from '../../@trpc/server/http';
+import { resolveResponse } from '../../@trpc/server/http';
 import type { FetchHandlerRequestOptions } from './types';
 
 const trimSlashes = (path: string): string => {
@@ -32,7 +32,7 @@ export async function fetchRequestHandler<TRouter extends AnyRouter>(
     return opts.createContext?.({ req: opts.req, resHeaders, ...innerOpts });
   };
 
-  const url = toURL(opts.req.url);
+  const url = new URL(opts.req.url);
 
   const pathname = trimSlashes(url.pathname);
   const endpoint = trimSlashes(opts.endpoint);

package/src/adapters/next-app-dir/nextAppDirCaller.ts

@@ -96,6 +96,7 @@ export function nextAppDirCaller<TContext, TMeta>(
             getRawInput: async () => input,
             path,
             input,
+            signal: undefined,
           })
           .then((data) => {
             if (data instanceof TRPCRedirectError) throw data;
@@ -112,6 +113,7 @@ export function nextAppDirCaller<TContext, TMeta>(
             getRawInput: async () => input,
             path,
             input,
+            signal: undefined,
           })
           .then((data) => {
             if (data instanceof TRPCRedirectError) throw data;
@@ -119,6 +121,7 @@ export function nextAppDirCaller<TContext, TMeta>(
           })
           .catch(handleError);
       }
+      case 'subscription':
       default: {
         throw new TRPCError({
           code: 'NOT_IMPLEMENTED',

package/src/adapters/next-app-dir/rethrowNextErrors.ts

@@ -1,4 +1,4 @@
-import * as nextNavigation from 'next/navigation.js';
+import * as nextNavigation from 'next/navigation';
 import type { TRPCError } from '../../@trpc/server';
 import { TRPCRedirectError } from './redirect';
 
@@ -62,6 +62,7 @@ export const rethrowNextErrors = (error: TRPCError) => {
 
   // Before Next.js 15, we have to check and rethrow the error manually.
   if (isRedirectError(cause) || isNotFoundError(cause)) {
-    throw error.cause;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    throw cause!;
   }
 };

package/src/adapters/next.ts

@@ -11,12 +11,14 @@ import type { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
 // @trpc/server
 import type { AnyRouter } from '../@trpc/server';
 // @trpc/server
-import { getErrorShape, TRPCError } from '../@trpc/server';
+import { TRPCError } from '../@trpc/server';
+// eslint-disable-next-line no-restricted-imports
+import { run } from '../unstable-core-do-not-import';
 import type {
   NodeHTTPCreateContextFnOptions,
   NodeHTTPHandlerOptions,
 } from './node-http';
-import { nodeHTTPRequestHandler } from './node-http';
+import { internal_exceptionHandler, nodeHTTPRequestHandler } from './node-http';
 
 export type CreateNextContextOptions = NodeHTTPCreateContextFnOptions<
   NextApiRequest,
@@ -32,43 +34,36 @@ export function createNextApiHandler<TRouter extends AnyRouter>(
   opts: NodeHTTPHandlerOptions<TRouter, NextApiRequest, NextApiResponse>,
 ): NextApiHandler {
   return async (req, res) => {
-    function getPath(): string | null {
-      if (typeof req.query['trpc'] === 'string') {
-        return req.query['trpc'];
-      }
-      if (Array.isArray(req.query['trpc'])) {
-        return req.query['trpc'].join('/');
-      }
-      return null;
-    }
-    const path = getPath();
+    let path = '';
 
-    if (path === null) {
-      const error = getErrorShape({
-        config: opts.router._def._config,
-        error: new TRPCError({
+    await run(async () => {
+      path = run(() => {
+        if (typeof req.query['trpc'] === 'string') {
+          return req.query['trpc'];
+        }
+        if (Array.isArray(req.query['trpc'])) {
+          return req.query['trpc'].join('/');
+        }
+        throw new TRPCError({
           message:
             'Query "trpc" not found - is the file named `[trpc]`.ts or `[...trpc].ts`?',
           code: 'INTERNAL_SERVER_ERROR',
-        }),
-        type: 'unknown',
-        ctx: undefined,
-        path: undefined,
-        input: undefined,
+        });
       });
-      res.statusCode = 500;
-      res.json({
-        id: -1,
-        error,
-      });
-      return;
-    }
 
-    await nodeHTTPRequestHandler({
-      ...(opts as any),
-      req,
-      res,
-      path,
-    });
+      await nodeHTTPRequestHandler({
+        ...(opts as any),
+        req,
+        res,
+        path,
+      });
+    }).catch(
+      internal_exceptionHandler({
+        req,
+        res,
+        path,
+        ...opts,
+      }),
+    );
   };
 }