@vercel/node 5.7.0-canary.20260211174907.cdd2da6 → 5.7.0

package/dist/bundling-handler.js

@@ -0,0 +1,259 @@
+//
+// Unified Lambda handler for bundled vanilla API routes.
+// All bundleable lambdas share this exact file (same handler digest).
+// It reads x-matched-path to determine which entrypoint to invoke.
+//
+// IMPORTANT: This file must remain entrypoint-agnostic. Do not embed
+// any path-specific constants. The x-matched-path header is set by
+// route rules injected by the builder.
+//
+// This runs at Lambda runtime where the handler is invoked with (req, res).
+// User modules are in the Lambda's file tree alongside this file.
+//
+// Supports all handler shapes:
+//   1. Function export:  module.exports = (req, res) => { ... }
+//   2. Web handlers:     export function GET(request) { ... }
+//   3. Fetch handler:    export function fetch(request) { ... }
+//   4. Server handler:   http.createServer(...).listen()
+//
+
+const http = require('http');
+const { existsSync } = require('fs');
+const { resolve } = require('path');
+const { pathToFileURL } = require('url');
+const { Readable } = require('stream');
+
+const HTTP_METHODS = [
+  'GET',
+  'HEAD',
+  'OPTIONS',
+  'POST',
+  'PUT',
+  'DELETE',
+  'PATCH',
+];
+
+const handlerCache = Object.create(null);
+
+/**
+ * Resolve an extensionless entrypoint to an actual file path.
+ * Tries common JS extensions in order, returning the first match.
+ */
+function resolveEntrypoint(name) {
+  const base = resolve('./' + name);
+  for (const ext of ['.js', '.cjs', '.mjs']) {
+    const p = base + ext;
+    if (existsSync(p)) return p;
+  }
+  // If base is a directory, look for index files inside it
+  if (existsSync(base)) {
+    for (const ext of ['.js', '.cjs', '.mjs']) {
+      const p = resolve(base, 'index' + ext);
+      if (existsSync(p)) return p;
+    }
+  }
+  return null;
+}
+
+/**
+ * Load a module via dynamic import(). Works for both CJS and ESM regardless
+ * of the file extension or the package.json "type" field.
+ */
+async function loadModule(filePath) {
+  return import(pathToFileURL(filePath).href);
+}
+
+/**
+ * Unwrap nested default exports (common with TS/ESM compiled to CJS).
+ */
+function unwrapDefaults(mod) {
+  for (let i = 0; i < 5; i++) {
+    if (mod && mod.default) mod = mod.default;
+    else break;
+  }
+  return mod;
+}
+
+/**
+ * Create a Node.js (req, res) handler from web handler exports (GET, POST, fetch, etc.).
+ * Uses Node.js 18+ built-in Web API globals (Request, Response).
+ */
+function createWebHandler(listener) {
+  const methods = Object.create(null);
+
+  // If fetch is exported, it handles all methods
+  if (typeof listener.fetch === 'function') {
+    for (const m of HTTP_METHODS) {
+      methods[m] = listener.fetch;
+    }
+  }
+
+  // Named method exports override fetch
+  for (const m of HTTP_METHODS) {
+    if (typeof listener[m] === 'function') {
+      methods[m] = listener[m];
+    }
+  }
+
+  return async (req, res) => {
+    const method = req.method || 'GET';
+    const fn = methods[method];
+    if (!fn) {
+      res.statusCode = 405;
+      res.end('Method Not Allowed');
+      return;
+    }
+
+    // Build a Web API Request from the Node.js IncomingMessage
+    const proto = req.headers['x-forwarded-proto'] || 'https';
+    const host =
+      req.headers['x-forwarded-host'] || req.headers.host || 'localhost';
+    const url = new URL(req.url || '/', `${proto}://${host}`);
+
+    const init = { method, headers: req.headers, duplex: 'half' };
+    if (method !== 'GET' && method !== 'HEAD') {
+      init.body = Readable.toWeb(req);
+    }
+
+    const request = new Request(url, init);
+    let response;
+    try {
+      response = await fn(request);
+    } catch {
+      res.statusCode = 500;
+      res.end('Internal Server Error');
+      return;
+    }
+
+    // Write the Web API Response back to the Node.js ServerResponse
+    res.statusCode = response.status;
+    for (const [key, value] of response.headers) {
+      res.appendHeader(key, value);
+    }
+
+    if (response.body) {
+      for await (const chunk of response.body) {
+        res.write(chunk);
+      }
+    }
+    res.end();
+  };
+}
+
+/**
+ * Compile a user module and return a (req, res) handler regardless of
+ * export shape. Mirrors the detection logic in serverless-handler.mts.
+ */
+async function compileUserCode(filePath) {
+  let server = null;
+  let serverFound;
+
+  // Monkey-patch http.Server.prototype.listen to capture server instances
+  // created during module import (e.g. Express apps calling app.listen()).
+  const originalListen = http.Server.prototype.listen;
+  http.Server.prototype.listen = function () {
+    server = this;
+    http.Server.prototype.listen = originalListen;
+    if (serverFound) serverFound();
+    return this;
+  };
+
+  try {
+    let listener = await loadModule(filePath);
+    listener = unwrapDefaults(listener);
+
+    // 1. Web handlers (GET, POST, fetch, etc.)
+    const isWebHandler =
+      HTTP_METHODS.some(m => typeof listener[m] === 'function') ||
+      typeof listener.fetch === 'function';
+
+    if (isWebHandler) {
+      return createWebHandler(listener);
+    }
+
+    // 2. Function handler: (req, res) => { ... }
+    if (typeof listener === 'function') {
+      return listener;
+    }
+
+    // 3. Server handler: http.createServer(...).listen()
+    //    Wait briefly for async server creation if not captured yet.
+    if (!server) {
+      await new Promise(r => {
+        serverFound = r;
+        setTimeout(r, 1000);
+      });
+    }
+
+    if (server) {
+      // Start the captured server on a random port and proxy requests to it.
+      await new Promise(r => server.listen(0, '127.0.0.1', r));
+      const { port } = server.address();
+
+      return (req, res) => {
+        const proxyReq = http.request(
+          {
+            hostname: '127.0.0.1',
+            port,
+            path: req.url,
+            method: req.method,
+            headers: {
+              ...req.headers,
+              host: req.headers['x-forwarded-host'] || req.headers.host,
+            },
+          },
+          proxyRes => {
+            res.writeHead(proxyRes.statusCode, proxyRes.headers);
+            proxyRes.pipe(res);
+          }
+        );
+        proxyReq.on('error', err => {
+          res.statusCode = 502;
+          res.end('Proxy error: ' + err.message);
+        });
+        req.pipe(proxyReq);
+      };
+    }
+
+    throw new Error(
+      "Can't detect handler export shape for " +
+        filePath +
+        '. Expected a function export, HTTP method exports (GET, POST, ...), or an http.Server.'
+    );
+  } finally {
+    http.Server.prototype.listen = originalListen;
+  }
+}
+
+module.exports = async (req, res) => {
+  const matchedPath = req.headers['x-matched-path'];
+  if (typeof matchedPath !== 'string' || !matchedPath) {
+    res.statusCode = 500;
+    res.end(
+      'Missing x-matched-path header. The bundled handler requires route-level header injection.'
+    );
+    return;
+  }
+
+  // Convert matched path to entrypoint name.
+  // x-matched-path "/" maps to "index", "/api/hello" maps to "api/hello".
+  const entrypoint = matchedPath.replace(/^\//, '') || 'index';
+
+  if (!handlerCache[entrypoint]) {
+    const filePath = resolveEntrypoint(entrypoint);
+    if (!filePath) {
+      res.statusCode = 404;
+      res.end('No handler found for ' + entrypoint);
+      return;
+    }
+    // Store the Promise immediately so concurrent requests to the same
+    // entrypoint share one compileUserCode() call instead of racing.
+    handlerCache[entrypoint] = compileUserCode(filePath).catch(err => {
+      delete handlerCache[entrypoint]; // Allow retry on next request
+      throw err;
+    });
+  }
+
+  const handler = await handlerCache[entrypoint];
+  return handler(req, res);
+};

package/dist/dev-server.mjs

@@ -662,16 +662,13 @@ var Awaiter = class {
       () => this.promises.size > 0 ? this.waitForBatch() : Promise.resolve()
     );
     this.waitUntil = (promise) => {
-      this.promises.add(promise);
+      const handledPromise = Promise.resolve(promise).catch(this.onError);
+      this.promises.add(handledPromise);
     };
     this.waitForBatch = async () => {
       const promises = Array.from(this.promises);
       this.promises.clear();
-      await Promise.all(
-        promises.map(
-          (promise) => Promise.resolve(promise).then(() => void 0, this.onError)
-        )
-      );
+      await Promise.all(promises);
     };
     this.onError = onError ?? console.error;
   }
@@ -907,7 +904,7 @@ function getBodyParser(body, contentType) {
       try {
         const str = body.toString();
         return str ? JSON.parse(str) : {};
-      } catch (error) {
+      } catch (_error) {
         throw new ApiError(400, "Invalid JSON");
       }
     }
@@ -1251,10 +1248,13 @@ async function createEventHandler(entrypoint2, config, options) {
   const staticConfig = parseConfig(entrypointPath);
   const runtime = staticConfig?.runtime;
   validateConfiguredRuntime(runtime, entrypoint2);
-  const { maxDuration } = await getLambdaOptionsFromFunction({
-    sourceFile: entrypoint2,
-    config
-  });
+  const { maxDuration: configMaxDuration } = await getLambdaOptionsFromFunction(
+    {
+      sourceFile: entrypoint2,
+      config
+    }
+  );
+  const maxDuration = typeof configMaxDuration === "number" ? configMaxDuration : void 0;
   const isMiddleware = config.middleware === true;
   const useEdgeRuntime = isMiddleware && !runtime || isEdgeRuntime(runtime);
   if (useEdgeRuntime) {

package/dist/edge-handler-template.js

@@ -61,7 +61,6 @@ async function parseRequestEvent(event) {
 }
 
 // This will be invoked by logic using this template
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function registerFetchListener(module, options, dependencies) {
   let handler;
 

package/dist/index.js

@@ -69961,6 +69961,7 @@ var require_dist = __commonJS({
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  _resetBundlingRoutesEmitted: () => _resetBundlingRoutesEmitted,
   build: () => build,
   prepareCache: () => prepareCache,
   shouldServe: () => import_build_utils8.shouldServe,
@@ -70050,7 +70051,7 @@ function register(opts = {}) {
     compiler = require_.resolve(options.compiler || "typescript", {
       paths: [options.project || cwd]
     });
-  } catch (e) {
+  } catch (_e) {
     compiler = "typescript";
   }
   const ts = require_(compiler);
@@ -70417,7 +70418,7 @@ function validateConfiguredRuntime(runtime, entrypoint) {
 
 // src/build.ts
 var require_2 = (0, import_module2.createRequire)(__filename);
-var libPathRegEx = /^node_modules|[\/\\]node_modules[\/\\]/;
+var libPathRegEx = /^node_modules|[/\\]node_modules[/\\]/;
 async function downloadInstallAndBundle({
   files,
   entrypoint,
@@ -70689,6 +70690,10 @@ function getAWSLambdaHandler(entrypoint, config) {
   }
   return "";
 }
+var bundlingRoutesEmitted = false;
+function _resetBundlingRoutesEmitted() {
+  bundlingRoutesEmitted = false;
+}
 var build = async ({
   files,
   entrypoint,
@@ -70836,9 +70841,50 @@ var build = async ({
   } else {
     const shouldAddHelpers = !(config.helpers === false || process.env.NODEJS_HELPERS === "0");
     const supportsResponseStreaming = (staticConfig?.supportsResponseStreaming ?? staticConfig?.experimentalResponseStreaming) === true ? true : void 0;
+    const enableBundling = process.env.VERCEL_API_FUNCTION_BUNDLING === "1" && config.zeroConfig === true && !isMiddleware && !isEdgeFunction;
+    if (enableBundling) {
+      const bundledHandlerName = "___vc_bundled_api_handler.js";
+      preparedFiles[bundledHandlerName] = new import_build_utils3.FileFsRef({
+        fsPath: (0, import_path3.join)((0, import_path3.dirname)(__filename), "bundling-handler.js")
+      });
+      handler = bundledHandlerName;
+      if (!bundlingRoutesEmitted) {
+        bundlingRoutesEmitted = true;
+        routes = [
+          { handle: "hit" },
+          {
+            src: "/index(?:/)?",
+            transforms: [
+              {
+                type: "request.headers",
+                op: "set",
+                target: { key: "x-matched-path" },
+                args: "/"
+              }
+            ],
+            continue: true,
+            important: true
+          },
+          {
+            src: "/((?!index$).*?)(?:/)?",
+            transforms: [
+              {
+                type: "request.headers",
+                op: "set",
+                target: { key: "x-matched-path" },
+                args: "/$1"
+              }
+            ],
+            continue: true,
+            important: true
+          }
+        ];
+      }
+    }
     output = new import_build_utils3.NodejsLambda({
       files: preparedFiles,
       handler,
+      experimentalAllowBundling: enableBundling || void 0,
       architecture: staticConfig?.architecture,
       runtime: nodeVersion.runtime,
       useWebApi: isMiddleware ? true : useWebApi,
@@ -70880,6 +70926,7 @@ var import_fs2 = require("fs");
 var import_path6 = require("path");
 var import_tree_kill = __toESM(require_tree_kill());
 var import_util = require("util");
+var import_stream = require("stream");
 var import_build_utils7 = require("@vercel/build-utils");
 var import_error_utils2 = require("@vercel/error-utils");
 var import_static_config2 = require("@vercel/static-config");
@@ -71059,9 +71106,70 @@ async function readMessage(child) {
 // src/start-dev-server.ts
 var require_3 = (0, import_module3.createRequire)(__filename);
 var treeKill = (0, import_util.promisify)(import_tree_kill.default);
+async function syncDependencies(workPath, onStdout, onStderr) {
+  const writeOut = (msg) => {
+    if (onStdout) {
+      onStdout(Buffer.from(msg));
+    } else {
+      process.stdout.write(msg);
+    }
+  };
+  const writeErr = (msg) => {
+    if (onStderr) {
+      onStderr(Buffer.from(msg));
+    } else {
+      process.stderr.write(msg);
+    }
+  };
+  const captured = [];
+  const bufStdout = new import_stream.Writable({
+    write(chunk, _enc, cb) {
+      captured.push([
+        "stdout",
+        Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+      ]);
+      cb();
+    }
+  });
+  const bufStderr = new import_stream.Writable({
+    write(chunk, _enc, cb) {
+      captured.push([
+        "stderr",
+        Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+      ]);
+      cb();
+    }
+  });
+  try {
+    await (0, import_build_utils7.runNpmInstall)(workPath, [], void 0, void 0, void 0, {
+      stdout: bufStdout,
+      stderr: bufStderr
+    });
+  } catch (err) {
+    for (const [channel, chunk] of captured) {
+      (channel === "stdout" ? writeOut : writeErr)(chunk.toString());
+    }
+    throw new import_build_utils7.NowBuildError({
+      code: "NODE_DEPENDENCY_SYNC_FAILED",
+      message: `Failed to install Node.JS dependencies: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+}
 var startDevServer = async (opts) => {
   const { entrypoint, workPath, config, meta = {}, publicDir } = opts;
   const entrypointPath = (0, import_path6.join)(workPath, entrypoint);
+  if (meta.syncDependencies) {
+    const gray = "\x1B[90m";
+    const reset = "\x1B[0m";
+    const syncMessage = `${gray}Synchronizing dependencies...${reset}
+`;
+    if (opts.onStdout) {
+      opts.onStdout(Buffer.from(syncMessage));
+    } else {
+      console.log(syncMessage);
+    }
+    await syncDependencies(workPath, opts.onStdout, opts.onStderr);
+  }
   const project = new import_ts_morph2.Project();
   const staticConfig = (0, import_static_config2.getConfig)(project, entrypointPath);
   const vercelConfigFile = opts.files["vercel.json"];
@@ -71180,7 +71288,7 @@ var startDevServer = async (opts) => {
       if (runtime === "bun") {
         try {
           process.kill(pid, "SIGTERM");
-        } catch (err) {
+        } catch (_err) {
           await treeKill(pid);
         }
       } else {
@@ -71208,6 +71316,7 @@ var import_build_utils8 = require("@vercel/build-utils");
 var version = 3;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  _resetBundlingRoutesEmitted,
   build,
   prepareCache,
   shouldServe,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "5.7.0-canary.20260211174907.cdd2da6",
+  "version": "5.7.0",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -17,7 +17,7 @@
     "@edge-runtime/primitives": "4.1.0",
     "@edge-runtime/vm": "3.2.0",
     "@types/node": "20.11.0",
-    "@vercel/nft": "1.1.1",
+    "@vercel/nft": "1.5.0",
     "async-listen": "3.0.0",
     "cjs-module-lexer": "1.2.3",
     "edge-runtime": "2.5.9",
@@ -32,9 +32,9 @@
     "tsx": "4.21.0",
     "typescript": "npm:typescript@5.9.3",
     "undici": "5.28.4",
-    "@vercel/error-utils": "2.1.0-canary.20260211174907.cdd2da6",
-    "@vercel/static-config": "3.2.0-canary.20260211174907.cdd2da6",
-    "@vercel/build-utils": "13.4.0-canary.20260211174907.cdd2da6"
+    "@vercel/error-utils": "2.0.3",
+    "@vercel/static-config": "3.2.0",
+    "@vercel/build-utils": "13.12.2"
   },
   "devDependencies": {
     "@babel/core": "7.24.4",
@@ -59,7 +59,7 @@
     "tree-kill": "1.2.2",
     "vite": "^5.1.6",
     "vitest": "^2.0.1",
-    "@vercel/functions": "3.5.0-canary.20260211174907.cdd2da6"
+    "@vercel/functions": "3.4.3"
   },
   "scripts": {
     "build": "node build.mjs",