@vercel/hono 0.1.1 → 0.1.3

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 honoVersion = require_(resolved).version;
     if (honoVersion) {
-      version2 = honoVersion;
+      version3 = honoVersion;
     }
   } catch (e) {
   }
   res.output.framework = {
     slug: frameworkName,
-    version: version2
+    version: version3
   };
   return res;
 };
@@ -202,9 +205,635 @@ var findMainPackageEntrypoint = (files) => {
   return null;
 };
 
-// src/index.ts
+// src/experimental/build.ts
+var import_build_utils5 = 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*)?["']hono["']\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 hono. 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 hono. 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_path5 = require("path");
+var import_fs_extra = require("fs-extra");
+var import_fs4 = require("fs");
+var import_promises = require("fs/promises");
+var import_child_process = require("child_process");
+var import_path_to_regexp = require("path-to-regexp");
+var import_zod = require("zod");
+var introspectApp = async (args, options) => {
+  await injectRouteCapture(options);
+  await invokeFunction(args, options);
+  const {
+    routes: routesFromIntrospection,
+    views,
+    staticPaths,
+    viewEngine
+  } = await processIntrospection(options);
+  await cleanup(options);
+  console.log(
+    `Generated introspection.json with ${routesFromIntrospection.length} routes for observability`
+  );
+  return { routes: routesFromIntrospection, views, staticPaths, viewEngine };
+};
+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]) => convertHonoRoute(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");
+    const parsedData = JSON.parse(introspection);
+    console.log("Parsed introspection data:", Object.keys(parsedData));
+    console.log("Routes count:", Object.keys(parsedData.routes || {}).length);
+    return schema.parse(parsedData);
+  } catch (error) {
+    console.log("Schema validation error:", error);
+    console.log(
+      `Unable to extract routes from hono, 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 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 invokeFunction = async (args, options) => {
+  await new Promise((resolve) => {
+    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 hono, route level observability will not be available`
+        );
+        resolve(void 0);
+      });
+      child.on("close", () => {
+        resolve(void 0);
+      });
+    } catch (error) {
+      console.log(
+        `Unable to extract routes from hono, route level observability will not be available`
+      );
+      resolve(void 0);
+    }
+  });
+};
+var injectRouteCapture = async (options) => {
+  const bundlePath = (0, import_path5.join)(options.outputDir, options.handler);
+  const introspectionPath = getIntrospectionPath(options);
+  try {
+    let bundleContent = (0, import_fs4.readFileSync)(bundlePath, "utf8");
+    const routeCaptureCode = `
+// Route capture for introspection using Hono's built-in methods
+import fs from 'fs';
+import path from 'path';
+const routes = {};
+let routesExtracted = false;
+
+// Function to extract routes using Hono's built-in app.routes
+function extractRoutesFromApp(app) {
+  if (!app || !app.routes) {
+    return;
+  }
+  
+  // Use Hono's built-in routes property
+  for (const route of app.routes) {
+    const routePath = route.path;
+    const method = route.method.toUpperCase();
+    
+    if (!routes[routePath]) {
+      routes[routePath] = { methods: [] };
+    }
+    if (!routes[routePath].methods.includes(method)) {
+      routes[routePath].methods.push(method);
+    }
+  }
+}
+
+// Handle app.all() routes - they should include all HTTP methods
+const processAllRoutes = () => {
+  for (const [path, routeData] of Object.entries(routes)) {
+    if (routeData.methods.includes('ALL')) {
+      routeData.methods = [
+        'GET',
+        'POST',
+        'PUT',
+        'DELETE',
+        'PATCH',
+        'OPTIONS',
+        'HEAD',
+      ];
+    }
+  }
+};
+
+const extractRoutes = () => {
+  if (routesExtracted) {
+    return;
+  }
+  routesExtracted = true;
+
+  // Extract routes from all Hono instances
+  if (typeof app !== 'undefined') {
+    extractRoutesFromApp(app);
+  }
+  
+  // Also check for other common variable names
+  const commonNames = ['api', 'router', 'server', 'hono', 'honoApp'];
+  for (const name of commonNames) {
+    if (typeof globalThis[name] !== 'undefined') {
+      extractRoutesFromApp(globalThis[name]);
+    }
+  }
+
+  processAllRoutes();
+
+  // Ensure directory exists
+  const dir = path.dirname('${introspectionPath}');
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  fs.writeFileSync('${introspectionPath}', JSON.stringify({
+    routes,
+    views: undefined,
+    staticPaths: undefined,
+    viewEngine: undefined
+  }, null, 2));
+};
+
+process.on('exit', () => {
+  extractRoutes();
+});
+
+process.on('SIGINT', () => {
+  extractRoutes();
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  extractRoutes();
+  process.exit(0);
+});
+
+`;
+    const importEndIndex = bundleContent.indexOf("//#region index.js");
+    if (importEndIndex !== -1) {
+      bundleContent = bundleContent.slice(0, importEndIndex) + routeCaptureCode + bundleContent.slice(importEndIndex);
+    } else {
+      bundleContent = routeCaptureCode + bundleContent;
+    }
+    await (0, import_fs_extra.outputFile)(bundlePath, bundleContent);
+    console.log("Injected route capture into bundled JavaScript");
+  } catch (error) {
+    console.log("Failed to inject route capture:", error);
+    throw error;
+  }
+};
+var convertHonoRoute = (route, routeData) => {
+  try {
+    const { regexp } = (0, import_path_to_regexp.pathToRegexp)(route);
+    const dest = route;
+    const src = regexp.source;
+    return {
+      src,
+      dest,
+      methods: routeData.methods
+    };
+  } catch (error) {
+    console.log(`Skipping route with invalid path: ${route}`);
+    const escapedRoute = route.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return {
+      src: `^${escapedRoute}$`,
+      dest: route,
+      methods: routeData.methods
+    };
+  }
+};
+
+// src/experimental/build.ts
+var version = 2;
+var build2 = async (args) => {
+  console.log(`Using experimental hono 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_utils5.Lambda({
+    runtime: downloadResult.nodeVersion.runtime,
+    ...rolldownResult
+  });
+  const output = { index: lambda };
+  const usedPaths = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    if (route.dest) {
+      if (route.dest === "/") {
+        continue;
+      }
+      const normalizedPath = route.dest.replace(/\/$/, "");
+      if (!usedPaths.has(normalizedPath)) {
+        output[normalizedPath] = lambda;
+        usedPaths.add(normalizedPath);
+      }
+    }
+  }
+  const normalizedRoutes = routes.map((route) => {
+    if (route.dest && route.dest !== "/") {
+      return {
+        ...route,
+        dest: route.dest.replace(/\/$/, "")
+      };
+    }
+    return route;
+  });
+  const mainRoutes = [
+    {
+      handle: "filesystem"
+    },
+    ...normalizedRoutes,
+    {
+      src: "/(.*)",
+      dest: "/"
+    }
+  ];
+  return {
+    routes: mainRoutes,
+    output
+  };
+};
+
+// src/index.ts
+var import_node3 = require("@vercel/node");
+var version2 = 3;
+var name = "hono";
 var shouldServe = async (opts) => {
   const requestPath = opts.requestPath.replace(/\/$/, "");
   if (requestPath.startsWith("api") && opts.hasMatched) {
@@ -215,16 +844,20 @@ 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
+    entrypoint,
+    publicDir: "public"
   });
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   build,
   entrypointCallback,
+  experimentalBuild,
+  experimentalVersion,
   findEntrypoint,
+  name,
   require_,
   shouldServe,
   startDevServer,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/hono",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "homepage": "https://vercel.com/docs",
@@ -17,11 +17,17 @@
     "edge-entry.js"
   ],
   "dependencies": {
+    "@vercel/nft": "0.30.1",
     "@vercel/static-config": "3.1.2",
-    "@vercel/node": "5.3.23",
-    "ts-morph": "12.0.0"
+    "@vercel/node": "5.3.24",
+    "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"
   },
   "devDependencies": {
+    "@types/fs-extra": "11",
     "@types/jest": "27.5.1",
     "@types/node": "14.18.33",
     "@vercel/build-utils": "12.1.0",