@hono/vite-build 1.10.1 → 1.11.1

package/dist/adapter/vercel/types.d.mts

@@ -0,0 +1,276 @@
+//#region src/adapter/vercel/types.d.ts
+/**
+ * Main configuration type for Vercel Build Output API v3.
+ * This type represents the root configuration object that should be output in the `.vercel/output/config.json` file.
+ * @see https://vercel.com/docs/build-output-api/v3/configuration
+ */
+type VercelBuildConfigV3 = {
+  /** Version identifier for the Build Output API. Must be 3. */version?: 3;
+  /**
+   * Array of routing rules to handle incoming requests.
+   * Routes are evaluated in order, where the first matching route will be applied.
+   */
+  routes?: Route[];
+  /**
+   * Configuration for Vercel's Image Optimization feature.
+   * Defines how images should be optimized, cached, and served.
+   * @see https://vercel.com/docs/build-output-api/v3/configuration#images
+   */
+  images?: ImagesConfig;
+  /**
+   * Custom domain wildcard configurations for internationalization.
+   * Maps domain names to values that can be referenced by the routes configuration.
+   * @see https://vercel.com/docs/build-output-api/v3/configuration#wildcard
+   */
+  wildcard?: WildCard[];
+  /**
+   * File-specific overrides for static files in the `.vercel/output/static` directory.
+   * Allows overriding Content-Type headers and URL paths for static files.
+   * @see https://vercel.com/docs/build-output-api/v3/configuration#overrides
+   */
+  overrides?: Record<string, Override>;
+  /**
+   * Array of file paths or glob patterns to be cached between builds.
+   * Only relevant when Vercel is building from source code.
+   * @see https://vercel.com/docs/build-output-api/v3/configuration#cache
+   */
+  cache?: string[];
+  /**
+   * Scheduled tasks configuration for production deployments.
+   * Defines API routes that should be invoked on a schedule.
+   * @see https://vercel.com/docs/build-output-api/v3/configuration#crons
+   */
+  crons?: Cron[];
+  /**
+   * Framework metadata for display purposes only.
+   * @see https://vercel.com/docs/build-output-api/v3/configuration#framework
+   */
+  framework?: Framework;
+};
+/**
+ * Route configuration that can either be a Source route or a Handler route.
+ * Source routes match incoming requests, while Handler routes define special behaviors.
+ */
+type Route = Source | Handler;
+/**
+ * Source route configuration for matching and handling incoming requests.
+ * Provides detailed control over request matching and response handling.
+ */
+type Source = {
+  /** Regular expression pattern to match incoming request paths */src: string; /** Path to rewrite or redirect the matched request to */
+  dest?: string; /** Custom HTTP headers to add to the response */
+  headers?: Record<string, string>; /** Array of HTTP methods this route should match */
+  methods?: string[]; /** When true, matching will continue even after this route matches */
+  continue?: boolean; /** When true, the src pattern will be matched case-sensitively */
+  caseSensitive?: boolean; /** Additional validation flag for route matching */
+  check?: boolean; /** HTTP status code to return (e.g., 308 for redirects) */
+  status?: number; /** Conditions that must be present in the request for the route to match */
+  has?: HasField; /** Conditions that must be absent from the request for the route to match */
+  missing?: HasField; /** Configuration for locale-based routing and redirects */
+  locale?: Locale; /** Raw source patterns used by middleware */
+  middlewareRawSrc?: string[]; /** Path to the middleware implementation file */
+  middlewarePath?: string; /** Mitigation action to apply to the route */
+  mitigate?: Mitigate; /** List of transforms to apply to the route */
+  transforms?: Transform[];
+};
+/**
+ * Locale configuration for internationalization routing.
+ * Used to configure language-specific redirects and preferences.
+ */
+type Locale = {
+  /** Mapping of locale codes to their redirect destinations */redirect?: Record<string, string>; /** Name of the cookie used to store the user's locale preference */
+  cookie?: string;
+};
+/**
+ * Matchable value for complex route condition matching.
+ * Allows matching against values using various comparison operators.
+ * @see https://vercel.com/docs/build-output-api/v3/configuration#source-route-matchablevalue
+ */
+type MatchableValue = {
+  /** Value must equal this value */eq?: string | number; /** Value must not equal this value */
+  neq?: string; /** Value must be included in this array */
+  inc?: string[]; /** Value must not be included in this array */
+  ninc?: string[]; /** Value must start with this prefix */
+  pre?: string; /** Value must end with this suffix */
+  suf?: string; /** Value must match this regular expression */
+  re?: string; /** Value must be greater than this number */
+  gt?: number; /** Value must be greater than or equal to this number */
+  gte?: number; /** Value must be less than this number */
+  lt?: number; /** Value must be less than or equal to this number */
+  lte?: number;
+};
+/**
+ * Condition fields for route matching based on request properties.
+ * Used in `has` and `missing` arrays on Source routes.
+ * @see https://vercel.com/docs/build-output-api/v3/configuration#source-route-hasfield
+ */
+type HasField = Array<{
+  /** Identifies this as a host matching condition */type: 'host'; /** Pattern to match against the Host header */
+  value: string | MatchableValue;
+} | {
+  /** Identifies the condition type: header, cookie, or query parameter */type: 'header' | 'cookie' | 'query'; /** Name of the header, cookie, or query parameter to match */
+  key: string; /** Optional value the field should match */
+  value?: string | MatchableValue;
+}>;
+/**
+ * Special handler phases for request processing.
+ * Defines when and how requests should be processed in the routing pipeline.
+ */
+type HandleValue = 'rewrite' | 'filesystem' | 'resource' | 'miss' | 'hit' | 'error';
+/**
+ * Handler route configuration for special request processing phases.
+ * Used to define behavior at specific points in the request lifecycle.
+ */
+type Handler = {
+  /** The type of handler to process the request */handle: HandleValue; /** Optional pattern to match against the request path */
+  src?: string; /** Optional path to handle the request with */
+  dest?: string; /** HTTP status code to return in the response */
+  status?: number;
+};
+/**
+ * Mitigation action to apply to a route.
+ * @see https://vercel.com/docs/build-output-api/v3/configuration#source-route-mitigate
+ */
+type Mitigate = {
+  /** The mitigation action to apply */action: 'challenge' | 'deny';
+};
+/**
+ * Transform to apply to request or response properties on a route.
+ * @see https://vercel.com/docs/build-output-api/v3/configuration#source-route-transform
+ */
+type Transform = {
+  /** The target of the transform: request headers, request query, or response headers */type: 'request.headers' | 'request.query' | 'response.headers'; /** The operation to perform */
+  op: 'append' | 'set' | 'delete'; /** The target key for the transform (regex matching not supported) */
+  target: {
+    key: string | Omit<MatchableValue, 're'>;
+  }; /** Arguments for the transform operation */
+  args?: string | string[];
+};
+/**
+ * Supported image formats for the Image Optimization API.
+ * @see https://vercel.com/docs/build-output-api/v3/configuration#images
+ */
+type ImageFormat = 'image/avif' | 'image/webp';
+/**
+ * Configuration for remote image sources in Image Optimization.
+ * Defines patterns for matching and processing external images.
+ */
+type RemotePattern = {
+  /** Protocol allowed for remote images (http or https) */protocol?: 'http' | 'https'; /** Hostname pattern that remote images must match */
+  hostname: string; /** Optional port number for remote image URLs */
+  port?: string; /** Path pattern that remote image URLs must match */
+  pathname?: string; /** Search query pattern that remote image URLs must match */
+  search?: string;
+};
+/**
+ * Configuration for local image patterns in Image Optimization.
+ * Defines patterns for matching and processing local images.
+ */
+type LocalPattern = {
+  /** Path pattern that local images must match */pathname?: string; /** Search query pattern that local image URLs must match */
+  search?: string;
+};
+/**
+ * Configuration for Vercel's Image Optimization feature.
+ * @see https://vercel.com/docs/build-output-api/v3/configuration#images
+ */
+type ImagesConfig = {
+  /** Array of allowed image widths for resizing */sizes: number[]; /** Array of allowed domains for remote images */
+  domains: string[]; /** Patterns for matching remote image sources */
+  remotePatterns?: RemotePattern[]; /** Patterns for matching local image sources */
+  localPatterns?: LocalPattern[]; /** Array of allowed quality values for image optimization */
+  qualities?: number[]; /** Minimum time (in seconds) to cache optimized images */
+  minimumCacheTTL?: number; /** Array of supported output formats for optimization */
+  formats?: ImageFormat[]; /** Whether to allow processing of SVG images (use with caution) */
+  dangerouslyAllowSVG?: boolean; /** Content Security Policy for optimized images */
+  contentSecurityPolicy?: string; /** Content-Disposition header type for image responses */
+  contentDispositionType?: string;
+};
+/**
+ * Configuration for custom domain wildcards.
+ * Used for internationalization and dynamic routing based on domains.
+ * @see https://vercel.com/docs/build-output-api/v3/configuration#wildcard
+ */
+type WildCard = {
+  /** Domain name to match for this wildcard configuration */domain: string; /** Value to use when this wildcard matches (available as $wildcard in routes) */
+  value: string;
+};
+/**
+ * Configuration for path or content-type overrides of static files.
+ * @see https://vercel.com/docs/build-output-api/v3/configuration#overrides
+ */
+type Override = {
+  /** URL path where the static file will be accessible */path?: string; /** Content-Type header value for the static file */
+  contentType?: string;
+};
+/**
+ * Configuration for scheduled tasks (Cron Jobs).
+ * @see https://vercel.com/docs/build-output-api/v3/configuration#crons
+ */
+type Cron = {
+  /** Path to the API route that handles the cron job */path: string; /** Cron schedule expression (e.g., "0 0 * * *" for daily at midnight) */
+  schedule: string;
+};
+/**
+ * Framework metadata for display purposes.
+ * @see https://vercel.com/docs/build-output-api/v3/configuration#framework
+ */
+type Framework = {
+  /** Framework version string */version: string;
+};
+/**
+ * Base configuration for a serverless function in Vercel.
+ * This type represents the `.vc-config.json` configuration within a `.func` directory.
+ * @see https://vercel.com/docs/build-output-api/v3/primitives#serverless-function-configuration
+ */
+type VercelServerlessFunctionConfig = {
+  /** Indicates the initial file where code will be executed for the Serverless Function */handler: string; /** Specifies which "runtime" will be used to execute the Serverless Function */
+  runtime: string; /** The amount of memory (RAM in MB) allocated to the function */
+  memory?: number; /** The maximum duration of the function in seconds */
+  maxDuration?: number; /** Map of additional environment variables available to the function */
+  environment?: Record<string, string>; /** The regions the function is available in */
+  regions?: string[]; /** Instruction set architecture the function supports */
+  architecture?: 'x86_64' | 'arm64'; /** Whether the custom runtime supports Lambda runtime wrappers */
+  supportsWrapper?: boolean; /** Whether the function supports response streaming */
+  supportsResponseStreaming?: boolean;
+};
+/**
+ * Node.js-specific serverless function configuration.
+ * Extends the base serverless function config with Node.js launcher options.
+ * @see https://vercel.com/docs/build-output-api/v3/primitives#nodejs-config
+ */
+type VercelNodejsServerlessFunctionConfig = VercelServerlessFunctionConfig & {
+  /** Specifies which "launcher" will be used to execute the Serverless Function */launcherType: 'Nodejs'; /** Enables request and response helpers methods */
+  shouldAddHelpers?: boolean; /** Enables source map generation */
+  shouldAddSourcemapSupport?: boolean; /** AWS Handler Value for when the serverless function uses AWS Lambda syntax */
+  awsLambdaHandler?: string;
+};
+/**
+ * Configuration for an Edge Function in Vercel.
+ * This type represents the `.vc-config.json` configuration for Edge Functions.
+ * @see https://vercel.com/docs/build-output-api/v3/primitives#edge-function-configuration
+ */
+type VercelEdgeFunctionConfig = {
+  /** Must be 'edge' to indicate this is an Edge Function */runtime: 'edge'; /** Initial file where code will be executed for the Edge Function */
+  entrypoint: string; /** List of environment variable names available to the Edge Function */
+  envVarsInUse?: string[]; /** Regions the edge function will be available in (defaults to 'all') */
+  regions?: 'all' | string | string[];
+};
+/**
+ * Configuration for a Prerender Function in Vercel (ISR).
+ * This type represents the `.prerender-config.json` configuration file.
+ * @see https://vercel.com/docs/build-output-api/v3/primitives#prerender-configuration-file
+ */
+type VercelPrerenderFunctionConfig = {
+  /** Cache expiration time in seconds, or false to never expire */expiration: number | false; /** Group number for co-revalidating prerender assets together */
+  group?: number; /** Random token for Draft Mode bypass cookie (`__prerender_bypass`) */
+  bypassToken?: string; /** Name of the optional fallback file relative to the configuration file */
+  fallback?: string; /** Query string parameter names that will be cached independently */
+  allowQuery?: string[]; /** When true, the query string will be present on the request argument */
+  passQuery?: boolean; /** Initial headers to include with the build-time prerendered response */
+  initialHeaders?: Record<string, string>; /** Initial HTTP status code for the build-time prerendered response (default 200) */
+  initialStatus?: number; /** When true, expose the response body regardless of status code including errors */
+  exposeErrBody?: boolean;
+};
+//#endregion
+export { VercelBuildConfigV3, VercelEdgeFunctionConfig, VercelNodejsServerlessFunctionConfig, VercelPrerenderFunctionConfig, VercelServerlessFunctionConfig };

package/dist/adapter/vercel/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/base.d.mts

@@ -0,0 +1,30 @@
+import { GetEntryContentOptions } from "./entry/index.mjs";
+import { ConfigEnv, Plugin, UserConfig } from "vite";
+
+//#region src/base.d.ts
+type BuildOptions = {
+  /**
+   * @default ['src/index.ts', './src/index.tsx', './app/server.ts']
+   */
+  entry?: string | string[];
+  /**
+   * @default './dist'
+   */
+  output?: string;
+  outputDir?: string;
+  external?: string[];
+  /**
+   * @default true
+   */
+  minify?: boolean;
+  emptyOutDir?: boolean;
+  apply?: ((this: void, config: UserConfig, env: ConfigEnv) => boolean) | undefined;
+  /**
+   * @default 'webworker'
+   */
+  ssrTarget?: 'node' | 'webworker';
+} & Omit<GetEntryContentOptions, 'entry'>;
+declare const defaultOptions: Required<Omit<BuildOptions, 'entryContentAfterHooks' | 'entryContentBeforeHooks' | 'entryContentDefaultExportHook'>>;
+declare const buildPlugin: (options: BuildOptions) => Plugin;
+//#endregion
+export { BuildOptions, buildPlugin as default, defaultOptions };

package/dist/base.mjs

@@ -0,0 +1,99 @@
+import { getEntryContent } from "./entry/index.mjs";
+import { builtinModules } from "module";
+import { readdirSync } from "node:fs";
+import { resolve } from "node:path";
+//#region src/base.ts
+const defaultOptions = {
+	entry: [
+		"src/index.ts",
+		"./src/index.tsx",
+		"./app/server.ts"
+	],
+	output: "index.js",
+	outputDir: "./dist",
+	external: [],
+	minify: true,
+	emptyOutDir: false,
+	apply: (_config, { command, mode }) => {
+		if (command === "build" && mode !== "client") return true;
+		return false;
+	},
+	staticPaths: [],
+	preset: "hono",
+	ssrTarget: "webworker"
+};
+const buildPlugin = (options) => {
+	const virtualEntryId = "virtual:build-entry-module";
+	const resolvedVirtualEntryId = "\0" + virtualEntryId;
+	let config;
+	const output = options.output ?? defaultOptions.output;
+	const preset = options.preset ?? defaultOptions.preset;
+	return {
+		name: "@hono/vite-build",
+		configResolved: async (resolvedConfig) => {
+			config = resolvedConfig;
+		},
+		resolveId(id) {
+			if (id === virtualEntryId) return resolvedVirtualEntryId;
+		},
+		async load(id) {
+			if (id === resolvedVirtualEntryId) {
+				const staticPaths = options.staticPaths ?? [];
+				const direntPaths = [];
+				try {
+					const publicDirPaths = readdirSync(resolve(config.root, config.publicDir), { withFileTypes: true });
+					direntPaths.push(...publicDirPaths);
+				} catch {}
+				try {
+					const buildOutDirPaths = readdirSync(resolve(config.root, config.build.outDir), { withFileTypes: true });
+					direntPaths.push(...buildOutDirPaths);
+				} catch {}
+				const uniqueStaticPaths = /* @__PURE__ */ new Set();
+				direntPaths.forEach((p) => {
+					if (p.isDirectory()) uniqueStaticPaths.add(`/${p.name}/*`);
+					else {
+						if (p.name === output) return;
+						uniqueStaticPaths.add(`/${p.name}`);
+					}
+				});
+				staticPaths.push(...Array.from(uniqueStaticPaths));
+				const entry = options.entry ?? defaultOptions.entry;
+				return await getEntryContent({
+					entry: Array.isArray(entry) ? entry : [entry],
+					entryContentBeforeHooks: options.entryContentBeforeHooks,
+					entryContentAfterHooks: options.entryContentAfterHooks,
+					entryContentDefaultExportHook: options.entryContentDefaultExportHook,
+					staticPaths,
+					preset
+				});
+			}
+		},
+		apply: options?.apply ?? defaultOptions.apply,
+		config: async () => {
+			return {
+				ssr: {
+					external: options?.external ?? defaultOptions.external,
+					noExternal: true,
+					target: options?.ssrTarget ?? defaultOptions.ssrTarget
+				},
+				build: {
+					outDir: options?.outputDir ?? defaultOptions.outputDir,
+					emptyOutDir: options?.emptyOutDir ?? defaultOptions.emptyOutDir,
+					minify: options?.minify ?? defaultOptions.minify,
+					ssr: true,
+					rollupOptions: {
+						external: [
+							...builtinModules,
+							/^node:/,
+							...options?.external ?? defaultOptions.external
+						],
+						input: virtualEntryId,
+						output: { entryFileNames: output }
+					}
+				}
+			};
+		}
+	};
+};
+//#endregion
+export { buildPlugin as default, defaultOptions };

package/dist/entry/index.d.mts

@@ -0,0 +1,27 @@
+//#region src/entry/index.d.ts
+type EntryContentHookOptions = {
+  staticPaths: string[];
+};
+type EntryContentHook = (appName: string, options?: EntryContentHookOptions) => string | Promise<string>;
+declare const presets: readonly ["hono", "hono/tiny", "hono/quick", "@hono/hono"];
+type Preset = (typeof presets)[number];
+type GetEntryContentOptions = {
+  entry: string[];
+  entryContentBeforeHooks?: EntryContentHook[];
+  entryContentAfterHooks?: EntryContentHook[];
+  /**
+   * Explicitly specify the default export for the app. Make sure your export
+   * incorporates the app passed as the `appName` argument.
+   *
+   * @default `export default ${appName}`
+   */
+  entryContentDefaultExportHook?: EntryContentHook;
+  staticPaths?: string[];
+  /**
+   * @default `hono`
+   */
+  preset?: Preset;
+};
+declare const getEntryContent: (options: GetEntryContentOptions) => Promise<string>;
+//#endregion
+export { EntryContentHook, EntryContentHookOptions, GetEntryContentOptions, Preset, getEntryContent };

package/dist/entry/index.mjs

@@ -0,0 +1,63 @@
+import { normalize } from "node:path";
+//#region src/entry/index.ts
+const presets = [
+	"hono",
+	"hono/tiny",
+	"hono/quick",
+	"@hono/hono"
+];
+const normalizePaths = (paths) => {
+	return paths.map((p) => {
+		let normalizedPath = normalize(p).replace(/\\/g, "/");
+		if (normalizedPath.startsWith("./")) normalizedPath = normalizedPath.substring(2);
+		return "/" + normalizedPath;
+	});
+};
+const getEntryContent = async (options) => {
+	const preset = presets.includes(options.preset ?? "hono") ? options.preset ?? "hono" : (console.warn(`Invalid preset: ${options.preset}. Must be one of: ${presets.join(", ")}. Using 'hono' as default.`), "hono");
+	const staticPaths = options.staticPaths ?? [""];
+	const globStr = normalizePaths(options.entry).map((e) => `'${e}'`).join(",");
+	const hooksToString = async (appName, hooks) => {
+		if (hooks) return (await Promise.all(hooks.map((hook) => {
+			return hook(appName, { staticPaths });
+		}))).join("\n");
+		return "";
+	};
+	const appStr = `const modules = import.meta.glob([${globStr}], { import: 'default', eager: true })
+      let added = false
+      for (const [, app] of Object.entries(modules)) {
+        if (app) {
+          mainApp.all('*', (c) => {
+            let executionCtx
+            try {
+              executionCtx = c.executionCtx
+            } catch {}
+            return app.fetch(c.req.raw, c.env, executionCtx)
+          })
+          mainApp.notFound((c) => {
+            let executionCtx
+            try {
+              executionCtx = c.executionCtx
+            } catch {}
+            return app.fetch(c.req.raw, c.env, executionCtx)
+          })
+          added = true
+        }
+      }
+      if (!added) {
+        throw new Error("Can't import modules from [${globStr}]")
+      }`;
+	const defaultExportHook = options.entryContentDefaultExportHook ?? (() => "export default mainApp");
+	return `import { Hono } from '${preset}'
+const mainApp = new Hono()
+
+${await hooksToString("mainApp", options.entryContentBeforeHooks)}
+
+${appStr}
+
+${await hooksToString("mainApp", options.entryContentAfterHooks)}
+
+${await hooksToString("mainApp", [defaultExportHook])}`;
+};
+//#endregion
+export { getEntryContent };

package/dist/entry/{serve-static.d.ts → serve-static.d.mts}

@@ -1,7 +1,8 @@
+//#region src/entry/serve-static.d.ts
 type ServeStaticHookOptions = {
-    filePaths?: string[];
-    root?: string;
+  filePaths?: string[];
+  root?: string;
 };
 declare const serveStaticHook: (appName: string, options: ServeStaticHookOptions) => string;
-
-export { serveStaticHook };
+//#endregion
+export { serveStaticHook };

package/dist/entry/serve-static.mjs

@@ -0,0 +1,8 @@
+//#region src/entry/serve-static.ts
+const serveStaticHook = (appName, options) => {
+	let code = "";
+	for (const path of options.filePaths ?? []) code += `${appName}.use('${path}', serveStatic({ root: '${options.root ?? "./"}' }))\n`;
+	return code;
+};
+//#endregion
+export { serveStaticHook };

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import buildPlugin, { defaultOptions } from "./base.mjs";
+export { buildPlugin as default, defaultOptions };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import buildPlugin, { defaultOptions } from "./base.mjs";
+//#region src/index.ts
+var src_default = buildPlugin;
+//#endregion
+export { src_default as default, defaultOptions };

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@hono/vite-build",
   "description": "Vite plugin to build your Hono app",
-  "version": "1.10.1",
-  "types": "dist/index.d.ts",
-  "module": "dist/index.js",
+  "version": "1.11.1",
+  "types": "dist/index.d.mts",
+  "module": "dist/index.mjs",
   "type": "module",
   "scripts": {
     "test": "vitest --run",
-    "build": "rimraf dist && tsup && publint",
-    "watch": "tsup --watch",
+    "build": "yarn run -T tsdown",
+    "watch": "yarn run -T tsdown --watch",
     "prerelease": "yarn build",
     "release": "yarn publish"
   },
@@ -17,64 +17,36 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
     },
     "./bun": {
-      "types": "./dist/adapter/bun/index.d.ts",
-      "import": "./dist/adapter/bun/index.js"
+      "types": "./dist/adapter/bun/index.d.mts",
+      "import": "./dist/adapter/bun/index.mjs"
     },
     "./node": {
-      "types": "./dist/adapter/node/index.d.ts",
-      "import": "./dist/adapter/node/index.js"
+      "types": "./dist/adapter/node/index.d.mts",
+      "import": "./dist/adapter/node/index.mjs"
     },
     "./cloudflare-pages": {
-      "types": "./dist/adapter/cloudflare-pages/index.d.ts",
-      "import": "./dist/adapter/cloudflare-pages/index.js"
+      "types": "./dist/adapter/cloudflare-pages/index.d.mts",
+      "import": "./dist/adapter/cloudflare-pages/index.mjs"
     },
     "./cloudflare-workers": {
-      "types": "./dist/adapter/cloudflare-workers/index.d.ts",
-      "import": "./dist/adapter/cloudflare-workers/index.js"
+      "types": "./dist/adapter/cloudflare-workers/index.d.mts",
+      "import": "./dist/adapter/cloudflare-workers/index.mjs"
     },
     "./netlify-functions": {
-      "types": "./dist/adapter/netlify-functions/index.d.ts",
-      "import": "./dist/adapter/netlify-functions/index.js"
+      "types": "./dist/adapter/netlify-functions/index.d.mts",
+      "import": "./dist/adapter/netlify-functions/index.mjs"
     },
     "./deno": {
-      "types": "./dist/adapter/deno/index.d.ts",
-      "import": "./dist/adapter/deno/index.js"
+      "types": "./dist/adapter/deno/index.d.mts",
+      "import": "./dist/adapter/deno/index.mjs"
     },
     "./vercel": {
-      "types": "./dist/adapter/vercel/index.d.ts",
-      "import": "./dist/adapter/vercel/index.js"
-    }
-  },
-  "typesVersions": {
-    "*": {
-      "types": [
-        "./dist/types"
-      ],
-      "bun": [
-        "./dist/adapter/bun/index.d.ts"
-      ],
-      "node": [
-        "./dist/adapter/node/index.d.ts"
-      ],
-      "cloudflare-pages": [
-        "./dist/adapter/cloudflare-pages/index.d.ts"
-      ],
-      "cloudflare-workers": [
-        "./dist/adapter/cloudflare-workers/index.d.ts"
-      ],
-      "netlify-functions": [
-        "./dist/adapter/netlify-functions/index.d.ts"
-      ],
-      "deno": [
-        "./dist/adapter/deno/index.d.ts"
-      ],
-      "vercel": [
-        "./dist/adapter/vercel/index.d.ts"
-      ]
+      "types": "./dist/adapter/vercel/index.d.mts",
+      "import": "./dist/adapter/vercel/index.mjs"
     }
   },
   "author": "Yusuke Wada <yusuke@kamawada.com> (https://github.com/yusukebe)",
@@ -95,11 +67,7 @@
   "devDependencies": {
     "@hono/node-server": "^1.19.11",
     "@types/node": "^24.10.0",
-    "glob": "^10.3.10",
     "hono": "^4.6.12",
-    "publint": "^0.1.12",
-    "rimraf": "^5.0.1",
-    "tsup": "^7.2.0",
     "vite": "^6.1.1",
     "vitest": "^2.1.1"
   },