@vercel/node 2.13.0 → 2.14.0

package/dist/dev-server.mjs

@@ -7,22 +7,17 @@ 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 { isEdgeRuntime, logError, validateConfiguredRuntime } 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 = join(process.cwd(), entrypoint);
     const staticConfig = parseConfig(entrypointPath);
-    const runtime = getRuntime(staticConfig?.runtime, entrypoint);
+    const runtime = staticConfig?.runtime;
+    validateConfiguredRuntime(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' }`

package/dist/edge-functions/edge-handler.mjs

@@ -96,12 +96,23 @@ async function createEdgeRuntimeServer(params) {
         }
         const wasmBindings = await params.wasmAssets.getContext();
         const nodeCompatBindings = params.nodeCompatBindings.getContext();
+        let WebSocket;
+        // undici's WebSocket handling is only available in Node.js >= 18
+        // so fallback to using ws for v16
+        if (Number(process.version.split('.')[0].substring(1)) < 18) {
+            // @ts-ignore
+            WebSocket = (await import('ws')).WebSocket;
+        }
+        else {
+            WebSocket = (await import('undici')).WebSocket;
+        }
         const runtime = new EdgeRuntime({
             initialCode: params.userCode,
             extend: context => {
                 Object.assign(context, {
                     // This is required for esbuild wrapping logic to resolve
                     module: {},
+                    WebSocket,
                     // This is required for environment variable access.
                     // In production, env var access is provided by static analysis
                     // so that only the used values are available.

package/dist/fork-dev-server.js

@@ -10,7 +10,10 @@ const child_process_1 = require("child_process");
 const url_1 = require("url");
 const path_1 = require("path");
 function forkDevServer(options) {
-    let nodeOptions = process.env.NODE_OPTIONS;
+    let nodeOptions = process.env.NODE_OPTIONS || '';
+    if (!nodeOptions.includes('--no-warnings')) {
+        nodeOptions += ' --no-warnings';
+    }
     const tsNodePath = options.require_.resolve('ts-node');
     const esmLoader = (0, url_1.pathToFileURL)((0, path_1.join)(tsNodePath, '..', '..', 'esm.mjs'));
     const cjsLoader = (0, path_1.join)(tsNodePath, '..', '..', 'register', 'index.js');

package/dist/index.js

@@ -15545,7 +15545,7 @@ function hoistVariables(path, emit, kind = "var") {
 
 /***/ }),
 
-/***/ 92288:
+/***/ 60732:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -15555,8 +15555,11 @@ Object.defineProperty(exports, "__esModule", ({
   value: true
 }));
 exports.default = void 0;
+
 var _assert = __webpack_require__(42357);
+
 var _t = __webpack_require__(32338);
+
 const {
   callExpression,
   cloneNode,
@@ -15571,6 +15574,7 @@ const {
   variableDeclaration,
   variableDeclarator
 } = _t;
+
 class ImportBuilder {
   constructor(importedSource, scope, hub) {
     this._statements = [];
@@ -15580,102 +15584,139 @@ class ImportBuilder {
     this._hub = hub;
     this._importedSource = importedSource;
   }
+
   done() {
     return {
       statements: this._statements,
       resultName: this._resultName
     };
   }
+
   import() {
     this._statements.push(importDeclaration([], stringLiteral(this._importedSource)));
+
     return this;
   }
+
   require() {
     this._statements.push(expressionStatement(callExpression(identifier("require"), [stringLiteral(this._importedSource)])));
+
     return this;
   }
+
   namespace(name = "namespace") {
     const local = this._scope.generateUidIdentifier(name);
+
     const statement = this._statements[this._statements.length - 1];
+
     _assert(statement.type === "ImportDeclaration");
+
     _assert(statement.specifiers.length === 0);
+
     statement.specifiers = [importNamespaceSpecifier(local)];
     this._resultName = cloneNode(local);
     return this;
   }
+
   default(name) {
     const id = this._scope.generateUidIdentifier(name);
+
     const statement = this._statements[this._statements.length - 1];
+
     _assert(statement.type === "ImportDeclaration");
+
     _assert(statement.specifiers.length === 0);
+
     statement.specifiers = [importDefaultSpecifier(id)];
     this._resultName = cloneNode(id);
     return this;
   }
+
   named(name, importName) {
     if (importName === "default") return this.default(name);
+
     const id = this._scope.generateUidIdentifier(name);
+
     const statement = this._statements[this._statements.length - 1];
+
     _assert(statement.type === "ImportDeclaration");
+
     _assert(statement.specifiers.length === 0);
+
     statement.specifiers = [importSpecifier(id, identifier(importName))];
     this._resultName = cloneNode(id);
     return this;
   }
+
   var(name) {
     const id = this._scope.generateUidIdentifier(name);
+
     let statement = this._statements[this._statements.length - 1];
+
     if (statement.type !== "ExpressionStatement") {
       _assert(this._resultName);
+
       statement = expressionStatement(this._resultName);
+
       this._statements.push(statement);
     }
+
     this._statements[this._statements.length - 1] = variableDeclaration("var", [variableDeclarator(id, statement.expression)]);
     this._resultName = cloneNode(id);
     return this;
   }
+
   defaultInterop() {
     return this._interop(this._hub.addHelper("interopRequireDefault"));
   }
+
   wildcardInterop() {
     return this._interop(this._hub.addHelper("interopRequireWildcard"));
   }
+
   _interop(callee) {
     const statement = this._statements[this._statements.length - 1];
+
     if (statement.type === "ExpressionStatement") {
       statement.expression = callExpression(callee, [statement.expression]);
     } else if (statement.type === "VariableDeclaration") {
       _assert(statement.declarations.length === 1);
+
       statement.declarations[0].init = callExpression(callee, [statement.declarations[0].init]);
     } else {
       _assert.fail("Unexpected type.");
     }
+
     return this;
   }
+
   prop(name) {
     const statement = this._statements[this._statements.length - 1];
+
     if (statement.type === "ExpressionStatement") {
       statement.expression = memberExpression(statement.expression, identifier(name));
     } else if (statement.type === "VariableDeclaration") {
       _assert(statement.declarations.length === 1);
+
       statement.declarations[0].init = memberExpression(statement.declarations[0].init, identifier(name));
     } else {
       _assert.fail("Unexpected type:" + statement.type);
     }
+
     return this;
   }
+
   read(name) {
     this._resultName = memberExpression(this._resultName, identifier(name));
   }
-}
-exports.default = ImportBuilder;
 
-//# sourceMappingURL=import-builder.js.map
+}
 
+exports.default = ImportBuilder;
 
 /***/ }),
 
-/***/ 37615:
+/***/ 27340:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -15685,14 +15726,20 @@ Object.defineProperty(exports, "__esModule", ({
   value: true
 }));
 exports.default = void 0;
+
 var _assert = __webpack_require__(42357);
+
 var _t = __webpack_require__(32338);
-var _importBuilder = __webpack_require__(92288);
-var _isModule = __webpack_require__(59462);
+
+var _importBuilder = __webpack_require__(60732);
+
+var _isModule = __webpack_require__(77901);
+
 const {
   numericLiteral,
   sequenceExpression
 } = _t;
+
 class ImportInjector {
   constructor(path, importedSource, opts) {
     this._defaultOpts = {
@@ -15710,35 +15757,46 @@ class ImportInjector {
     this._hub = programPath.hub;
     this._defaultOpts = this._applyDefaults(importedSource, opts, true);
   }
+
   addDefault(importedSourceIn, opts) {
     return this.addNamed("default", importedSourceIn, opts);
   }
+
   addNamed(importName, importedSourceIn, opts) {
     _assert(typeof importName === "string");
+
     return this._generateImport(this._applyDefaults(importedSourceIn, opts), importName);
   }
+
   addNamespace(importedSourceIn, opts) {
     return this._generateImport(this._applyDefaults(importedSourceIn, opts), null);
   }
+
   addSideEffect(importedSourceIn, opts) {
     return this._generateImport(this._applyDefaults(importedSourceIn, opts), void 0);
   }
+
   _applyDefaults(importedSource, opts, isInit = false) {
     let newOpts;
+
     if (typeof importedSource === "string") {
       newOpts = Object.assign({}, this._defaultOpts, {
         importedSource
       }, opts);
     } else {
       _assert(!opts, "Unexpected secondary arguments.");
+
       newOpts = Object.assign({}, this._defaultOpts, importedSource);
     }
+
     if (!isInit && opts) {
       if (opts.nameHint !== undefined) newOpts.nameHint = opts.nameHint;
       if (opts.blockHoist !== undefined) newOpts.blockHoist = opts.blockHoist;
     }
+
     return newOpts;
   }
+
   _generateImport(opts, importName) {
     const isDefault = importName === "default";
     const isNamed = !!importName && !isDefault;
@@ -15758,15 +15816,20 @@ class ImportInjector {
     const isMod = (0, _isModule.default)(this._programPath);
     const isModuleForNode = isMod && importingInterop === "node";
     const isModuleForBabel = isMod && importingInterop === "babel";
+
     if (importPosition === "after" && !isMod) {
       throw new Error(`"importPosition": "after" is only supported in modules`);
     }
+
     const builder = new _importBuilder.default(importedSource, this._programScope, this._hub);
+
     if (importedType === "es6") {
       if (!isModuleForNode && !isModuleForBabel) {
         throw new Error("Cannot import an ES6 module from CommonJS");
       }
+
       builder.import();
+
       if (isNamespace) {
         builder.namespace(nameHint || importedSource);
       } else if (isDefault || isNamed) {
@@ -15779,6 +15842,7 @@ class ImportInjector {
         name = name !== "default" ? name : importedSource;
         const es6Default = `${importedSource}$es6Default`;
         builder.import();
+
         if (isNamespace) {
           builder.default(es6Default).var(name || importedSource).wildcardInterop();
         } else if (isDefault) {
@@ -15792,6 +15856,7 @@ class ImportInjector {
         }
       } else if (isModuleForBabel) {
         builder.import();
+
         if (isNamespace) {
           builder.namespace(name || importedSource);
         } else if (isDefault || isNamed) {
@@ -15799,6 +15864,7 @@ class ImportInjector {
         }
       } else {
         builder.require();
+
         if (isNamespace) {
           builder.var(name || importedSource).wildcardInterop();
         } else if ((isDefault || isNamed) && ensureLiveReference) {
@@ -15818,6 +15884,7 @@ class ImportInjector {
     } else if (importedInterop === "compiled") {
       if (isModuleForNode) {
         builder.import();
+
         if (isNamespace) {
           builder.default(name || importedSource);
         } else if (isDefault || isNamed) {
@@ -15825,6 +15892,7 @@ class ImportInjector {
         }
       } else if (isModuleForBabel) {
         builder.import();
+
         if (isNamespace) {
           builder.namespace(name || importedSource);
         } else if (isDefault || isNamed) {
@@ -15832,6 +15900,7 @@ class ImportInjector {
         }
       } else {
         builder.require();
+
         if (isNamespace) {
           builder.var(name || importedSource);
         } else if (isDefault || isNamed) {
@@ -15846,8 +15915,10 @@ class ImportInjector {
       if (isDefault && ensureLiveReference) {
         throw new Error("No live reference for commonjs default");
       }
+
       if (isModuleForNode) {
         builder.import();
+
         if (isNamespace) {
           builder.default(name || importedSource);
         } else if (isDefault) {
@@ -15857,6 +15928,7 @@ class ImportInjector {
         }
       } else if (isModuleForBabel) {
         builder.import();
+
         if (isNamespace) {
           builder.default(name || importedSource);
         } else if (isDefault) {
@@ -15866,6 +15938,7 @@ class ImportInjector {
         }
       } else {
         builder.require();
+
         if (isNamespace) {
           builder.var(name || importedSource);
         } else if (isDefault) {
@@ -15881,18 +15954,24 @@ class ImportInjector {
     } else {
       throw new Error(`Unknown importedInterop "${importedInterop}".`);
     }
+
     const {
       statements,
       resultName
     } = builder.done();
+
     this._insertStatements(statements, importPosition, blockHoist);
+
     if ((isDefault || isNamed) && ensureNoContext && resultName.type !== "Identifier") {
       return sequenceExpression([numericLiteral(0), resultName]);
     }
+
     return resultName;
   }
+
   _insertStatements(statements, importPosition = "before", blockHoist = 3) {
     const body = this._programPath.get("body");
+
     if (importPosition === "after") {
       for (let i = body.length - 1; i >= 0; i--) {
         if (body[i].isImportDeclaration()) {
@@ -15908,22 +15987,23 @@ class ImportInjector {
         const val = p.node._blockHoist;
         return Number.isFinite(val) && val < 4;
       });
+
       if (targetPath) {
         targetPath.insertBefore(statements);
         return;
       }
     }
+
     this._programPath.unshiftContainer("body", statements);
   }
-}
-exports.default = ImportInjector;
 
-//# sourceMappingURL=import-injector.js.map
+}
 
+exports.default = ImportInjector;
 
 /***/ }),
 
-/***/ 10742:
+/***/ 96150:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -15948,27 +16028,30 @@ Object.defineProperty(exports, "isModule", ({
     return _isModule.default;
   }
 }));
-var _importInjector = __webpack_require__(37615);
-var _isModule = __webpack_require__(59462);
+
+var _importInjector = __webpack_require__(27340);
+
+var _isModule = __webpack_require__(77901);
+
 function addDefault(path, importedSource, opts) {
   return new _importInjector.default(path).addDefault(importedSource, opts);
 }
+
 function addNamed(path, name, importedSource, opts) {
   return new _importInjector.default(path).addNamed(name, importedSource, opts);
 }
+
 function addNamespace(path, importedSource, opts) {
   return new _importInjector.default(path).addNamespace(importedSource, opts);
 }
+
 function addSideEffect(path, importedSource, opts) {
   return new _importInjector.default(path).addSideEffect(importedSource, opts);
 }
 
-//# sourceMappingURL=index.js.map
-
-
 /***/ }),
 
-/***/ 59462:
+/***/ 77901:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -15978,12 +16061,18 @@ Object.defineProperty(exports, "__esModule", ({
   value: true
 }));
 exports.default = isModule;
+
 function isModule(path) {
-  return path.node.sourceType === "module";
-}
+  const {
+    sourceType
+  } = path.node;
 
-//# sourceMappingURL=is-module.js.map
+  if (sourceType !== "module" && sourceType !== "script") {
+    throw path.buildCodeFrameError(`Unknown sourceType "${sourceType}", cannot transform.`);
+  }
 
+  return path.node.sourceType === "module";
+}
 
 /***/ }),
 
@@ -16163,7 +16252,7 @@ exports.wrapInterop = wrapInterop;
 var _assert = __webpack_require__(42357);
 var _t = __webpack_require__(32338);
 var _template = __webpack_require__(82272);
-var _helperModuleImports = __webpack_require__(10742);
+var _helperModuleImports = __webpack_require__(96150);
 var _rewriteThis = __webpack_require__(52831);
 var _rewriteLiveReferences = __webpack_require__(72337);
 var _normalizeAndLoadMetadata = __webpack_require__(34376);
@@ -139947,7 +140036,10 @@ const child_process_1 = __webpack_require__(63129);
 const url_1 = __webpack_require__(78835);
 const path_1 = __webpack_require__(85622);
 function forkDevServer(options) {
-    let nodeOptions = process.env.NODE_OPTIONS;
+    let nodeOptions = process.env.NODE_OPTIONS || '';
+    if (!nodeOptions.includes('--no-warnings')) {
+        nodeOptions += ' --no-warnings';
+    }
     const tsNodePath = options.require_.resolve('ts-node');
     const esmLoader = (0, url_1.pathToFileURL)((0, path_1.join)(tsNodePath, '..', '..', 'esm.mjs'));
     const cjsLoader = (0, path_1.join)(tsNodePath, '..', '..', 'register', 'index.js');
@@ -140053,7 +140145,6 @@ const static_config_1 = __webpack_require__(27167);
 const typescript_1 = __webpack_require__(39677);
 const utils_1 = __webpack_require__(76136);
 const fork_dev_server_1 = __webpack_require__(31158);
-const ALLOWED_RUNTIMES = ['nodejs', ...Object.values(utils_1.EdgeRuntimes)];
 const require_ = eval('require');
 const tscPath = (0, path_1.resolve)((0, path_1.dirname)(require_.resolve('typescript')), '../bin/tsc');
 // eslint-disable-next-line no-useless-escape
@@ -140076,7 +140167,7 @@ function renameTStoJS(path) {
     }
     return path;
 }
-async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, isEdgeFunction) {
+async function compile(workPath, baseDir, entrypointPath, config, meta, nodeVersion, isEdgeFunction) {
     const inputFiles = new Set([entrypointPath]);
     const preparedFiles = {};
     const sourceCache = new Map();
@@ -140224,7 +140315,8 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
         !file.endsWith('.tsx') &&
         !file.endsWith('.mjs') &&
         !file.match(libPathRegEx));
-    if (esmPaths.length) {
+    const babelCompileEnabled = !isEdgeFunction || process.env.VERCEL_EDGE_NO_BABEL !== '1';
+    if (babelCompileEnabled && esmPaths.length) {
         const babelCompile = __webpack_require__(20007)/* .compile */ .M;
         for (const path of esmPaths) {
             const pathDir = (0, path_1.join)(workPath, (0, path_1.dirname)(path));
@@ -140248,6 +140340,11 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
             const { data: source } = await build_utils_1.FileBlob.fromStream({
                 stream: preparedFiles[path].toStream(),
             });
+            if (!meta.compiledToCommonJS) {
+                meta.compiledToCommonJS = true;
+                console.warn('Warning: Node.js functions are compiled from ESM to CommonJS. If this is not intended, add "type": "module" to your package.json file.');
+            }
+            console.log(`Compiling "${filename}" from ESM to CommonJS...`);
             const { code, map } = babelCompile(filename, source);
             shouldAddSourcemapSupport = true;
             preparedFiles[path] = new build_utils_1.FileBlob({
@@ -140297,18 +140394,14 @@ const build = async ({ files, entrypoint, workPath, repoRootPath, config = {}, m
     let isEdgeFunction = isMiddleware;
     const project = new ts_morph_1.Project();
     const staticConfig = (0, static_config_1.getConfig)(project, entrypointPath);
-    if (staticConfig?.runtime) {
-        if (!ALLOWED_RUNTIMES.includes(staticConfig.runtime)) {
-            throw new Error(`Unsupported "runtime" property in \`config\`: ${JSON.stringify(staticConfig.runtime)} (must be one of: ${JSON.stringify(ALLOWED_RUNTIMES)})`);
-        }
-        if (staticConfig.runtime === 'nodejs') {
-            console.log(`Detected unused static config runtime "nodejs" in "${entrypointPath}"`);
-        }
-        isEdgeFunction = (0, utils_1.isEdgeRuntime)(staticConfig.runtime);
+    const runtime = staticConfig?.runtime;
+    (0, utils_1.validateConfiguredRuntime)(runtime, entrypoint);
+    if (runtime) {
+        isEdgeFunction = (0, utils_1.isEdgeRuntime)(runtime);
     }
     (0, build_utils_1.debug)('Tracing input files...');
     const traceTime = Date.now();
-    const { preparedFiles, shouldAddSourcemapSupport } = await compile(workPath, baseDir, entrypointPath, config, nodeVersion, isEdgeFunction);
+    const { preparedFiles, shouldAddSourcemapSupport } = await compile(workPath, baseDir, entrypointPath, config, meta, nodeVersion, isEdgeFunction);
     (0, build_utils_1.debug)(`Trace complete [${Date.now() - traceTime}ms]`);
     let routes;
     let output;
@@ -140938,7 +141031,7 @@ function filterDiagnostics(diagnostics, ignore) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.serializeBody = exports.isEdgeRuntime = exports.EdgeRuntimes = exports.logError = exports.entrypointToOutputPath = exports.getRegExpFromMatchers = void 0;
+exports.serializeBody = exports.validateConfiguredRuntime = exports.isEdgeRuntime = exports.EdgeRuntimes = exports.logError = exports.entrypointToOutputPath = exports.getRegExpFromMatchers = void 0;
 const build_utils_1 = __webpack_require__(63445);
 const path_to_regexp_1 = __webpack_require__(91344);
 const path_1 = __webpack_require__(85622);
@@ -141004,6 +141097,18 @@ function isEdgeRuntime(runtime) {
         Object.values(EdgeRuntimes).includes(runtime));
 }
 exports.isEdgeRuntime = isEdgeRuntime;
+const ALLOWED_RUNTIMES = Object.values(EdgeRuntimes);
+function validateConfiguredRuntime(runtime, entrypoint) {
+    if (runtime) {
+        if (runtime === 'nodejs') {
+            throw new Error(`${entrypoint}: \`config.runtime: "nodejs"\` semantics will evolve soon. Please remove the \`runtime\` key to keep the existing behavior.`);
+        }
+        if (!ALLOWED_RUNTIMES.includes(runtime)) {
+            throw new Error(`${entrypoint}: unsupported "runtime" value in \`config\`: ${JSON.stringify(runtime)} (must be one of: ${JSON.stringify(ALLOWED_RUNTIMES)}). Learn more: https://vercel.link/creating-edge-functions`);
+        }
+    }
+}
+exports.validateConfiguredRuntime = validateConfiguredRuntime;
 async function serializeBody(request) {
     return request.method !== 'GET' && request.method !== 'HEAD'
         ? await (0, build_utils_1.streamToBuffer)(request)

package/dist/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeBody = exports.isEdgeRuntime = exports.EdgeRuntimes = exports.logError = exports.entrypointToOutputPath = exports.getRegExpFromMatchers = void 0;
+exports.serializeBody = exports.validateConfiguredRuntime = exports.isEdgeRuntime = exports.EdgeRuntimes = exports.logError = exports.entrypointToOutputPath = exports.getRegExpFromMatchers = void 0;
 const build_utils_1 = require("@vercel/build-utils");
 const path_to_regexp_1 = require("path-to-regexp");
 const path_1 = require("path");
@@ -66,6 +66,18 @@ function isEdgeRuntime(runtime) {
         Object.values(EdgeRuntimes).includes(runtime));
 }
 exports.isEdgeRuntime = isEdgeRuntime;
+const ALLOWED_RUNTIMES = Object.values(EdgeRuntimes);
+function validateConfiguredRuntime(runtime, entrypoint) {
+    if (runtime) {
+        if (runtime === 'nodejs') {
+            throw new Error(`${entrypoint}: \`config.runtime: "nodejs"\` semantics will evolve soon. Please remove the \`runtime\` key to keep the existing behavior.`);
+        }
+        if (!ALLOWED_RUNTIMES.includes(runtime)) {
+            throw new Error(`${entrypoint}: unsupported "runtime" value in \`config\`: ${JSON.stringify(runtime)} (must be one of: ${JSON.stringify(ALLOWED_RUNTIMES)}). Learn more: https://vercel.link/creating-edge-functions`);
+        }
+    }
+}
+exports.validateConfiguredRuntime = validateConfiguredRuntime;
 async function serializeBody(request) {
     return request.method !== 'GET' && request.method !== 'HEAD'
         ? await (0, build_utils_1.streamToBuffer)(request)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "2.13.0",
+  "version": "2.14.0",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -33,7 +33,9 @@
     "path-to-regexp": "6.2.1",
     "ts-morph": "12.0.0",
     "ts-node": "10.9.1",
-    "typescript": "4.9.5"
+    "typescript": "4.9.5",
+    "undici": "5.22.0",
+    "ws": "8.13.0"
   },
   "devDependencies": {
     "@babel/core": "7.5.0",
@@ -56,5 +58,5 @@
     "source-map-support": "0.5.12",
     "test-listen": "1.1.0"
   },
-  "gitHead": "2de365f9cfea3ce283d2bf855507c71209f1e3d8"
+  "gitHead": "b5db13c97035d0eae04a5e075ae74e488d1298d6"
 }