@cloudflare/vite-plugin 0.0.0-d422c8ecb → 0.0.0-d5ce0c459

package/dist/index.js

@@ -1,6 +1,7 @@
 // src/index.ts
 import assert9 from "node:assert";
 import * as fs5 from "node:fs";
+import { builtinModules as builtinModules2 } from "node:module";
 import * as path7 from "node:path";
 import { createMiddleware } from "@hattip/adapter-node";
 
@@ -1088,13 +1089,9 @@ var INIT_PATH = "/__vite_plugin_cloudflare_init__";
 var MODULE_PATTERN = `__CLOUDFLARE_MODULE__(${MODULE_TYPES.join("|")})__(.*?)__`;
 
 // src/utils.ts
-import { builtinModules } from "node:module";
 import * as path from "node:path";
 import { Request as MiniflareRequest } from "miniflare";
 import "vite";
-var nodeBuiltInModules = new Set(
-  builtinModules.concat(builtinModules.map((m) => `node:${m}`))
-);
 function getOutputDirectory(userConfig, environmentName) {
   const rootOutputDirectory = userConfig.build?.outDir ?? "dist";
   return userConfig.environments?.[environmentName]?.build?.outDir ?? path.join(rootOutputDirectory, environmentName);
@@ -1212,9 +1209,7 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
       // We want to use `workerd` package exports if available (e.g. for postgres).
       conditions: [...defaultConditions, "development|production"],
       // The Cloudflare ones are proper builtins in the environment
-      builtins: [...cloudflareBuiltInModules],
-      // The Node.js ones are no proper builtins in the environment since we also polyfill them using unenv
-      external: [...nodeBuiltInModules]
+      builtins: [...cloudflareBuiltInModules]
     },
     dev: {
       createEnvironment(name2, config) {
@@ -1243,10 +1238,7 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
       // Note: ssr pre-bundling is opt-in and we need to enable it by setting `noDiscovery` to false
       noDiscovery: false,
       entries: workerConfig.main,
-      exclude: [
-        // we have to exclude all node modules to work in dev-mode not just the unenv externals...
-        ...nodeBuiltInModules
-      ],
+      exclude: [...cloudflareBuiltInModules],
       esbuildOptions: {
         platform: "neutral",
         conditions: [...defaultConditions, "development"],
@@ -1372,7 +1364,13 @@ import * as fs2 from "node:fs";
 import * as fsp from "node:fs/promises";
 import * as path3 from "node:path";
 import { fileURLToPath } from "node:url";
-import { Log, LogLevel, Response as MiniflareResponse } from "miniflare";
+import {
+  kCurrentWorker,
+  Log,
+  LogLevel,
+  Response as MiniflareResponse
+} from "miniflare";
+import { globSync } from "tinyglobby";
 import "vite";
 import {
   unstable_getMiniflareWorkerOptions,
@@ -1406,11 +1404,10 @@ function getWorkerToWorkerEntrypointNamesMap(workers) {
   );
   for (const worker of workers) {
     for (const value of Object.values(worker.serviceBindings ?? {})) {
-      if (typeof value === "object" && "name" in value && typeof value.name === "string" && value.entrypoint !== void 0 && value.entrypoint !== "default") {
-        const entrypointNames = workerToWorkerEntrypointNamesMap.get(
-          value.name
-        );
-        assert4(entrypointNames, missingWorkerErrorMessage(value.name));
+      if (typeof value === "object" && "name" in value && value.entrypoint !== void 0 && value.entrypoint !== "default") {
+        const targetWorkerName = value.name === kCurrentWorker ? worker.name : value.name;
+        const entrypointNames = workerToWorkerEntrypointNamesMap.get(targetWorkerName);
+        assert4(entrypointNames, missingWorkerErrorMessage(targetWorkerName));
         entrypointNames.add(value.entrypoint);
       }
     }
@@ -1555,7 +1552,7 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
       }
     }
   ];
-  const userWorkers = resolvedPluginConfig.type === "workers" ? Object.entries(resolvedPluginConfig.workers).map(
+  const workersFromConfig = resolvedPluginConfig.type === "workers" ? Object.entries(resolvedPluginConfig.workers).map(
     ([environmentName, workerConfig]) => {
       const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(
         {
@@ -1564,52 +1561,58 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
         },
         resolvedPluginConfig.cloudflareEnv
       );
+      const { externalWorkers: externalWorkers2 } = miniflareWorkerOptions;
       const { ratelimits, ...workerOptions } = miniflareWorkerOptions.workerOptions;
       return {
-        ...workerOptions,
-        // We have to add the name again because `unstable_getMiniflareWorkerOptions` sets it to `undefined`
-        name: workerConfig.name,
-        modulesRoot: miniflareModulesRoot,
-        unsafeEvalBinding: "__VITE_UNSAFE_EVAL__",
-        bindings: {
-          ...workerOptions.bindings,
-          __VITE_ROOT__: resolvedViteConfig.root,
-          __VITE_ENTRY_PATH__: workerConfig.main
-        },
-        serviceBindings: {
-          ...workerOptions.serviceBindings,
-          ...environmentName === resolvedPluginConfig.entryWorkerEnvironmentName && workerConfig.assets?.binding ? {
-            [workerConfig.assets.binding]: ASSET_WORKER_NAME
-          } : {},
-          __VITE_INVOKE_MODULE__: async (request) => {
-            const payload = await request.json();
-            const invokePayloadData = payload.data;
-            assert4(
-              invokePayloadData.name === "fetchModule",
-              `Invalid invoke event: ${invokePayloadData.name}`
-            );
-            const [moduleId] = invokePayloadData.data;
-            const moduleRE = new RegExp(MODULE_PATTERN);
-            const shouldExternalize = (
-              // Worker modules (CompiledWasm, Text, Data)
-              moduleRE.test(moduleId) || // Node.js builtin node modules (they will be resolved to unenv aliases)
-              nodeBuiltInModules.has(moduleId)
-            );
-            if (shouldExternalize) {
-              const result2 = {
-                externalize: moduleId,
-                type: "module"
-              };
-              return MiniflareResponse.json({ result: result2 });
+        externalWorkers: externalWorkers2,
+        worker: {
+          ...workerOptions,
+          name: workerOptions.name ?? workerConfig.name,
+          modulesRoot: miniflareModulesRoot,
+          unsafeEvalBinding: "__VITE_UNSAFE_EVAL__",
+          bindings: {
+            ...workerOptions.bindings,
+            __VITE_ROOT__: resolvedViteConfig.root,
+            __VITE_ENTRY_PATH__: workerConfig.main
+          },
+          serviceBindings: {
+            ...workerOptions.serviceBindings,
+            ...environmentName === resolvedPluginConfig.entryWorkerEnvironmentName && workerConfig.assets?.binding ? {
+              [workerConfig.assets.binding]: ASSET_WORKER_NAME
+            } : {},
+            __VITE_INVOKE_MODULE__: async (request) => {
+              const payload = await request.json();
+              const invokePayloadData = payload.data;
+              assert4(
+                invokePayloadData.name === "fetchModule",
+                `Invalid invoke event: ${invokePayloadData.name}`
+              );
+              const [moduleId] = invokePayloadData.data;
+              const moduleRE = new RegExp(MODULE_PATTERN);
+              const shouldExternalize = (
+                // Worker modules (CompiledWasm, Text, Data)
+                moduleRE.test(moduleId)
+              );
+              if (shouldExternalize) {
+                const result2 = {
+                  externalize: moduleId,
+                  type: "module"
+                };
+                return MiniflareResponse.json({ result: result2 });
+              }
+              const devEnvironment = viteDevServer.environments[environmentName];
+              const result = await devEnvironment.hot.handleInvoke(payload);
+              return MiniflareResponse.json(result);
             }
-            const devEnvironment = viteDevServer.environments[environmentName];
-            const result = await devEnvironment.hot.handleInvoke(payload);
-            return MiniflareResponse.json(result);
           }
         }
       };
     }
   ) : [];
+  const userWorkers = workersFromConfig.map((options) => options.worker);
+  const externalWorkers = workersFromConfig.flatMap(
+    (options) => options.externalWorkers
+  );
   const workerToWorkerEntrypointNamesMap = getWorkerToWorkerEntrypointNamesMap(userWorkers);
   const workerToDurableObjectClassNamesMap = getWorkerToDurableObjectClassNamesMap(userWorkers);
   const workerToWorkflowEntrypointClassNamesMap = getWorkerToWorkflowEntrypointClassNamesMap(userWorkers);
@@ -1629,6 +1632,7 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
     ),
     workers: [
       ...assetWorkers,
+      ...externalWorkers,
       ...userWorkers.map((workerOptions) => {
         const wrappers = [
           `import { createWorkerEntrypointWrapper, createDurableObjectWrapper, createWorkflowEntrypointWrapper } from '${RUNNER_PATH}';`,
@@ -1661,7 +1665,7 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
         const workflowEntrypointClassNames = workerToWorkflowEntrypointClassNamesMap.get(workerOptions.name);
         assert4(
           workflowEntrypointClassNames,
-          `WorkflowEntrypoint class names not found for worker ${workerOptions.name}`
+          `WorkflowEntrypoint class names not found for worker: ${workerOptions.name}`
         );
         for (const className of [...workflowEntrypointClassNames].sort()) {
           wrappers.push(
@@ -1697,17 +1701,19 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
       );
       const moduleRE = new RegExp(MODULE_PATTERN);
       const match = moduleRE.exec(rawSpecifier);
-      assert4(match, `Unexpected error: no match for module ${rawSpecifier}.`);
+      assert4(match, `Unexpected error: no match for module: ${rawSpecifier}.`);
       const [full, moduleType, modulePath] = match;
       assert4(
         modulePath,
-        `Unexpected error: module path not found in reference ${full}.`
+        `Unexpected error: module path not found in reference: ${full}.`
       );
       let source;
       try {
         source = fs2.readFileSync(modulePath);
       } catch (error) {
-        throw new Error(`Import ${modulePath} not found. Does the file exist?`);
+        throw new Error(
+          `Import "${modulePath}" not found. Does the file exist?`
+        );
       }
       return MiniflareResponse.json({
         // Cap'n Proto expects byte arrays for `:Data` typed fields from JSON
@@ -1716,22 +1722,44 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
     }
   };
 }
+function getPreviewModules(main, modulesRules) {
+  assert4(modulesRules, `Unexpected error: 'modulesRules' is undefined`);
+  const rootPath = path3.dirname(main);
+  const entryPath = path3.basename(main);
+  return {
+    rootPath,
+    modules: [
+      {
+        type: "ESModule",
+        path: entryPath
+      },
+      ...modulesRules.flatMap(
+        ({ type, include }) => globSync(include, { cwd: rootPath, ignore: entryPath }).map((path8) => ({
+          type,
+          path: path8
+        }))
+      )
+    ]
+  };
+}
 function getPreviewMiniflareOptions(vitePreviewServer, persistState) {
   const resolvedViteConfig = vitePreviewServer.config;
   const configPaths = getWorkerConfigPaths(resolvedViteConfig.root);
   const workerConfigs = configPaths.map(
     (configPath) => unstable_readConfig({ config: configPath })
   );
-  const workers = workerConfigs.map((config) => {
+  const workers = workerConfigs.flatMap((config) => {
     const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(config);
-    const { ratelimits, ...workerOptions } = miniflareWorkerOptions.workerOptions;
-    return {
-      ...workerOptions,
-      // We have to add the name again because `unstable_getMiniflareWorkerOptions` sets it to `undefined`
-      name: config.name,
-      modules: true,
-      ...miniflareWorkerOptions.main ? { scriptPath: miniflareWorkerOptions.main } : { script: "" }
-    };
+    const { externalWorkers } = miniflareWorkerOptions;
+    const { ratelimits, modulesRules, ...workerOptions } = miniflareWorkerOptions.workerOptions;
+    return [
+      {
+        ...workerOptions,
+        name: workerOptions.name ?? config.name,
+        ...miniflareWorkerOptions.main ? getPreviewModules(miniflareWorkerOptions.main, modulesRules) : { modules: true, script: "" }
+      },
+      ...externalWorkers
+    ];
   });
   const logger = new ViteMiniflareLogger(resolvedViteConfig);
   return {
@@ -7313,7 +7341,7 @@ Parser.acorn = {
 };
 
 // ../../node_modules/.pnpm/mlly@1.7.4/node_modules/mlly/dist/index.mjs
-import { builtinModules as builtinModules2, createRequire } from "node:module";
+import { builtinModules, createRequire } from "node:module";
 import fs3, { realpathSync, statSync as statSync2, promises } from "node:fs";
 
 // ../../node_modules/.pnpm/ufo@1.5.4/node_modules/ufo/dist/index.mjs
@@ -7373,10 +7401,10 @@ var isAbsolute = function(p) {
 import { fileURLToPath as fileURLToPath$1, URL as URL$1, pathToFileURL as pathToFileURL$1 } from "node:url";
 import assert5 from "node:assert";
 import process$1 from "node:process";
-import path4, { dirname as dirname3 } from "node:path";
+import path4, { dirname as dirname4 } from "node:path";
 import v8 from "node:v8";
 import { format as format2, inspect } from "node:util";
-var BUILTIN_MODULES = new Set(builtinModules2);
+var BUILTIN_MODULES = new Set(builtinModules);
 function normalizeSlash(path8) {
   return path8.replace(/\\/g, "/");
 }
@@ -8490,7 +8518,7 @@ function parsePackageName(specifier, base) {
   return { packageName, packageSubpath, isScoped };
 }
 function packageResolve(specifier, base, conditions) {
-  if (builtinModules2.includes(specifier)) {
+  if (builtinModules.includes(specifier)) {
     return new URL$1("node:" + specifier);
   }
   const { packageName, packageSubpath, isScoped } = parsePackageName(
@@ -8577,7 +8605,7 @@ function moduleResolve(specifier, base, conditions, preserveSymlinks) {
     try {
       resolved = new URL$1(specifier);
     } catch (error_) {
-      if (isRemote && !builtinModules2.includes(specifier)) {
+      if (isRemote && !builtinModules.includes(specifier)) {
         const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
         error.cause = error_;
         throw error;
@@ -8722,7 +8750,8 @@ var { env } = defineEnv({
   nodeCompat: true,
   presets: [cloudflare]
 });
-var CLOUDFLARE_VIRTUAL_PREFIX = "\0__CLOUDFLARE_NODEJS_COMPAT__";
+var nodeCompatExternals = new Set(env.external);
+var nodeCompatEntries = getNodeCompatEntries();
 function isNodeCompat(workerConfig) {
   if (workerConfig === void 0) {
     return false;
@@ -8734,11 +8763,6 @@ function isNodeCompat(workerConfig) {
   if (nodeCompatMode === "v2") {
     return true;
   }
-  if (nodeCompatMode === "legacy") {
-    throw new Error(
-      "Unsupported Node.js compat mode (legacy). Remove the `node_compat` setting and add the `nodejs_compat` flag instead."
-    );
-  }
   if (nodeCompatMode === "v1") {
     throw new Error(
       `Unsupported Node.js compat mode (v1). Only the v2 mode is supported, either change your compat date to "2024-09-23" or later, or set the "nodejs_compat_v2" compatibility flag`
@@ -8750,12 +8774,17 @@ function injectGlobalCode(id, code) {
   const injectedCode = Object.entries(env.inject).map(([globalName, globalInject]) => {
     if (typeof globalInject === "string") {
       const moduleSpecifier2 = globalInject;
-      return `import var_${globalName} from "${CLOUDFLARE_VIRTUAL_PREFIX}${moduleSpecifier2}";
+      return `import var_${globalName} from "${moduleSpecifier2}";
 globalThis.${globalName} = var_${globalName};
 `;
     }
     const [moduleSpecifier, exportName] = globalInject;
-    return `import var_${globalName} from "${CLOUDFLARE_VIRTUAL_PREFIX}${moduleSpecifier}";
+    assert6(
+      moduleSpecifier !== void 0,
+      "Expected moduleSpecifier to be defined"
+    );
+    assert6(exportName !== void 0, "Expected exportName to be defined");
+    return `import var_${globalName} from "${moduleSpecifier}";
 globalThis.${globalName} = var_${globalName}.${exportName};
 `;
   }).join("\n");
@@ -8766,37 +8795,36 @@ globalThis.${globalName} = var_${globalName}.${exportName};
     map: modified.generateMap({ hires: "boundary", source: id })
   };
 }
-function getNodeCompatAliases() {
-  const aliases = {};
-  Object.keys(env.alias).forEach((key) => {
-    if (!env.external.includes(key)) {
-      aliases[key] = CLOUDFLARE_VIRTUAL_PREFIX + key;
-    }
-  });
-  return aliases;
-}
-function getNodeCompatExternals() {
-  return env.external;
-}
-function maybeStripNodeJsVirtualPrefix(source) {
-  return source.startsWith(CLOUDFLARE_VIRTUAL_PREFIX) ? source.slice(CLOUDFLARE_VIRTUAL_PREFIX.length) : void 0;
-}
 function resolveNodeJSImport(source) {
   const alias = env.alias[source];
   if (alias) {
-    assert6(
-      !env.external.includes(alias),
-      `Unexpected unenv alias to external module: ${source} -> ${alias}`
-    );
-    source = alias;
+    return {
+      unresolved: alias,
+      resolved: resolvePathSync(alias, { url: import.meta.url })
+    };
   }
-  const resolved = resolvePathSync(source, {
-    url: import.meta.url
-  });
-  return {
-    unresolved: source,
-    resolved
-  };
+  if (nodeCompatEntries.has(source)) {
+    return {
+      unresolved: source,
+      resolved: resolvePathSync(source, { url: import.meta.url })
+    };
+  }
+}
+function getNodeCompatEntries() {
+  const entries = new Set(Object.values(env.alias));
+  for (const globalInject of Object.values(env.inject)) {
+    if (typeof globalInject === "string") {
+      entries.add(globalInject);
+    } else {
+      assert6(
+        globalInject[0] !== void 0,
+        "Expected first element of globalInject to be defined"
+      );
+      entries.add(globalInject[0]);
+    }
+  }
+  nodeCompatExternals.forEach((external) => entries.delete(external));
+  return entries;
 }
 
 // src/plugin-config.ts
@@ -8841,7 +8869,6 @@ var nonApplicableWorkerConfigs = {
     "build",
     "find_additional_modules",
     "no_bundle",
-    "node_compat",
     "preserve_file_names",
     "site",
     "tsconfig",
@@ -8858,7 +8885,6 @@ var nullableNonApplicable = [
   "find_additional_modules",
   "minify",
   "no_bundle",
-  "node_compat",
   "preserve_file_names",
   "site",
   "tsconfig",
@@ -9109,9 +9135,9 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 }
 
 // src/websockets.ts
-import ws from "ws";
+import { WebSocketServer } from "ws";
 function handleWebSocket(httpServer, fetcher, logger) {
-  const nodeWebSocket = new ws.Server({ noServer: true });
+  const nodeWebSocket = new WebSocketServer({ noServer: true });
   httpServer.on(
     "upgrade",
     async (request, socket, head) => {
@@ -9220,7 +9246,7 @@ function cloudflare2(pluginConfig = {}) {
             }
           } : void 0,
           builder: {
-            async buildApp(builder) {
+            buildApp: userConfig.builder?.buildApp ?? (async (builder) => {
               const clientEnvironment = builder.environments.client;
               const defaultHtmlPath = path7.resolve(
                 builder.config.root,
@@ -9246,7 +9272,7 @@ function cloudflare2(pluginConfig = {}) {
                   )
                 );
               }
-            }
+            })
           }
         };
       },
@@ -9307,7 +9333,7 @@ function cloudflare2(pluginConfig = {}) {
           return;
         }
         config.no_bundle = true;
-        config.rules = [{ type: "ESModule", globs: ["**/*.js"] }];
+        config.rules = [{ type: "ESModule", globs: ["**/*.js", "**/*.mjs"] }];
         if (config.unsafe && Object.keys(config.unsafe).length === 0) {
           config.unsafe = void 0;
         }
@@ -9465,49 +9491,61 @@ function cloudflare2(pluginConfig = {}) {
       apply(_config, env2) {
         return !env2.isPreview;
       },
-      config() {
-        return {
-          resolve: {
-            alias: getNodeCompatAliases()
-          }
-        };
-      },
-      configEnvironment(environmentName) {
-        const workerConfig = getWorkerConfig2(environmentName);
-        if (isNodeCompat(workerConfig)) {
+      configEnvironment(name2) {
+        if (isNodeCompat(getWorkerConfig2(name2))) {
           return {
-            build: {
-              rollupOptions: {
-                external: getNodeCompatExternals()
-              }
+            resolve: {
+              builtins: [...nodeCompatExternals]
+            },
+            optimizeDeps: {
+              // This is a list of dependency entry-points that should be pre-bundled.
+              // In this case we provide a list of all the possible polyfills so that they are pre-bundled,
+              // ready ahead the first request to the dev server.
+              // Without this the dependency optimizer will try to bundle them on-the-fly in the middle of the first request,
+              // which can potentially cause problems if it leads to previous pre-bundling to become stale and needing to be reloaded.
+              // TODO: work out how to re-enable pre-bundling of these
+              // include: [...getNodeCompatEntries()],
+              // This is a list of module specifiers that the dependency optimizer should not follow when doing import analysis.
+              // In this case we provide a list of all the Node.js modules, both those built-in to workerd and those that will be polyfilled.
+              // Obviously we don't want/need the optimizer to try to process modules that are built-in;
+              // But also we want to avoid following the ones that are polyfilled since the dependency-optimizer import analyzer does not
+              // resolve these imports using our `resolveId()` hook causing the optimization step to fail.
+              exclude: [
+                ...builtinModules2,
+                ...builtinModules2.map((m) => `node:${m}`)
+              ]
             }
           };
         }
       },
+      applyToEnvironment(environment) {
+        return isNodeCompat(getWorkerConfig2(environment.name));
+      },
+      // We need the resolver from this plugin to run before built-in ones, otherwise Vite's built-in
+      // resolver will try to externalize the Node.js module imports (e.g. `perf_hooks` and `node:tty`)
+      // rather than allowing the resolve hook here to alias then to polyfills.
+      enforce: "pre",
       async resolveId(source, importer, options) {
-        const strippedSource = maybeStripNodeJsVirtualPrefix(source);
-        if (!strippedSource) {
-          return;
+        const result = resolveNodeJSImport(source);
+        if (!result) {
+          return this.resolve(source, importer, options);
         }
-        const workerConfig = getWorkerConfig2(this.environment.name);
-        if (!isNodeCompat(workerConfig)) {
-          return this.resolve(strippedSource, importer, options);
-        }
-        const { unresolved, resolved } = resolveNodeJSImport(strippedSource);
-        if (this.environment.mode === "dev" && this.environment.depsOptimizer) {
-          const optimized = this.environment.depsOptimizer.registerMissingImport(
-            unresolved,
-            resolved
-          ).id;
-          return this.resolve(optimized, importer, options);
+        if (this.environment.mode === "dev") {
+          assert9(
+            this.environment.depsOptimizer,
+            "depsOptimizer is required in dev mode"
+          );
+          const { id } = this.environment.depsOptimizer.registerMissingImport(
+            result.unresolved,
+            result.resolved
+          );
+          return this.resolve(id, importer, options);
         }
-        return this.resolve(resolved, importer, options);
+        return this.resolve(result.resolved, importer, options);
       },
       async transform(code, id) {
         const workerConfig = getWorkerConfig2(this.environment.name);
-        if (!isNodeCompat(workerConfig)) {
-          return;
-        }
+        assert9(workerConfig, "Expected a worker config");
         const resolvedId = await this.resolve(workerConfig.main);
         if (id === resolvedId?.id) {
           return injectGlobalCode(id, code);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudflare/vite-plugin",
-  "version": "0.0.0-d422c8ecb",
+  "version": "0.0.0-d5ce0c459",
   "description": "Cloudflare plugin for Vite",
   "keywords": [
     "cloudflare",
@@ -35,12 +35,14 @@
   "dependencies": {
     "@cloudflare/unenv-preset": "1.1.1",
     "@hattip/adapter-node": "^0.0.49",
+    "tinyglobby": "^0.2.12",
     "unenv": "2.0.0-rc.1",
-    "ws": "^8.18.0",
-    "miniflare": "0.0.0-d422c8ecb"
+    "ws": "8.18.0",
+    "miniflare": "0.0.0-d5ce0c459",
+    "wrangler": "0.0.0-d5ce0c459"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20250214.0",
+    "@cloudflare/workers-types": "^4.20250310.0",
     "@types/node": "^22.10.1",
     "@types/ws": "^8.5.13",
     "magic-string": "^0.30.12",
@@ -51,9 +53,8 @@
     "vite": "^6.1.0",
     "vitest": "~3.0.5",
     "@cloudflare/mock-npm-registry": "0.0.0",
-    "@cloudflare/workers-tsconfig": "0.0.0",
-    "@cloudflare/workers-shared": "0.0.0-d422c8ecb",
-    "wrangler": "0.0.0-d422c8ecb"
+    "@cloudflare/workers-shared": "0.0.0-d5ce0c459",
+    "@cloudflare/workers-tsconfig": "0.0.0"
   },
   "peerDependencies": {
     "vite": "^6.1.0",
@@ -70,7 +71,7 @@
     "check:type": "tsc --build",
     "dev": "tsup --watch",
     "test": "vitest run",
-    "test:ci": "pnpm test && pnpm test:e2e",
+    "test:ci": "pnpm test",
     "test:e2e": "vitest run -c e2e/vitest.config.ts",
     "test:watch": "vitest"
   }