@vercel/node 2.11.0 → 2.13.0

package/dist/{dev-server.js → dev-server.mjs}

@@ -1,49 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.onDevRequest = void 0;
 const entrypoint = process.env.VERCEL_DEV_ENTRYPOINT;
 delete process.env.VERCEL_DEV_ENTRYPOINT;
 if (!entrypoint) {
     throw new Error('`VERCEL_DEV_ENTRYPOINT` must be defined');
 }
-delete process.env.TS_NODE_TRANSPILE_ONLY;
-delete process.env.TS_NODE_COMPILER_OPTIONS;
-const path_1 = require("path");
-const useRequire = process.env.VERCEL_DEV_IS_ESM !== '1';
-const http_1 = require("http");
-const static_config_1 = require("@vercel/static-config");
-const ts_morph_1 = require("ts-morph");
-const utils_1 = require("./utils");
-const edge_handler_1 = require("./edge-functions/edge-handler");
-const serverless_handler_1 = require("./serverless-functions/serverless-handler");
-function listen(server, port, host) {
-    return new Promise(resolve => {
-        server.listen(port, host, () => {
-            resolve();
-        });
-    });
-}
-function parseRuntime(entrypoint, entryPointPath) {
-    const project = new ts_morph_1.Project();
-    const staticConfig = static_config_1.getConfig(project, entryPointPath);
-    const runtime = staticConfig?.runtime;
-    if (runtime && !utils_1.isEdgeRuntime(runtime)) {
-        throw new Error(`Invalid function runtime "${runtime}" for "${entrypoint}". Valid runtimes are: ${JSON.stringify(Object.values(utils_1.EdgeRuntimes))}. Learn more: https://vercel.link/creating-edge-functions`);
+import { join } from 'path';
+import { createEdgeEventHandler } from './edge-functions/edge-handler.mjs';
+import { createServer } from 'http';
+import { createServerlessEventHandler } from './serverless-functions/serverless-handler.mjs';
+import { EdgeRuntimes, isEdgeRuntime, logError } from './utils.js';
+import { getConfig } from '@vercel/static-config';
+import { Project } from 'ts-morph';
+import asyncListen from 'async-listen';
+const { default: listen } = asyncListen;
+const parseConfig = (entryPointPath) => getConfig(new Project(), entryPointPath);
+function getRuntime(runtime, entrypoint) {
+    if (runtime && !isEdgeRuntime(runtime)) {
+        throw new Error(`Invalid function runtime "${runtime}" for "${entrypoint}". Valid runtimes are: ${JSON.stringify(Object.values(EdgeRuntimes))}. Learn more: https://vercel.link/creating-edge-functions`);
     }
     return runtime;
 }
 async function createEventHandler(entrypoint, config, options) {
-    const entrypointPath = path_1.join(process.cwd(), entrypoint);
-    const runtime = parseRuntime(entrypoint, entrypointPath);
+    const entrypointPath = join(process.cwd(), entrypoint);
+    const staticConfig = parseConfig(entrypointPath);
+    const runtime = getRuntime(staticConfig?.runtime, entrypoint);
     // `middleware.js`/`middleware.ts` file is always run as
     // an Edge Function, otherwise needs to be opted-in via
     // `export const config = { runtime: 'edge' }`
-    if (config.middleware === true || utils_1.isEdgeRuntime(runtime)) {
-        return edge_handler_1.createEdgeEventHandler(entrypointPath, entrypoint, config.middleware || false, config.zeroConfig);
+    if (config.middleware === true || isEdgeRuntime(runtime)) {
+        return createEdgeEventHandler(entrypointPath, entrypoint, config.middleware || false, config.zeroConfig);
     }
-    return serverless_handler_1.createServerlessEventHandler(entrypointPath, {
+    return createServerlessEventHandler(entrypointPath, {
+        mode: staticConfig?.supportsResponseStreaming ? 'streaming' : 'buffer',
         shouldAddHelpers: options.shouldAddHelpers,
-        useRequire,
     });
 }
 let handleEvent;
@@ -54,15 +42,15 @@ async function main() {
     const buildEnv = JSON.parse(process.env.VERCEL_DEV_BUILD_ENV || '{}');
     delete process.env.VERCEL_DEV_BUILD_ENV;
     const shouldAddHelpers = !(config.helpers === false || buildEnv.NODEJS_HELPERS === '0');
-    const proxyServer = http_1.createServer(onDevRequest);
-    await listen(proxyServer, 0, '127.0.0.1');
+    const proxyServer = createServer(onDevRequest);
+    await listen(proxyServer, { host: '127.0.0.1', port: 0 });
     try {
         handleEvent = await createEventHandler(entrypoint, config, {
             shouldAddHelpers,
         });
     }
     catch (error) {
-        utils_1.logError(error);
+        logError(error);
         handlerEventError = error;
     }
     const address = proxyServer.address();
@@ -86,22 +74,26 @@ async function onDevRequest(req, res) {
         return;
     }
     try {
-        const result = await handleEvent(req);
-        res.statusCode = result.statusCode;
-        for (const [key, value] of Object.entries(result.headers)) {
-            if (typeof value !== 'undefined') {
+        const { headers, body, status } = await handleEvent(req);
+        res.statusCode = status;
+        for (const [key, value] of headers) {
+            if (value !== undefined) {
                 res.setHeader(key, value);
             }
         }
-        res.end(Buffer.from(result.body, result.encoding));
+        if (body instanceof Buffer) {
+            res.end(body);
+        }
+        else {
+            body.pipe(res);
+        }
     }
     catch (error) {
         res.statusCode = 500;
         res.end(error.stack);
     }
 }
-exports.onDevRequest = onDevRequest;
 main().catch(err => {
-    utils_1.logError(err);
+    logError(err);
     process.exit(1);
 });

package/dist/edge-functions/edge-handler-template.js

@@ -1,49 +1,29 @@
 // provided by the edge runtime:
 /* global addEventListener */
 
-function buildUrl(requestDetails) {
-  const host = requestDetails.headers['x-forwarded-host'] || '127.0.0.1';
-  const path = requestDetails.url || '/';
-
-  const allProtocols = requestDetails.headers['x-forwarded-proto'];
-  let proto;
-  if (allProtocols) {
-    // handle multi-protocol like: https,http://...
-    proto = allProtocols.split(/\b/).shift();
-  } else {
-    proto = 'http';
-  }
-
-  return `${proto}://${host}${path}`;
+function getUrl(url, headers) {
+  const urlObj = new URL(url);
+  const protocol = headers.get('x-forwarded-proto');
+  if (protocol) urlObj.protocol = protocol.split(/\b/).shift();
+  urlObj.host = headers.get('x-forwarded-host');
+  urlObj.port = headers.get('x-forwarded-port');
+  return urlObj.toString();
 }
 
-async function respond(
-  userEdgeHandler,
-  requestDetails,
-  event,
-  options,
-  dependencies
-) {
+async function respond(userEdgeHandler, event, options, dependencies) {
   const { Request, Response } = dependencies;
   const { isMiddleware } = options;
-
-  let body;
-
-  if (requestDetails.method !== 'GET' && requestDetails.method !== 'HEAD') {
-    if (requestDetails.body) {
-      body = Uint8Array.from(atob(requestDetails.body), c => c.charCodeAt(0));
-    }
-  }
-
-  const request = new Request(buildUrl(requestDetails), {
-    headers: requestDetails.headers,
-    method: requestDetails.method,
-    body: body,
-  });
-
-  event.request = request;
-
-  let response = await userEdgeHandler(event.request, event);
+  event.request.headers.set(
+    'host',
+    event.request.headers.get('x-forwarded-host')
+  );
+  let response = await userEdgeHandler(
+    new Request(
+      getUrl(event.request.url, event.request.headers),
+      event.request
+    ),
+    event
+  );
 
   if (!response) {
     if (isMiddleware) {
@@ -85,10 +65,8 @@ async function parseRequestEvent(event) {
 function registerFetchListener(userEdgeHandler, options, dependencies) {
   addEventListener('fetch', async event => {
     try {
-      const requestDetails = await parseRequestEvent(event);
       const response = await respond(
         userEdgeHandler,
-        requestDetails,
         event,
         options,
         dependencies
@@ -100,11 +78,10 @@ function registerFetchListener(userEdgeHandler, options, dependencies) {
   });
 }
 
-// for testing:
 module.exports = {
-  buildUrl,
-  respond,
-  toResponseError,
+  getUrl,
   parseRequestEvent,
   registerFetchListener,
+  respond,
+  toResponseError,
 };

package/dist/edge-functions/{edge-handler.js → edge-handler.mjs}

@@ -1,39 +1,25 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEdgeEventHandler = void 0;
-const build_utils_1 = require("@vercel/build-utils");
-const exit_hook_1 = __importDefault(require("exit-hook"));
-const edge_runtime_1 = require("edge-runtime");
-const esbuild_1 = __importDefault(require("esbuild"));
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const edge_wasm_plugin_1 = require("./edge-wasm-plugin");
-const utils_1 = require("../utils");
-const fs_1 = require("fs");
-const edge_node_compat_plugin_1 = require("./edge-node-compat-plugin");
+import { createEdgeWasmPlugin } from './edge-wasm-plugin.mjs';
+import { createNodeCompatPlugin, } from './edge-node-compat-plugin.mjs';
+import { EdgeRuntime, runServer } from 'edge-runtime';
+import fetch, { Headers } from 'node-fetch';
+import { isError } from '@vercel/error-utils';
+import { readFileSync } from 'fs';
+import { serializeBody, entrypointToOutputPath, logError } from '../utils.js';
+import esbuild from 'esbuild';
+import exitHook from 'exit-hook';
+import { fileURLToPath } from 'url';
 const NODE_VERSION_MAJOR = process.version.match(/^v(\d+)\.\d+/)?.[1];
 const NODE_VERSION_IDENTIFIER = `node${NODE_VERSION_MAJOR}`;
 if (!NODE_VERSION_MAJOR) {
     throw new Error(`Unable to determine current node version: process.version=${process.version}`);
 }
-const edgeHandlerTemplate = fs_1.readFileSync(`${__dirname}/edge-handler-template.js`);
-async function serializeRequest(message) {
-    const bodyBuffer = await build_utils_1.streamToBuffer(message);
-    const body = bodyBuffer.toString('base64');
-    return JSON.stringify({
-        url: message.url,
-        method: message.method,
-        headers: message.headers,
-        body,
-    });
-}
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const edgeHandlerTemplate = readFileSync(`${__dirname}/edge-handler-template.js`);
 async function compileUserCode(entrypointFullPath, entrypointRelativePath, isMiddleware) {
-    const { wasmAssets, plugin: edgeWasmPlugin } = edge_wasm_plugin_1.createEdgeWasmPlugin();
-    const nodeCompatPlugin = edge_node_compat_plugin_1.createNodeCompatPlugin();
+    const { wasmAssets, plugin: edgeWasmPlugin } = createEdgeWasmPlugin();
+    const nodeCompatPlugin = createNodeCompatPlugin();
     try {
-        const result = await esbuild_1.default.build({
+        const result = await esbuild.build({
             // bundling behavior: use globals (like "browser") instead
             // of "require" statements for core libraries (like "node")
             platform: 'browser',
@@ -43,7 +29,20 @@ async function compileUserCode(entrypointFullPath, entrypointRelativePath, isMid
             sourcemap: 'inline',
             legalComments: 'none',
             bundle: true,
-            plugins: [edgeWasmPlugin, nodeCompatPlugin.plugin],
+            plugins: [
+                edgeWasmPlugin,
+                nodeCompatPlugin.plugin,
+                {
+                    name: 'import.meta.url',
+                    setup({ onLoad }) {
+                        onLoad({ filter: /\.[cm]?js$/, namespace: 'file' }, args => {
+                            let code = readFileSync(args.path, 'utf8');
+                            code = code.replace(/\bimport\.meta\.url\b/g, JSON.stringify(import.meta.url));
+                            return { contents: code };
+                        });
+                    },
+                },
+            ],
             entryPoints: [entrypointFullPath],
             write: false,
             format: 'cjs',
@@ -71,14 +70,8 @@ async function compileUserCode(entrypointFullPath, entrypointRelativePath, isMid
 
       // edge handler
       ${edgeHandlerTemplate};
-      const dependencies = {
-        Request,
-        Response
-      };
-      const options = {
-        isMiddleware,
-        entrypointLabel
-      };
+      const dependencies = { Request, Response };
+      const options = { isMiddleware, entrypointLabel };
       registerFetchListener(userEdgeHandler, options, dependencies);
     `;
         return {
@@ -91,20 +84,21 @@ async function compileUserCode(entrypointFullPath, entrypointRelativePath, isMid
         // We can't easily show a meaningful stack trace from ncc -> edge-runtime.
         // So, stick with just the message for now.
         console.error(`Failed to compile user code for edge runtime.`);
-        utils_1.logError(error);
+        if (isError(error))
+            logError(error);
         return undefined;
     }
 }
-async function createEdgeRuntime(params) {
+async function createEdgeRuntimeServer(params) {
     try {
         if (!params) {
             return undefined;
         }
         const wasmBindings = await params.wasmAssets.getContext();
         const nodeCompatBindings = params.nodeCompatBindings.getContext();
-        const edgeRuntime = new edge_runtime_1.EdgeRuntime({
+        const runtime = new EdgeRuntime({
             initialCode: params.userCode,
-            extend: (context) => {
+            extend: context => {
                 Object.assign(context, {
                     // This is required for esbuild wrapping logic to resolve
                     module: {},
@@ -122,21 +116,21 @@ async function createEdgeRuntime(params) {
                 return context;
             },
         });
-        const server = await edge_runtime_1.runServer({ runtime: edgeRuntime });
-        exit_hook_1.default(server.close);
+        const server = await runServer({ runtime });
+        exitHook(() => server.close());
         return server;
     }
     catch (error) {
         // We can't easily show a meaningful stack trace from ncc -> edge-runtime.
         // So, stick with just the message for now.
         console.error('Failed to instantiate edge runtime.');
-        utils_1.logError(error);
+        logError(error);
         return undefined;
     }
 }
-async function createEdgeEventHandler(entrypointFullPath, entrypointRelativePath, isMiddleware, isZeroConfig) {
+export async function createEdgeEventHandler(entrypointFullPath, entrypointRelativePath, isMiddleware, isZeroConfig) {
     const userCode = await compileUserCode(entrypointFullPath, entrypointRelativePath, isMiddleware);
-    const server = await createEdgeRuntime(userCode);
+    const server = await createEdgeRuntimeServer(userCode);
     return async function (request) {
         if (!server) {
             // this error state is already logged, but we have to wait until here to exit the process
@@ -144,14 +138,21 @@ async function createEdgeEventHandler(entrypointFullPath, entrypointRelativePath
             // an error is thrown in the function
             process.exit(1);
         }
-        const response = await node_fetch_1.default(server.url, {
+        const headers = new Headers(request.headers);
+        const body = await serializeBody(request);
+        if (body !== undefined)
+            headers.set('content-length', String(body.length));
+        const url = new URL(request.url ?? '/', server.url);
+        // @ts-expect-error
+        const response = await fetch(url, {
+            body,
+            headers,
+            method: request.method,
             redirect: 'manual',
-            method: 'post',
-            body: await serializeRequest(request),
         });
-        const body = await response.text();
         const isUserError = response.headers.get('x-vercel-failed') === 'edge-wrapper';
         if (isUserError && response.status >= 500) {
+            const body = await response.text();
             // We can't currently get a real stack trace from the Edge Function error,
             // but we can fake a basic one that is still usefult to the user.
             const fakeStackTrace = `    at (${entrypointRelativePath})`;
@@ -162,16 +163,15 @@ async function createEdgeEventHandler(entrypointFullPath, entrypointRelativePath
             process.exit(1);
         }
         return {
-            statusCode: response.status,
-            headers: response.headers.raw(),
-            body,
+            status: response.status,
+            headers: response.headers,
+            body: response.body,
             encoding: 'utf8',
         };
     };
 }
-exports.createEdgeEventHandler = createEdgeEventHandler;
 function entrypointToRequestPath(entrypointRelativePath, isZeroConfig) {
     // ensure the path starts with a slash to match conventions used elsewhere,
     // notably when rendering serverless function paths in error messages
-    return '/' + utils_1.entrypointToOutputPath(entrypointRelativePath, isZeroConfig);
+    return '/' + entrypointToOutputPath(entrypointRelativePath, isZeroConfig);
 }

package/dist/edge-functions/{edge-node-compat-plugin.js → edge-node-compat-plugin.mjs}

@@ -1,14 +1,8 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodeCompatPlugin = exports.NodeCompatBindings = void 0;
-const buffer_1 = __importDefault(require("buffer"));
-const events_1 = __importDefault(require("events"));
-const async_hooks_1 = __importDefault(require("async_hooks"));
-const assert_1 = __importDefault(require("assert"));
-const util_1 = __importDefault(require("util"));
+import BufferImplementation from 'buffer';
+import EventsImplementation from 'events';
+import AsyncHooksImplementation from 'async_hooks';
+import AssertImplementation from 'assert';
+import UtilImplementation from 'util';
 const SUPPORTED_NODE_MODULES = [
     'buffer',
     'events',
@@ -26,14 +20,14 @@ function pick(obj, keys) {
 }
 const NativeModuleMap = () => {
     const mods = {
-        buffer: pick(buffer_1.default, [
+        buffer: pick(BufferImplementation, [
             'constants',
             'kMaxLength',
             'kStringMaxLength',
             'Buffer',
             'SlowBuffer',
         ]),
-        events: pick(events_1.default, [
+        events: pick(EventsImplementation, [
             'EventEmitter',
             'captureRejectionSymbol',
             'defaultMaxListeners',
@@ -42,11 +36,11 @@ const NativeModuleMap = () => {
             'on',
             'once',
         ]),
-        async_hooks: pick(async_hooks_1.default, [
+        async_hooks: pick(AsyncHooksImplementation, [
             'AsyncLocalStorage',
             'AsyncResource',
         ]),
-        assert: pick(assert_1.default, [
+        assert: pick(AssertImplementation, [
             'AssertionError',
             'deepEqual',
             'deepStrictEqual',
@@ -67,7 +61,7 @@ const NativeModuleMap = () => {
             'strictEqual',
             'throws',
         ]),
-        util: pick(util_1.default, [
+        util: pick(UtilImplementation, [
             '_extend',
             'callbackify',
             'format',
@@ -79,7 +73,7 @@ const NativeModuleMap = () => {
     return new Map(Object.entries(mods));
 };
 const NODE_COMPAT_NAMESPACE = 'vercel-node-compat';
-class NodeCompatBindings {
+export class NodeCompatBindings {
     constructor() {
         this.bindings = new Map();
     }
@@ -107,13 +101,12 @@ class NodeCompatBindings {
         return context;
     }
 }
-exports.NodeCompatBindings = NodeCompatBindings;
 /**
  * Allows to enable Node.js compatibility by detecting namespaced `node:`
  * imports and producing metadata to bind global variables for each.
  * It requires from the consumer to add the imports.
  */
-function createNodeCompatPlugin() {
+export function createNodeCompatPlugin() {
     const bindings = new NodeCompatBindings();
     const plugin = {
         name: 'vc-node-compat',
@@ -145,4 +138,3 @@ function createNodeCompatPlugin() {
         bindings,
     };
 }
-exports.createNodeCompatPlugin = createNodeCompatPlugin;

package/dist/edge-functions/{edge-wasm-plugin.js → edge-wasm-plugin.mjs}

@@ -1,11 +1,8 @@
-"use strict";
 // copied from `edge-functions-bridge`:
 // https://github.com/vercel/runtimes/blob/c076db9e3ce5635f7c2690396e3d9f791a0fd808/packages/edge-functions-bridge/src/get-edge-function-source.ts#L282-L317
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEdgeWasmPlugin = exports.WasmAssets = void 0;
-const crypto_1 = require("crypto");
-const fs_1 = require("fs");
-class WasmAssets {
+import { createHash } from 'crypto';
+import { promises as fs } from 'fs';
+export class WasmAssets {
     constructor() {
         this.assets = new Map();
     }
@@ -13,7 +10,7 @@ class WasmAssets {
      * Declare a WebAssembly binding
      */
     async declare(filePath) {
-        const hash = sha1(await fs_1.promises.readFile(filePath));
+        const hash = sha1(await fs.readFile(filePath));
         const name = `wasm_${hash}`;
         this.assets.set(name, filePath);
         return name;
@@ -27,7 +24,7 @@ class WasmAssets {
         const context = {};
         for (const [name, filePath] of this.assets) {
             promises.push((async () => {
-                const bytes = await fs_1.promises.readFile(filePath);
+                const bytes = await fs.readFile(filePath);
                 context[name] = await WebAssembly.compile(bytes);
             })());
         }
@@ -41,8 +38,7 @@ class WasmAssets {
         return this.assets[Symbol.iterator]();
     }
 }
-exports.WasmAssets = WasmAssets;
-function createEdgeWasmPlugin() {
+export function createEdgeWasmPlugin() {
     const wasmAssets = new WasmAssets();
     const plugin = {
         name: 'vercel-wasm',
@@ -76,7 +72,6 @@ function createEdgeWasmPlugin() {
     };
     return { plugin, wasmAssets };
 }
-exports.createEdgeWasmPlugin = createEdgeWasmPlugin;
 function sha1(data) {
-    return crypto_1.createHash('sha1').update(data).digest('hex');
+    return createHash('sha1').update(data).digest('hex');
 }

package/dist/fork-dev-server.js

@@ -12,17 +12,12 @@ const path_1 = require("path");
 function forkDevServer(options) {
     let nodeOptions = process.env.NODE_OPTIONS;
     const tsNodePath = options.require_.resolve('ts-node');
-    const esmLoader = url_1.pathToFileURL(path_1.join(tsNodePath, '..', '..', 'esm.mjs'));
-    const cjsLoader = path_1.join(tsNodePath, '..', '..', 'register', 'index.js');
-    const devServerPath = options.devServerPath || path_1.join(__dirname, 'dev-server.js');
+    const esmLoader = (0, url_1.pathToFileURL)((0, path_1.join)(tsNodePath, '..', '..', 'esm.mjs'));
+    const cjsLoader = (0, path_1.join)(tsNodePath, '..', '..', 'register', 'index.js');
+    const devServerPath = options.devServerPath || (0, path_1.join)(__dirname, 'dev-server.mjs');
     if (options.maybeTranspile) {
         if (options.isTypeScript) {
-            if (options.isEsm) {
-                nodeOptions = `--loader ${esmLoader} ${nodeOptions || ''}`;
-            }
-            else {
-                nodeOptions = `--require ${cjsLoader} ${nodeOptions || ''}`;
-            }
+            nodeOptions = `--loader ${esmLoader} ${nodeOptions || ''}`;
         }
         else {
             if (options.isEsm) {
@@ -36,9 +31,8 @@ function forkDevServer(options) {
     const forkOptions = {
         cwd: options.workPath,
         execArgv: [],
-        env: build_utils_1.cloneEnv(process.env, options.meta.env, {
+        env: (0, build_utils_1.cloneEnv)(process.env, options.meta.env, {
             VERCEL_DEV_ENTRYPOINT: options.entrypoint,
-            VERCEL_DEV_IS_ESM: options.isEsm ? '1' : undefined,
             VERCEL_DEV_CONFIG: JSON.stringify(options.config),
             VERCEL_DEV_BUILD_ENV: JSON.stringify(options.meta.buildEnv || {}),
             TS_NODE_TRANSPILE_ONLY: '1',
@@ -48,7 +42,7 @@ function forkDevServer(options) {
             NODE_OPTIONS: nodeOptions,
         }),
     };
-    const child = child_process_1.fork(devServerPath, [], forkOptions);
+    const child = (0, child_process_1.fork)(devServerPath, [], forkOptions);
     checkForPid(devServerPath, child);
     return child;
 }
@@ -64,7 +58,7 @@ function checkForPid(path, process) {
  * or it is listening to new requests, and we can start proxying requests.
  */
 async function readMessage(child) {
-    const onMessage = once_1.default(child, 'message');
+    const onMessage = (0, once_1.default)(child, 'message');
     const onExit = once_1.default.spread(child, 'close');
     const result = await Promise.race([
         onMessage.then(x => {

package/dist/index.d.ts

@@ -1,33 +1,41 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { ServerResponse, IncomingMessage } from 'http';
-export declare type VercelRequestCookies = {
+import type { Headers } from 'node-fetch';
+export type VercelRequestCookies = {
     [key: string]: string;
 };
-export declare type VercelRequestQuery = {
+export type VercelRequestQuery = {
     [key: string]: string | string[];
 };
-export declare type VercelRequestBody = any;
-export declare type VercelRequest = IncomingMessage & {
+export type VercelRequestBody = any;
+export type VercelRequest = IncomingMessage & {
     query: VercelRequestQuery;
     cookies: VercelRequestCookies;
     body: VercelRequestBody;
 };
-export declare type VercelResponse = ServerResponse & {
+export type VercelResponse = ServerResponse & {
     send: (body: any) => VercelResponse;
     json: (jsonBody: any) => VercelResponse;
     status: (statusCode: number) => VercelResponse;
     redirect: (statusOrUrl: string | number, url?: string) => VercelResponse;
 };
-export declare type VercelApiHandler = (req: VercelRequest, res: VercelResponse) => void | Promise<void>;
+export type VercelApiHandler = (req: VercelRequest, res: VercelResponse) => void | Promise<void>;
 /** @deprecated Use VercelRequestCookies instead. */
-export declare type NowRequestCookies = VercelRequestCookies;
+export type NowRequestCookies = VercelRequestCookies;
 /** @deprecated Use VercelRequestQuery instead. */
-export declare type NowRequestQuery = VercelRequestQuery;
+export type NowRequestQuery = VercelRequestQuery;
 /** @deprecated Use VercelRequestBody instead. */
-export declare type NowRequestBody = any;
+export type NowRequestBody = any;
 /** @deprecated Use VercelRequest instead. */
-export declare type NowRequest = VercelRequest;
+export type NowRequest = VercelRequest;
 /** @deprecated Use VercelResponse instead. */
-export declare type NowResponse = VercelResponse;
+export type NowResponse = VercelResponse;
 /** @deprecated Use VercelApiHandler instead. */
-export declare type NowApiHandler = VercelApiHandler;
+export type NowApiHandler = VercelApiHandler;
+export interface VercelProxyResponse {
+    status: number;
+    headers: Headers;
+    body: Buffer | NodeJS.ReadableStream;
+    encoding: BufferEncoding;
+}