@vercel/express 0.0.18 → 0.0.20

package/dist/index.js

@@ -6,8 +6,8 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -32,11 +32,14 @@ var src_exports = {};
 __export(src_exports, {
   build: () => build,
   entrypointCallback: () => entrypointCallback,
+  experimentalBuild: () => build2,
+  experimentalVersion: () => version,
   findEntrypoint: () => findEntrypoint,
+  name: () => name,
   require_: () => require_,
   shouldServe: () => shouldServe,
   startDevServer: () => startDevServer,
-  version: () => version
+  version: () => version2
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -80,20 +83,20 @@ var build = async (args) => {
       return entrypointCallback(args);
     }
   });
-  let version2 = void 0;
+  let version3 = void 0;
   try {
     const resolved = require_.resolve(`${frameworkName}/package.json`, {
       paths: [args.workPath]
     });
     const expressVersion = require_(resolved).version;
     if (expressVersion) {
-      version2 = expressVersion;
+      version3 = expressVersion;
     }
   } catch (e) {
   }
   res.output.framework = {
     slug: frameworkName,
-    version: version2
+    version: version3
   };
   return res;
 };
@@ -202,9 +205,633 @@ var findMainPackageEntrypoint = (files) => {
   return null;
 };
 
-// src/index.ts
+// src/experimental/build.ts
+var import_build_utils6 = require("@vercel/build-utils");
+
+// src/experimental/utils.ts
+var import_path2 = require("path");
+var import_build_utils2 = require("@vercel/build-utils");
+async function downloadInstallAndBundle(args) {
+  const { entrypoint, files, workPath, meta, config } = args;
+  await (0, import_build_utils2.download)(files, workPath, meta);
+  const entrypointFsDirname = (0, import_path2.join)(workPath, (0, import_path2.dirname)(entrypoint));
+  const nodeVersion = await (0, import_build_utils2.getNodeVersion)(
+    entrypointFsDirname,
+    void 0,
+    config,
+    meta
+  );
+  const spawnOpts = (0, import_build_utils2.getSpawnOptions)(meta || {}, nodeVersion);
+  const {
+    cliType,
+    lockfileVersion,
+    packageJsonPackageManager,
+    turboSupportsCorepackHome
+  } = await (0, import_build_utils2.scanParentDirs)(entrypointFsDirname, true);
+  spawnOpts.env = (0, import_build_utils2.getEnvForPackageManager)({
+    cliType,
+    lockfileVersion,
+    packageJsonPackageManager,
+    nodeVersion,
+    env: spawnOpts.env || {},
+    turboSupportsCorepackHome,
+    projectCreatedAt: config.projectSettings?.createdAt
+  });
+  const installCommand = config.projectSettings?.installCommand;
+  if (typeof installCommand === "string") {
+    if (installCommand.trim()) {
+      console.log(`Running "install" command: \`${installCommand}\`...`);
+      await (0, import_build_utils2.execCommand)(installCommand, {
+        ...spawnOpts,
+        cwd: entrypointFsDirname
+      });
+    } else {
+      console.log(`Skipping "install" command...`);
+    }
+  } else {
+    await (0, import_build_utils2.runNpmInstall)(
+      entrypointFsDirname,
+      [],
+      spawnOpts,
+      meta,
+      nodeVersion,
+      config.projectSettings?.createdAt
+    );
+  }
+  return { entrypointFsDirname, nodeVersion, spawnOpts };
+}
+async function maybeExecBuildCommand(args, options) {
+  const projectBuildCommand = args.config.projectSettings?.buildCommand;
+  if (projectBuildCommand) {
+    await (0, import_build_utils2.execCommand)(projectBuildCommand, {
+      ...options.spawnOpts,
+      cwd: args.workPath
+    });
+  } else {
+    const possibleScripts = ["build"];
+    await (0, import_build_utils2.runPackageJsonScript)(
+      options.entrypointFsDirname,
+      possibleScripts,
+      options.spawnOpts,
+      args.config.projectSettings?.createdAt
+    );
+  }
+}
+
+// src/experimental/rolldown.ts
+var import_build_utils3 = require("@vercel/build-utils");
+var import_nft = require("@vercel/nft");
+var import_fs2 = require("fs");
+var import_path3 = require("path");
+var import_rolldown = require("rolldown");
+var rolldown = async (args) => {
+  const baseDir = args.repoRootPath || args.workPath;
+  const entrypointPath = (0, import_path3.join)(args.workPath, args.entrypoint);
+  const files = {};
+  const shouldAddSourcemapSupport = false;
+  const extension = (0, import_path3.extname)(args.entrypoint);
+  const extensionMap = {
+    ".ts": { format: "auto", extension: "js" },
+    ".mts": { format: "esm", extension: "mjs" },
+    ".cts": { format: "cjs", extension: "cjs" },
+    ".cjs": { format: "cjs", extension: "cjs" },
+    ".js": { format: "auto", extension: "js" },
+    ".mjs": { format: "esm", extension: "mjs" }
+  };
+  const extensionInfo = extensionMap[extension] || extensionMap[".js"];
+  let format = extensionInfo.format;
+  const packageJsonPath = (0, import_path3.join)(args.workPath, "package.json");
+  const external = [];
+  if ((0, import_fs2.existsSync)(packageJsonPath)) {
+    const { mode } = (0, import_fs2.lstatSync)(packageJsonPath);
+    const source = (0, import_fs2.readFileSync)(packageJsonPath);
+    const relPath = (0, import_path3.relative)(baseDir, packageJsonPath);
+    let pkg;
+    try {
+      pkg = JSON.parse(source.toString());
+    } catch (_e) {
+      pkg = {};
+    }
+    if (format === "auto") {
+      if (pkg.type === "module") {
+        format = "esm";
+      } else {
+        format = "cjs";
+      }
+    }
+    for (const dependency of Object.keys(pkg.dependencies || {})) {
+      external.push(dependency);
+    }
+    for (const dependency of Object.keys(pkg.devDependencies || {})) {
+      external.push(dependency);
+    }
+    for (const dependency of Object.keys(pkg.peerDependencies || {})) {
+      external.push(dependency);
+    }
+    for (const dependency of Object.keys(pkg.optionalDependencies || {})) {
+      external.push(dependency);
+    }
+    files[relPath] = new import_build_utils3.FileBlob({ data: source, mode });
+  }
+  const absoluteImportPlugin = {
+    name: "absolute-import-resolver",
+    resolveId(source) {
+      if (external.includes(source)) {
+        return { id: source, external: true };
+      }
+      return null;
+    }
+  };
+  let tsconfigPath = (0, import_path3.join)(baseDir, "tsconfig.json");
+  if (!(0, import_fs2.existsSync)(tsconfigPath)) {
+    tsconfigPath = await (0, import_build_utils3.walkParentDirs)({
+      base: baseDir,
+      start: args.workPath,
+      filename: "tsconfig.json"
+    });
+  }
+  const relativeOutputDir = (0, import_path3.join)(
+    ".vercel",
+    "output",
+    "functions",
+    "index.func"
+  );
+  const outputDir = (0, import_path3.join)(baseDir, relativeOutputDir);
+  let handler = null;
+  await (0, import_rolldown.build)({
+    input: entrypointPath,
+    cwd: baseDir,
+    platform: "node",
+    external: /node_modules/,
+    plugins: [absoluteImportPlugin],
+    tsconfig: tsconfigPath || void 0,
+    output: {
+      dir: outputDir,
+      // FIXME: This is a bit messy, not sure what facadeModuleId even is and the only reason for renaming here
+      // is to preserve the proper extension for mjs/cjs scenario.
+      // There doesn't seem to be another way to do only specify the entrypoint extension.
+      entryFileNames: (info) => {
+        if (info.name === "rolldown_runtime") {
+          return "rolldown_runtime.js";
+        }
+        const facadeModuleId = info.facadeModuleId;
+        if (!facadeModuleId) {
+          throw new Error(`Unable to resolve module for ${info.name}`);
+        }
+        const relPath = (0, import_path3.relative)(baseDir, facadeModuleId);
+        const extension2 = (0, import_path3.extname)(relPath);
+        const extensionMap2 = {
+          ".ts": ".js",
+          ".mts": ".mjs",
+          ".mjs": ".mjs",
+          ".cts": ".cjs",
+          ".cjs": ".cjs",
+          ".js": ".js"
+        };
+        const ext = extensionMap2[extension2] || ".js";
+        const nameWithJS = relPath.slice(0, -extension2.length) + ext;
+        if (info.isEntry) {
+          handler = nameWithJS;
+        }
+        return nameWithJS;
+      },
+      format,
+      preserveModules: true,
+      sourcemap: false
+    }
+  });
+  if (typeof handler !== "string") {
+    throw new Error(`Unable to resolve module for ${args.entrypoint}`);
+  }
+  const nftResult = await (0, import_nft.nodeFileTrace)([(0, import_path3.join)(outputDir, handler)], {
+    // This didn't work as I expected it to, didn't find node_modules
+    // base: outputDir,
+    // processCwd: outputDir,
+    ignore: args.config.excludeFiles
+  });
+  for (const file of nftResult.fileList) {
+    if (file.startsWith(relativeOutputDir)) {
+      continue;
+    }
+    files[file] = new import_build_utils3.FileFsRef({ fsPath: file, mode: 420 });
+  }
+  return {
+    files,
+    shouldAddSourcemapSupport,
+    handler,
+    outputDir
+  };
+};
+
+// src/experimental/find-entrypoint.ts
+var import_build_utils4 = require("@vercel/build-utils");
 var import_node2 = require("@vercel/node");
-var version = 3;
+var import_module2 = require("module");
+var import_path4 = require("path");
+var import_fs3 = __toESM(require("fs"));
+var REGEX2 = /(?:from|require|import)\s*(?:\(\s*)?["']express["']\s*(?:\))?/g;
+var validFilenames2 = [
+  "app",
+  "index",
+  "server",
+  "src/app",
+  "src/index",
+  "src/server"
+];
+var require_2 = (0, import_module2.createRequire)(__filename);
+var validExtensions2 = ["js", "cjs", "mjs", "ts", "cts", "mts"];
+var entrypointsForMessage2 = validFilenames2.map((filename) => `- ${filename}.{${validExtensions2.join(",")}}`).join("\n");
+var entrypointCallback2 = async (args) => {
+  const mainPackageEntrypoint = findMainPackageEntrypoint2(args.files);
+  const entrypointGlob = `{${validFilenames2.map((entrypoint) => `${entrypoint}`).join(",")}}.{${validExtensions2.join(",")}}`;
+  const dir = args.config.projectSettings?.outputDirectory?.replace(
+    /^\/+|\/+$/g,
+    ""
+  );
+  if (dir) {
+    const { entrypoint: entrypointFromOutputDir, entrypointsNotMatchingRegex: entrypointsNotMatchingRegex2 } = findEntrypoint2(await (0, import_build_utils4.glob)(entrypointGlob, (0, import_path4.join)(args.workPath, dir)));
+    if (entrypointFromOutputDir) {
+      return (0, import_path4.join)(dir, entrypointFromOutputDir);
+    }
+    if (entrypointsNotMatchingRegex2.length > 0) {
+      throw new Error(
+        `No entrypoint found which imports express. Found possible ${pluralize2("entrypoint", entrypointsNotMatchingRegex2.length)}: ${entrypointsNotMatchingRegex2.join(", ")}`
+      );
+    }
+    throw new Error(
+      `No entrypoint found in output directory: "${dir}". Searched for: 
+${entrypointsForMessage2}`
+    );
+  }
+  const files = await (0, import_build_utils4.glob)(entrypointGlob, args.workPath);
+  const { entrypoint: entrypointFromRoot, entrypointsNotMatchingRegex } = findEntrypoint2(files);
+  if (entrypointFromRoot) {
+    return entrypointFromRoot;
+  }
+  if (mainPackageEntrypoint) {
+    const entrypointFromPackageJson = await (0, import_build_utils4.glob)(
+      mainPackageEntrypoint,
+      args.workPath
+    );
+    if (entrypointFromPackageJson[mainPackageEntrypoint]) {
+      if (checkMatchesRegex2(entrypointFromPackageJson[mainPackageEntrypoint])) {
+        return mainPackageEntrypoint;
+      }
+    }
+  }
+  if (entrypointsNotMatchingRegex.length > 0) {
+    throw new Error(
+      `No entrypoint found which imports express. Found possible ${pluralize2("entrypoint", entrypointsNotMatchingRegex.length)}: ${entrypointsNotMatchingRegex.join(", ")}`
+    );
+  }
+  throw new Error(
+    `No entrypoint found. Searched for:
+${entrypointsForMessage2}`
+  );
+};
+function pluralize2(word, count) {
+  return count === 1 ? word : `${word}s`;
+}
+var findEntrypoint2 = (files) => {
+  const allEntrypoints = validFilenames2.flatMap(
+    (filename) => validExtensions2.map((extension) => `${filename}.${extension}`)
+  );
+  const possibleEntrypointsInFiles = allEntrypoints.filter((entrypoint2) => {
+    return files[entrypoint2] !== void 0;
+  });
+  const entrypointsMatchingRegex = possibleEntrypointsInFiles.filter(
+    (entrypoint2) => {
+      const file = files[entrypoint2];
+      return checkMatchesRegex2(file);
+    }
+  );
+  const entrypointsNotMatchingRegex = possibleEntrypointsInFiles.filter(
+    (entrypoint2) => {
+      const file = files[entrypoint2];
+      return !checkMatchesRegex2(file);
+    }
+  );
+  const entrypoint = entrypointsMatchingRegex[0];
+  if (entrypointsMatchingRegex.length > 1) {
+    console.warn(
+      `Multiple entrypoints found: ${entrypointsMatchingRegex.join(", ")}. Using ${entrypoint}.`
+    );
+  }
+  return {
+    entrypoint,
+    entrypointsNotMatchingRegex
+  };
+};
+var checkMatchesRegex2 = (file) => {
+  const content = import_fs3.default.readFileSync(file.fsPath, "utf-8");
+  const matchesContent = content.match(REGEX2);
+  return matchesContent !== null;
+};
+var findMainPackageEntrypoint2 = (files) => {
+  const packageJson = files["package.json"];
+  if (packageJson) {
+    if (packageJson.type === "FileFsRef") {
+      const packageJsonContent = import_fs3.default.readFileSync(packageJson.fsPath, "utf-8");
+      let packageJsonJson;
+      try {
+        packageJsonJson = JSON.parse(packageJsonContent);
+      } catch (_e) {
+        packageJsonJson = {};
+      }
+      if ("main" in packageJsonJson && typeof packageJsonJson.main === "string") {
+        return packageJsonJson.main;
+      }
+    }
+  }
+  return null;
+};
+
+// src/experimental/introspection.ts
+var import_build_utils5 = require("@vercel/build-utils");
+var import_path5 = require("path");
+var import_fs_extra = require("fs-extra");
+var import_child_process = require("child_process");
+var import_fs4 = require("fs");
+var import_promises = require("fs/promises");
+var import_module3 = require("module");
+var import_path_to_regexp = require("path-to-regexp");
+var import_zod = require("zod");
+var require_3 = (0, import_module3.createRequire)(__filename);
+var introspectApp = async (args, options) => {
+  const source = expressShimSource(options);
+  await (0, import_fs_extra.outputFile)(
+    (0, import_path5.join)(options.outputDir, "node_modules", "express", "index.js"),
+    source
+  );
+  await invokeFunction(args, options);
+  const {
+    routes: routesFromIntrospection,
+    views,
+    staticPaths
+  } = await processIntrospection(options);
+  await cleanup(options);
+  if (views) {
+    try {
+      const validatedViews = validatePath(views, args.workPath);
+      const viewFiles = await (0, import_build_utils5.glob)((0, import_path5.join)(validatedViews, "**/*"), args.workPath);
+      for (const [p, f] of Object.entries(viewFiles)) {
+        options.files[p] = f;
+      }
+    } catch (error) {
+      console.log(`Skipping invalid views path: ${views}`);
+    }
+  }
+  if (staticPaths) {
+    try {
+      const validatedStaticPaths = staticPaths.map(
+        (path) => validatePath(path, args.workPath)
+      );
+      for (const staticPath of validatedStaticPaths) {
+        const staticFiles = await (0, import_build_utils5.glob)((0, import_path5.join)(staticPath, "**/*"), args.workPath);
+        for (const [p, f] of Object.entries(staticFiles)) {
+          options.files[p] = f;
+        }
+      }
+    } catch (error) {
+      console.log(`Skipping invalid static paths: ${staticPaths}`);
+    }
+  }
+  const routes = [
+    {
+      handle: "filesystem"
+    },
+    ...routesFromIntrospection,
+    {
+      src: "/(.*)",
+      dest: "/"
+    }
+  ];
+  return { routes };
+};
+var cleanup = async (options) => {
+  await (0, import_promises.rm)((0, import_path5.join)(options.outputDir, "node_modules"), {
+    recursive: true,
+    force: true
+  });
+  await (0, import_promises.rm)(getIntrospectionPath(options), { force: true });
+};
+var processIntrospection = async (options) => {
+  const schema = import_zod.z.object({
+    routes: import_zod.z.record(
+      import_zod.z.string(),
+      import_zod.z.object({
+        methods: import_zod.z.array(import_zod.z.string())
+      })
+    ).transform(
+      (value) => Object.entries(value).map(([path, route]) => convertExpressRoute(path, route)).filter(Boolean)
+    ),
+    views: import_zod.z.string().optional(),
+    staticPaths: import_zod.z.array(import_zod.z.string()).optional(),
+    viewEngine: import_zod.z.string().optional()
+  });
+  try {
+    const introspectionPath = (0, import_path5.join)(options.outputDir, "introspection.json");
+    const introspection = (0, import_fs4.readFileSync)(introspectionPath, "utf8");
+    return schema.parse(JSON.parse(introspection));
+  } catch (error) {
+    console.log(
+      `Unable to extract routes from express, route level observability will not be available`
+    );
+    return {
+      routes: [],
+      views: void 0,
+      staticPaths: void 0,
+      viewEngine: void 0
+    };
+  }
+};
+var getIntrospectionPath = (options) => {
+  return (0, import_path5.join)(options.outputDir, "introspection.json");
+};
+var invokeFunction = async (args, options) => {
+  await new Promise((resolve2) => {
+    try {
+      const child = (0, import_child_process.spawn)("node", [(0, import_path5.join)(options.outputDir, options.handler)], {
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: options.outputDir,
+        env: {
+          ...process.env,
+          ...args.meta?.env || {},
+          ...args.meta?.buildEnv || {}
+        }
+      });
+      setTimeout(() => {
+        child.kill("SIGTERM");
+      }, 5e3);
+      child.on("error", () => {
+        console.log(
+          `Unable to extract routes from express, route level observability will not be available`
+        );
+        resolve2(void 0);
+      });
+      child.on("close", () => {
+        resolve2(void 0);
+      });
+    } catch (error) {
+      console.log(
+        `Unable to extract routes from express, route level observability will not be available`
+      );
+      resolve2(void 0);
+    }
+  });
+};
+var expressShimSource = (args) => {
+  const pathToExpress = require_3.resolve("express", {
+    paths: [args.outputDir]
+  });
+  const introspectionPath = getIntrospectionPath(args);
+  return `
+const fs = require('fs');
+const path = require('path');
+const originalExpress = require(${JSON.stringify(pathToExpress)});
+
+let app = null
+let staticPaths = [];
+let views = ''
+let viewEngine = ''
+const routes = {};
+const originalStatic = originalExpress.static
+originalExpress.static = (...args) => {
+  staticPaths.push(args[0]);
+  return originalStatic(...args);
+}
+function expressWrapper() {
+  app = originalExpress.apply(this, arguments);
+  return app;
+}
+
+// Copy all properties from the original express to the wrapper
+Object.setPrototypeOf(expressWrapper, originalExpress);
+Object.assign(expressWrapper, originalExpress);
+
+// Preserve the original prototype
+expressWrapper.prototype = originalExpress.prototype;
+
+module.exports = expressWrapper;
+
+let routesExtracted = false;
+
+const extractRoutes = () => {
+  if (routesExtracted) {
+    return;
+  }
+  routesExtracted = true;
+
+  const methods = ["all", "get", "post", "put", "delete", "patch", "options", "head"]
+  if (!app) {
+    return;
+  }
+  const router = app._router || app.router
+  for (const route of router.stack) {
+    if(route.route) {
+      const m = [];
+      for (const method of methods) {
+        if(route.route.methods[method]) {
+          m.push(method.toUpperCase());
+        }
+      }
+      routes[route.route.path] = { methods: m };
+    }
+  }
+
+  views = app.settings.views
+  viewEngine = app.settings['view engine']
+
+  // Ensure directory exists
+  const dir = path.dirname(${JSON.stringify(introspectionPath)});
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  fs.writeFileSync(${JSON.stringify(introspectionPath)}, JSON.stringify({routes, views, staticPaths, viewEngine}, null, 2));
+}
+
+process.on('exit', () => {
+  extractRoutes()
+});
+
+process.on('SIGINT', () => {
+  extractRoutes()
+  process.exit(0);
+});
+// Write routes to file on SIGTERM
+process.on('SIGTERM', () => {
+  extractRoutes()
+  process.exit(0);
+});
+  `;
+};
+var convertExpressRoute = (route, routeData) => {
+  const { regexp } = (0, import_path_to_regexp.pathToRegexp)(route);
+  const dest = route;
+  if (dest === "/") {
+    return;
+  }
+  const src = regexp.source;
+  return {
+    src,
+    dest,
+    methods: routeData.methods
+  };
+};
+var validatePath = (inputPath, workPath) => {
+  if (inputPath.indexOf("\0") !== -1) {
+    throw new Error(`Path contains null bytes: ${inputPath}`);
+  }
+  const normalizedPath = (0, import_path5.normalize)(inputPath);
+  if (normalizedPath.includes("..")) {
+    throw new Error(
+      `Path contains directory traversal sequences: ${inputPath}`
+    );
+  }
+  if ((0, import_path5.isAbsolute)(normalizedPath)) {
+    throw new Error(`Absolute paths are not allowed: ${inputPath}`);
+  }
+  const resolvedPath = (0, import_path5.resolve)(workPath, normalizedPath);
+  const resolvedWorkPath = (0, import_path5.resolve)(workPath);
+  if (!resolvedPath.startsWith(resolvedWorkPath + import_path5.sep) && resolvedPath !== resolvedWorkPath) {
+    throw new Error(`Path escapes the intended directory: ${inputPath}`);
+  }
+  return normalizedPath;
+};
+
+// src/experimental/build.ts
+var version = 2;
+var build2 = async (args) => {
+  console.log(`Using experimental express build`);
+  const downloadResult = await downloadInstallAndBundle(args);
+  await maybeExecBuildCommand(args, downloadResult);
+  args.entrypoint = await entrypointCallback2(args);
+  const rolldownResult = await rolldown(args);
+  const { routes } = await introspectApp(args, rolldownResult);
+  const lambda = new import_build_utils6.Lambda({
+    runtime: downloadResult.nodeVersion.runtime,
+    ...rolldownResult
+  });
+  const output = { index: lambda };
+  for (const route of routes) {
+    if (route.dest) {
+      if (route.dest === "/") {
+        continue;
+      }
+      output[route.dest] = lambda;
+    }
+  }
+  return {
+    routes,
+    output
+  };
+};
+
+// src/index.ts
+var import_node3 = require("@vercel/node");
+var version2 = 3;
+var name = "express";
 var shouldServe = async (opts) => {
   const requestPath = opts.requestPath.replace(/\/$/, "");
   if (requestPath.startsWith("api") && opts.hasMatched) {
@@ -215,7 +842,7 @@ var shouldServe = async (opts) => {
 var startDevServer = async (opts) => {
   const entrypoint = await entrypointCallback(opts);
   process.env.EXPERIMENTAL_NODE_TYPESCRIPT_ERRORS = "1";
-  return (0, import_node2.startDevServer)({
+  return (0, import_node3.startDevServer)({
     ...opts,
     entrypoint,
     publicDir: "public"
@@ -225,7 +852,10 @@ var startDevServer = async (opts) => {
 0 && (module.exports = {
   build,
   entrypointCallback,
+  experimentalBuild,
+  experimentalVersion,
   findEntrypoint,
+  name,
   require_,
   shouldServe,
   startDevServer,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/express",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "homepage": "https://vercel.com/docs",
@@ -17,16 +17,21 @@
     "edge-entry.js"
   ],
   "dependencies": {
+    "@vercel/nft": "0.30.1",
     "@vercel/static-config": "3.1.2",
-    "@vercel/node": "5.3.24",
-    "ts-morph": "12.0.0"
+    "fs-extra": "11.1.0",
+    "path-to-regexp": "8.3.0",
+    "rolldown": "1.0.0-beta.35",
+    "ts-morph": "12.0.0",
+    "zod": "3.22.4",
+    "@vercel/node": "5.3.24"
   },
   "devDependencies": {
+    "@types/fs-extra": "11",
     "@types/jest": "27.5.1",
     "@types/node": "14.18.33",
     "@vercel/build-utils": "12.1.0",
     "execa": "3.2.0",
-    "fs-extra": "11.1.0",
     "jest-junit": "16.0.0",
     "vite": "^5.1.6",
     "vitest": "^2.0.1"