@vercel/node 2.12.0 → 2.14.0

package/dist/index.js

@@ -140036,19 +140036,17 @@ 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 = 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) {
@@ -140062,9 +140060,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',
@@ -140074,7 +140071,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;
 }
@@ -140090,7 +140087,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 => {
@@ -140116,7 +140113,11 @@ exports.readMessage = readMessage;
 
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -140144,17 +140145,16 @@ 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 = path_1.resolve(path_1.dirname(require_.resolve('typescript')), '../bin/tsc');
+const tscPath = (0, path_1.resolve)((0, path_1.dirname)(require_.resolve('typescript')), '../bin/tsc');
 // eslint-disable-next-line no-useless-escape
 const libPathRegEx = /^node_modules|[\/\\]node_modules[\/\\]/;
 async function downloadInstallAndBundle({ files, entrypoint, workPath, config, meta, }) {
-    const downloadedFiles = await build_utils_1.download(files, workPath, meta);
-    const entrypointFsDirname = path_1.join(workPath, path_1.dirname(entrypoint));
-    const nodeVersion = await build_utils_1.getNodeVersion(entrypointFsDirname, undefined, config, meta);
-    const spawnOpts = build_utils_1.getSpawnOptions(meta, nodeVersion);
-    await build_utils_1.runNpmInstall(entrypointFsDirname, [], spawnOpts, meta, nodeVersion);
+    const downloadedFiles = await (0, build_utils_1.download)(files, workPath, meta);
+    const entrypointFsDirname = (0, path_1.join)(workPath, (0, path_1.dirname)(entrypoint));
+    const nodeVersion = await (0, build_utils_1.getNodeVersion)(entrypointFsDirname, undefined, config, meta);
+    const spawnOpts = (0, build_utils_1.getSpawnOptions)(meta, nodeVersion);
+    await (0, build_utils_1.runNpmInstall)(entrypointFsDirname, [], spawnOpts, meta, nodeVersion);
     const entrypointPath = downloadedFiles[entrypoint].fsPath;
     return { entrypointPath, entrypointFsDirname, nodeVersion, spawnOpts };
 }
@@ -140167,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();
@@ -140180,10 +140180,10 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
             ? [config.includeFiles]
             : config.includeFiles;
         for (const pattern of includeFiles) {
-            const files = await build_utils_1.glob(pattern, workPath);
+            const files = await (0, build_utils_1.glob)(pattern, workPath);
             await Promise.all(Object.values(files).map(async (entry) => {
                 const { fsPath } = entry;
-                const relPath = path_1.relative(baseDir, fsPath);
+                const relPath = (0, path_1.relative)(baseDir, fsPath);
                 fsCache.set(relPath, entry);
                 preparedFiles[relPath] = entry;
             }));
@@ -140191,9 +140191,9 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
     }
     let tsCompile;
     function compileTypeScript(path, source) {
-        const relPath = path_1.relative(baseDir, path);
+        const relPath = (0, path_1.relative)(baseDir, path);
         if (!tsCompile) {
-            tsCompile = typescript_1.register({
+            tsCompile = (0, typescript_1.register)({
                 basePath: workPath,
                 project: path,
                 files: true,
@@ -140212,7 +140212,7 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
     const conditions = isEdgeFunction
         ? ['edge-light', 'browser', 'module', 'import', 'require']
         : undefined;
-    const { fileList, esmFileList, warnings } = await nft_1.nodeFileTrace([...inputFiles], {
+    const { fileList, esmFileList, warnings } = await (0, nft_1.nodeFileTrace)([...inputFiles], {
         base: baseDir,
         processCwd: workPath,
         ts: true,
@@ -140220,29 +140220,29 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
         conditions,
         resolve(id, parent, job, cjsResolve) {
             const normalizedWasmImports = id.replace(/\.wasm\?module$/i, '.wasm');
-            return resolve_dependency_1.default(normalizedWasmImports, parent, job, cjsResolve);
+            return (0, resolve_dependency_1.default)(normalizedWasmImports, parent, job, cjsResolve);
         },
         ignore: config.excludeFiles,
         async readFile(fsPath) {
-            const relPath = path_1.relative(baseDir, fsPath);
+            const relPath = (0, path_1.relative)(baseDir, fsPath);
             // If this file has already been read then return from the cache
             const cached = sourceCache.get(relPath);
             if (typeof cached !== 'undefined')
                 return cached;
             try {
                 let entry;
-                let source = fs_1.readFileSync(fsPath);
-                const { mode } = fs_1.lstatSync(fsPath);
-                if (build_utils_1.isSymbolicLink(mode)) {
+                let source = (0, fs_1.readFileSync)(fsPath);
+                const { mode } = (0, fs_1.lstatSync)(fsPath);
+                if ((0, build_utils_1.isSymbolicLink)(mode)) {
                     entry = new build_utils_1.FileFsRef({ fsPath, mode });
                 }
-                if (isEdgeFunction && path_1.basename(fsPath) === 'package.json') {
+                if (isEdgeFunction && (0, path_1.basename)(fsPath) === 'package.json') {
                     // For Edge Functions, patch "main" field to prefer "browser" or "module"
                     const pkgJson = JSON.parse(source.toString());
                     for (const prop of ['browser', 'module']) {
                         const val = pkgJson[prop];
                         if (typeof val === 'string') {
-                            build_utils_1.debug(`Using "${prop}" field in ${fsPath}`);
+                            (0, build_utils_1.debug)(`Using "${prop}" field in ${fsPath}`);
                             pkgJson.main = val;
                             // Create the `entry` with the original so that the output is unmodified
                             if (!entry) {
@@ -140266,7 +140266,7 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
                 return source;
             }
             catch (error) {
-                if (error_utils_1.isErrnoException(error) &&
+                if ((0, error_utils_1.isErrnoException)(error) &&
                     (error.code === 'ENOENT' || error.code === 'EISDIR')) {
                     // `null` represents a not found
                     sourceCache.set(relPath, null);
@@ -140277,27 +140277,27 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
         },
     });
     for (const warning of warnings) {
-        build_utils_1.debug(`Warning from trace: ${warning.message}`);
+        (0, build_utils_1.debug)(`Warning from trace: ${warning.message}`);
     }
     for (const path of fileList) {
         let entry = fsCache.get(path);
         if (!entry) {
-            const fsPath = path_1.resolve(baseDir, path);
-            const { mode } = fs_1.lstatSync(fsPath);
-            if (build_utils_1.isSymbolicLink(mode)) {
+            const fsPath = (0, path_1.resolve)(baseDir, path);
+            const { mode } = (0, fs_1.lstatSync)(fsPath);
+            if ((0, build_utils_1.isSymbolicLink)(mode)) {
                 entry = new build_utils_1.FileFsRef({ fsPath, mode });
             }
             else {
-                const source = fs_1.readFileSync(fsPath);
+                const source = (0, fs_1.readFileSync)(fsPath);
                 entry = new build_utils_1.FileBlob({ data: source, mode });
             }
         }
-        if (build_utils_1.isSymbolicLink(entry.mode) && entry.type === 'FileFsRef') {
+        if ((0, build_utils_1.isSymbolicLink)(entry.mode) && entry.type === 'FileFsRef') {
             // ensure the symlink target is added to the file list
-            const symlinkTarget = path_1.relative(baseDir, path_1.resolve(path_1.dirname(entry.fsPath), fs_1.readlinkSync(entry.fsPath)));
+            const symlinkTarget = (0, path_1.relative)(baseDir, (0, path_1.resolve)((0, path_1.dirname)(entry.fsPath), (0, fs_1.readlinkSync)(entry.fsPath)));
             if (!symlinkTarget.startsWith('..' + path_1.sep) &&
                 !fileList.has(symlinkTarget)) {
-                const stats = fs_1.statSync(path_1.resolve(baseDir, symlinkTarget));
+                const stats = (0, fs_1.statSync)((0, path_1.resolve)(baseDir, symlinkTarget));
                 if (stats.isFile()) {
                     fileList.add(symlinkTarget);
                 }
@@ -140315,12 +140315,13 @@ 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 = path_1.join(workPath, path_1.dirname(path));
+            const pathDir = (0, path_1.join)(workPath, (0, path_1.dirname)(path));
             if (!pkgCache.has(pathDir)) {
-                const pathToPkg = await build_utils_1.walkParentDirs({
+                const pathToPkg = await (0, build_utils_1.walkParentDirs)({
                     base: workPath,
                     start: pathDir,
                     filename: 'package.json',
@@ -140335,10 +140336,15 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
                 // https://nodejs.org/api/packages.html#packages_type
                 continue;
             }
-            const filename = path_1.basename(path);
+            const filename = (0, path_1.basename)(path);
             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({
@@ -140360,7 +140366,7 @@ function getAWSLambdaHandler(entrypoint, config) {
         return config.awsLambdaHandler;
     }
     if (process.env.NODEJS_AWS_HANDLER_NAME) {
-        const { dir, name } = path_1.parse(entrypoint);
+        const { dir, name } = (0, path_1.parse)(entrypoint);
         return `${dir}${dir ? path_1.sep : ''}${name}.${process.env.NODEJS_AWS_HANDLER_NAME}`;
     }
     return '';
@@ -140378,7 +140384,7 @@ const build = async ({ files, entrypoint, workPath, repoRootPath, config = {}, m
         config,
         meta,
     });
-    await build_utils_1.runPackageJsonScript(entrypointFsDirname, 
+    await (0, build_utils_1.runPackageJsonScript)(entrypointFsDirname, 
     // Don't consider "build" script since its intended for frontend code
     ['vercel-build', 'now-build'], spawnOpts);
     const isMiddleware = config.middleware === true;
@@ -140387,24 +140393,20 @@ const build = async ({ files, entrypoint, workPath, repoRootPath, config = {}, m
     // `export const config = { runtime: 'edge' }`
     let isEdgeFunction = isMiddleware;
     const project = new ts_morph_1.Project();
-    const staticConfig = 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 = utils_1.isEdgeRuntime(staticConfig.runtime);
+    const staticConfig = (0, static_config_1.getConfig)(project, entrypointPath);
+    const runtime = staticConfig?.runtime;
+    (0, utils_1.validateConfiguredRuntime)(runtime, entrypoint);
+    if (runtime) {
+        isEdgeFunction = (0, utils_1.isEdgeRuntime)(runtime);
     }
-    build_utils_1.debug('Tracing input files...');
+    (0, build_utils_1.debug)('Tracing input files...');
     const traceTime = Date.now();
-    const { preparedFiles, shouldAddSourcemapSupport } = await compile(workPath, baseDir, entrypointPath, config, nodeVersion, isEdgeFunction);
-    build_utils_1.debug(`Trace complete [${Date.now() - traceTime}ms]`);
+    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;
-    const handler = renameTStoJS(path_1.relative(baseDir, entrypointPath));
-    const outputPath = utils_1.entrypointToOutputPath(entrypoint, config.zeroConfig);
+    const handler = renameTStoJS((0, path_1.relative)(baseDir, entrypointPath));
+    const outputPath = (0, utils_1.entrypointToOutputPath)(entrypoint, config.zeroConfig);
     // Add a `route` for Middleware
     if (isMiddleware) {
         if (!isEdgeFunction) {
@@ -140412,7 +140414,7 @@ const build = async ({ files, entrypoint, workPath, repoRootPath, config = {}, m
             throw new Error(`Middleware file can not be a Node.js Serverless Function`);
         }
         // Middleware is a catch-all for all paths unless a `matcher` property is defined
-        const src = utils_1.getRegExpFromMatchers(staticConfig?.matcher);
+        const src = (0, utils_1.getRegExpFromMatchers)(staticConfig?.matcher);
         const middlewareRawSrc = [];
         if (staticConfig?.matcher) {
             if (Array.isArray(staticConfig.matcher)) {
@@ -140463,19 +140465,19 @@ const build = async ({ files, entrypoint, workPath, repoRootPath, config = {}, m
 };
 exports.build = build;
 const prepareCache = ({ repoRootPath, workPath }) => {
-    return build_utils_1.glob('**/node_modules/**', repoRootPath || workPath);
+    return (0, build_utils_1.glob)('**/node_modules/**', repoRootPath || workPath);
 };
 exports.prepareCache = prepareCache;
 const startDevServer = async (opts) => {
     const { entrypoint, workPath, config, meta = {} } = opts;
-    const entrypointPath = path_1.join(workPath, entrypoint);
+    const entrypointPath = (0, path_1.join)(workPath, entrypoint);
     if (config.middleware === true && typeof meta.requestUrl === 'string') {
         // TODO: static config is also parsed in `dev-server.ts`.
         // we should pass in this version as an env var instead.
         const project = new ts_morph_1.Project();
-        const staticConfig = static_config_1.getConfig(project, entrypointPath);
+        const staticConfig = (0, static_config_1.getConfig)(project, entrypointPath);
         // Middleware is a catch-all for all paths unless a `matcher` property is defined
-        const matchers = new RegExp(utils_1.getRegExpFromMatchers(staticConfig?.matcher));
+        const matchers = new RegExp((0, utils_1.getRegExpFromMatchers)(staticConfig?.matcher));
         const parsed = url_1.default.parse(meta.requestUrl, true);
         if (typeof parsed.pathname !== 'string' ||
             !matchers.test(parsed.pathname)) {
@@ -140484,14 +140486,14 @@ const startDevServer = async (opts) => {
             return null;
         }
     }
-    const entryDir = path_1.dirname(entrypointPath);
-    const ext = path_1.extname(entrypoint);
-    const pathToTsConfig = await build_utils_1.walkParentDirs({
+    const entryDir = (0, path_1.dirname)(entrypointPath);
+    const ext = (0, path_1.extname)(entrypoint);
+    const pathToTsConfig = await (0, build_utils_1.walkParentDirs)({
         base: workPath,
         start: entryDir,
         filename: 'tsconfig.json',
     });
-    const pathToPkg = await build_utils_1.walkParentDirs({
+    const pathToPkg = await (0, build_utils_1.walkParentDirs)({
         base: workPath,
         start: entryDir,
         filename: 'package.json',
@@ -140523,7 +140525,7 @@ const startDevServer = async (opts) => {
         }
         // Otherwise fall back to using the copy that `@vercel/node` uses
         if (!ts) {
-            compiler = resolveTypescript(path_1.join(__dirname, '..'));
+            compiler = resolveTypescript((0, path_1.join)(__dirname, '..'));
             ts = requireTypescript(compiler);
         }
         if (pathToTsConfig) {
@@ -140531,14 +140533,27 @@ const startDevServer = async (opts) => {
                 tsConfig = ts.readConfigFile(pathToTsConfig, ts.sys.readFile).config;
             }
             catch (error) {
-                if (error_utils_1.isErrnoException(error) && error.code !== 'ENOENT') {
+                if ((0, error_utils_1.isErrnoException)(error) && error.code !== 'ENOENT') {
                     console.error(`Error while parsing "${pathToTsConfig}"`);
                     throw error;
                 }
             }
         }
+        // if we're using ESM, we need to tell TypeScript to use `nodenext` to
+        // preserve the `import` semantics
+        if (isEsm) {
+            if (!tsConfig.compilerOptions) {
+                tsConfig.compilerOptions = {};
+            }
+            if (tsConfig.compilerOptions.module === undefined) {
+                tsConfig.compilerOptions.module = 'nodenext';
+            }
+            if (tsConfig.compilerOptions.moduleResolution === undefined) {
+                tsConfig.compilerOptions.moduleResolution = 'nodenext';
+            }
+        }
         const nodeVersionMajor = Number(process.versions.node.split('.')[0]);
-        typescript_1.fixConfig(tsConfig, nodeVersionMajor);
+        (0, typescript_1.fixConfig)(tsConfig, nodeVersionMajor);
         // In prod, `.ts` inputs use TypeScript and
         // `.js` inputs use Babel to convert ESM to CJS.
         // In dev, both `.ts` and `.js` inputs use ts-node
@@ -140548,7 +140563,7 @@ const startDevServer = async (opts) => {
         // In dev, we don't emit because we use ts-node.
         tsConfig.compilerOptions.noEmit = true;
     }
-    const child = fork_dev_server_1.forkDevServer({
+    const child = (0, fork_dev_server_1.forkDevServer)({
         workPath,
         config,
         entrypoint,
@@ -140560,7 +140575,7 @@ const startDevServer = async (opts) => {
         tsConfig,
     });
     const { pid } = child;
-    const message = await fork_dev_server_1.readMessage(child);
+    const message = await (0, fork_dev_server_1.readMessage)(child);
     if (message.state === 'message') {
         // "message" event
         if (isTypeScript) {
@@ -140581,22 +140596,22 @@ const startDevServer = async (opts) => {
 };
 exports.startDevServer = startDevServer;
 async function doTypeCheck({ entrypoint, workPath, meta = {} }, projectTsConfig) {
-    const { devCacheDir = path_1.join(workPath, '.vercel', 'cache') } = meta;
-    const entrypointCacheDir = path_1.join(devCacheDir, 'node', entrypoint);
+    const { devCacheDir = (0, path_1.join)(workPath, '.vercel', 'cache') } = meta;
+    const entrypointCacheDir = (0, path_1.join)(devCacheDir, 'node', entrypoint);
     // In order to type-check a single file, a standalone tsconfig
     // file needs to be created that inherits from the base one :(
     // See: https://stackoverflow.com/a/44748041/376773
     //
     // A different filename needs to be used for different `extends` tsconfig.json
     const tsconfigName = projectTsConfig
-        ? `tsconfig-with-${path_1.relative(workPath, projectTsConfig).replace(/[\\/.]/g, '-')}.json`
+        ? `tsconfig-with-${(0, path_1.relative)(workPath, projectTsConfig).replace(/[\\/.]/g, '-')}.json`
         : 'tsconfig.json';
-    const tsconfigPath = path_1.join(entrypointCacheDir, tsconfigName);
+    const tsconfigPath = (0, path_1.join)(entrypointCacheDir, tsconfigName);
     const tsconfig = {
         extends: projectTsConfig
-            ? path_1.relative(entrypointCacheDir, projectTsConfig)
+            ? (0, path_1.relative)(entrypointCacheDir, projectTsConfig)
             : undefined,
-        include: [path_1.relative(entrypointCacheDir, path_1.join(workPath, entrypoint))],
+        include: [(0, path_1.relative)(entrypointCacheDir, (0, path_1.join)(workPath, entrypoint))],
     };
     try {
         const json = JSON.stringify(tsconfig, null, '\t');
@@ -140604,10 +140619,10 @@ async function doTypeCheck({ entrypoint, workPath, meta = {} }, projectTsConfig)
         await fs_1.promises.writeFile(tsconfigPath, json, { flag: 'wx' });
     }
     catch (error) {
-        if (error_utils_1.isErrnoException(error) && error.code !== 'EEXIST')
+        if ((0, error_utils_1.isErrnoException)(error) && error.code !== 'EEXIST')
             throw error;
     }
-    const child = child_process_1.spawn(process.execPath, [
+    const child = (0, child_process_1.spawn)(process.execPath, [
         tscPath,
         '--project',
         tsconfigPath,
@@ -140869,7 +140884,7 @@ function register(opts = {}) {
             const diagnosticList = filterDiagnostics(diagnostics, ignoreDiagnostics);
             reportTSError(diagnosticList, config.options.noEmitOnError);
             if (output.emitSkipped) {
-                throw new TypeError(`${path_1.relative(cwd, fileName)}: Emit skipped`);
+                throw new TypeError(`${(0, path_1.relative)(cwd, fileName)}: Emit skipped`);
             }
             // Throw an error when requiring `.d.ts` files.
             if (output.outputFiles.length === 0) {
@@ -140877,7 +140892,7 @@ function register(opts = {}) {
                     'This is usually the result of a faulty configuration or import. ' +
                     'Make sure there is a `.js`, `.json` or another executable extension and ' +
                     'loader (attached before `ts-node`) available alongside ' +
-                    `\`${path_1.basename(fileName)}\`.`);
+                    `\`${(0, path_1.basename)(fileName)}\`.`);
             }
             const file = {
                 code: output.outputFiles[1].text,
@@ -140905,7 +140920,7 @@ function register(opts = {}) {
      */
     function readConfig(configFileName) {
         let config = { compilerOptions: {} };
-        const basePath = normalizeSlashes(path_1.dirname(configFileName));
+        const basePath = normalizeSlashes((0, path_1.dirname)(configFileName));
         // Read project configuration when available.
         if (configFileName) {
             const result = ts.readConfigFile(configFileName, readFile);
@@ -140947,7 +140962,7 @@ function register(opts = {}) {
         const output = {
             code: value,
             map: Object.assign(JSON.parse(sourceMap), {
-                file: path_1.basename(fileName),
+                file: (0, path_1.basename)(fileName),
                 sources: [fileName],
             }),
         };
@@ -141016,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);
@@ -141038,9 +141053,9 @@ function getRegExpFromMatcher(matcher, index, allMatchers) {
     if (!matcher.startsWith('/')) {
         throw new Error(`Middleware's \`config.matcher\` values must start with "/". Received: ${matcher}`);
     }
-    const regExps = [path_to_regexp_1.pathToRegexp(matcher).source];
+    const regExps = [(0, path_to_regexp_1.pathToRegexp)(matcher).source];
     if (matcher === '/' && !allMatchers.includes('/index')) {
-        regExps.push(path_to_regexp_1.pathToRegexp('/index').source);
+        regExps.push((0, path_to_regexp_1.pathToRegexp)('/index').source);
     }
     return regExps;
 }
@@ -141055,7 +141070,7 @@ function getRegExpFromMatcher(matcher, index, allMatchers) {
  */
 function entrypointToOutputPath(entrypoint, zeroConfig) {
     if (zeroConfig) {
-        const ext = path_1.extname(entrypoint);
+        const ext = (0, path_1.extname)(entrypoint);
         return entrypoint.slice(0, entrypoint.length - ext.length);
     }
     return entrypoint;
@@ -141068,7 +141083,7 @@ function logError(error) {
         // because it points to internals, not user code
         const errorPrefixLength = 'Error: '.length;
         const errorMessageLength = errorPrefixLength + error.message.length;
-        build_utils_1.debug(error.stack.substring(errorMessageLength + 1));
+        (0, build_utils_1.debug)(error.stack.substring(errorMessageLength + 1));
     }
 }
 exports.logError = logError;
@@ -141082,9 +141097,21 @@ 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 build_utils_1.streamToBuffer(request)
+        ? await (0, build_utils_1.streamToBuffer)(request)
         : undefined;
 }
 exports.serializeBody = serializeBody;

package/dist/serverless-functions/helpers.js

@@ -201,7 +201,7 @@ function restoreBody(req, body) {
     replicateBody.end();
 }
 async function readBody(req) {
-    const body = (await utils_1.serializeBody(req)) || Buffer.from('');
+    const body = (await (0, utils_1.serializeBody)(req)) || Buffer.from('');
     restoreBody(req, body);
     return body;
 }

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

@@ -0,0 +1,65 @@
+import { addHelpers } from './helpers.js';
+import { createServer } from 'http';
+import { serializeBody } from '../utils.js';
+import { streamToBuffer } from '@vercel/build-utils';
+import exitHook from 'exit-hook';
+import fetch from 'node-fetch';
+import asyncListen from 'async-listen';
+import { isAbsolute } from 'path';
+import { pathToFileURL } from 'url';
+const { default: listen } = asyncListen;
+async function createServerlessServer(userCode, options) {
+    const server = createServer(async (req, res) => {
+        if (options.shouldAddHelpers)
+            await addHelpers(req, res);
+        return userCode(req, res);
+    });
+    exitHook(() => server.close());
+    return { url: await listen(server) };
+}
+async function compileUserCode(entrypointPath) {
+    const id = isAbsolute(entrypointPath)
+        ? pathToFileURL(entrypointPath).href
+        : entrypointPath;
+    let fn = await import(id);
+    /**
+     * In some cases we might have nested default props due to TS => JS
+     */
+    for (let i = 0; i < 5; i++) {
+        if (fn.default)
+            fn = fn.default;
+    }
+    return fn;
+}
+export async function createServerlessEventHandler(entrypointPath, options) {
+    const userCode = await compileUserCode(entrypointPath);
+    const server = await createServerlessServer(userCode, options);
+    return async function (request) {
+        const url = new URL(request.url ?? '/', server.url);
+        // @ts-expect-error
+        const response = await fetch(url, {
+            body: await serializeBody(request),
+            headers: {
+                ...request.headers,
+                host: request.headers['x-forwarded-host'],
+            },
+            method: request.method,
+            redirect: 'manual',
+        });
+        let body;
+        if (options.mode === 'streaming') {
+            body = response.body;
+        }
+        else {
+            body = await streamToBuffer(response.body);
+            response.headers.delete('transfer-encoding');
+            response.headers.set('content-length', body.length);
+        }
+        return {
+            status: response.status,
+            headers: response.headers,
+            body,
+            encoding: 'utf8',
+        };
+    };
+}