@cloudflare/vite-plugin 0.0.0-910007bce → 0.0.0-930ebb279

package/README.md

@@ -1,340 +1,8 @@
 # `@cloudflare/vite-plugin`
 
-[Intro](#intro) | [Quick start](#quick-start) | [Tutorial](#tutorial) | [API](#api) | [Cloudflare environments](#cloudflare-environments) | [Debugging](#debugging) | [Migrating from `wrangler dev`](#migrating-from-wrangler-dev)
-
-## Intro
-
-The Cloudflare Vite plugin enables a full-featured integration between Vite and the Workers runtime.
+The Cloudflare Vite plugin enables a full-featured integration between [Vite](https://vite.dev/) and the [Workers runtime](https://developers.cloudflare.com/workers/runtime-apis/).
 Your Worker code runs inside [workerd](https://github.com/cloudflare/workerd), matching the production behavior as closely as possible and providing confidence as you develop and deploy your applications.
 
-### Features
-
-- Provides direct access to Workers runtime APIs and bindings
-- Supports Workers Assets, enabling you to build static sites, SPAs, and full-stack applications
-- Leverages Vite's hot module replacement for consistently fast updates
-- Supports `vite preview` for previewing your build output in the Workers runtime prior to deployment
-
-## Quick start
-
-### Start with a basic `package.json`
-
-```json
-{
-  "name": "cloudflare-vite-quick-start",
-  "private": true,
-  "version": "0.0.0",
-  "type": "module",
-  "scripts": {
-    "dev": "vite",
-    "build": "vite build",
-    "preview": "vite preview"
-  }
-}
-```
-
-> [!NOTE]
-> Ensure that you include `"type": "module"` in order to use ES modules by default.
-
-### Install the dependencies
-
-```sh
-npm install vite @cloudflare/vite-plugin wrangler --save-dev
-```
-
-### Create your Vite config file and include the Cloudflare plugin
-
-```ts
-// vite.config.ts
-
-import { defineConfig } from "vite";
-import { cloudflare } from "@cloudflare/vite-plugin";
-
-export default defineConfig({
-  plugins: [cloudflare()],
-});
-```
-
-### Create your Worker config file
-
-```toml
-# wrangler.toml
-
-name = "cloudflare-vite-quick-start"
-compatibility_date = "2024-12-30"
-main = "./src/index.ts"
-```
-
-### Create your Worker entry file
-
-```ts
-// src/index.ts
-
-export default {
-  fetch() {
-    return new Response(`Running in ${navigator.userAgent}!`);
-  },
-};
-```
-
-You can now develop (`npm run dev`), build (`npm run build`), preview (`npm run preview`), and deploy (`npm exec wrangler deploy`) your application.
-
-## Tutorial
-
-In this tutorial, you will create a React SPA that can be deployed as a Worker with Workers Assets.
-Then, you will add an API Worker that can be accessed from the front-end code.
-You will develop, build, and preview the application using Vite before finally deploying to Cloudflare.
-
-### Set up and configure the React SPA
-
-#### Scaffold a Vite project
-
-Start by creating a React TypeScript project with Vite.
-
-```sh
-npm create vite@latest cloudflare-vite-tutorial -- --template react-ts
-```
-
-Open the `cloudflare-vite-tutorial` directory in your editor of choice.
-
-#### Add the Cloudflare dependencies
-
-```sh
-npm install @cloudflare/vite-plugin wrangler --save-dev
-```
-
-#### Add the plugin to your Vite config
-
-```ts
-// vite.config.ts
-
-import { defineConfig } from "vite";
-import react from "@vitejs/plugin-react";
-import { cloudflare } from "@cloudflare/vite-plugin";
-
-export default defineConfig({
-  plugins: [react(), cloudflare()],
-});
-```
-
-#### Create your Worker config file
-
-```toml
-# wrangler.toml
-
-name = "cloudflare-vite-tutorial"
-compatibility_date = "2024-12-30"
-assets = { not_found_handling = "single-page-application" }
-```
-
-The [`not_found_handling`](https://developers.cloudflare.com/workers/static-assets/routing/#not_found_handling--404-page--single-page-application--none) value has been set to `single-page-application`.
-This means that all not found requests will serve the `index.html` file.
-With the Cloudflare plugin, the `assets` routing configuration is used in place of Vite's default behavior.
-This ensures that your application's routing works the same way while developing as it does when deployed to production.
-
-Note that the [`directory`](https://developers.cloudflare.com/workers/static-assets/binding/#directory) field is not used when configuring assets with Vite.
-The `directory` in the output configuration will automatically point to the client build output.
-
-> [!NOTE]
-> When using the Cloudflare Vite plugin, the Worker config (for example, `wrangler.toml`) that you provide is the input configuration file.
-> A separate output `wrangler.json` file is created when you run `vite build`.
-> This output file is a snapshot of your configuration at the time of the build and is modified to reference your build artifacts.
-> It is the configuration that is used for preview and deployment.
-
-#### Update the .gitignore file
-
-Wrangler will use and/or generate temporary files that should not be stored in git. Add the following lines to the `.gitignore` file:
-
-```gitignore
-.wrangler
-.dev.vars
-```
-
-#### Run the development server
-
-Run `npm run dev` to verify that your application is working as expected.
-
-For a purely front-end application, you could now build (`npm run build`), preview (`npm run preview`), and deploy (`npm exec wrangler deploy`) your application.
-However, this tutorial will show you how to go a step further and add an API Worker.
-
-### Add an API Worker
-
-#### Configure TypeScript for your Worker code
-
-```sh
-npm install @cloudflare/workers-types --save-dev
-```
-
-```jsonc
-// tsconfig.worker.json
-
-{
-  "extends": "./tsconfig.node.json",
-  "compilerOptions": {
-    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.worker.tsbuildinfo",
-    "types": ["@cloudflare/workers-types/2023-07-01", "vite/client"],
-  },
-  "include": ["api"],
-}
-```
-
-```jsonc
-// tsconfig.json
-
-{
-  "files": [],
-  "references": [
-    { "path": "./tsconfig.app.json" },
-    { "path": "./tsconfig.node.json" },
-    { "path": "./tsconfig.worker.json" },
-  ],
-}
-```
-
-#### Add to your Worker configuration
-
-```toml
-# wrangler.toml
-
-name = "cloudflare-vite-tutorial"
-compatibility_date = "2024-12-30"
-assets = { not_found_handling = "single-page-application", binding = "ASSETS" }
-main = "./api/index.ts"
-```
-
-The assets `binding` defined here will allow you to access the assets functionality from your Worker.
-
-#### Add your API Worker
-
-```ts
-// api/index.ts
-
-interface Env {
-  ASSETS: Fetcher;
-}
-
-export default {
-  fetch(request, env) {
-    const url = new URL(request.url);
-
-    if (url.pathname.startsWith("/api/")) {
-      return Response.json({
-        name: "Cloudflare",
-      });
-    }
-
-    return env.ASSETS.fetch(request);
-  },
-} satisfies ExportedHandler<Env>;
-```
-
-The Worker above will be invoked for any request not matching a static asset.
-It returns a JSON response if the `pathname` starts with `/api/` and otherwise passes the incoming request through to the assets binding.
-This means that for paths that do not start with `/api/`, the `not_found_handling` behavior defined in the Worker config will be evaluated and the `index.html` file will be returned, enabling SPA navigations.
-
-#### Call the API from the client
-
-Edit `src/App.tsx` so that it includes an additional button that calls the API and sets some state.
-Replace the file contents with the following code:
-
-```tsx
-// src/App.tsx
-
-import { useState } from "react";
-import reactLogo from "./assets/react.svg";
-import viteLogo from "/vite.svg";
-import "./App.css";
-
-function App() {
-  const [count, setCount] = useState(0);
-  const [name, setName] = useState("unknown");
-
-  return (
-    <>
-      <div>
-        <a href="https://vite.dev" target="_blank">
-          <img src={viteLogo} className="logo" alt="Vite logo" />
-        </a>
-        <a href="https://react.dev" target="_blank">
-          <img src={reactLogo} className="logo react" alt="React logo" />
-        </a>
-      </div>
-      <h1>Vite + React</h1>
-      <div className="card">
-        <button
-          onClick={() => setCount((count) => count + 1)}
-          aria-label="increment"
-        >
-          count is {count}
-        </button>
-        <p>
-          Edit <code>src/App.tsx</code> and save to test HMR
-        </p>
-      </div>
-      <div className="card">
-        <button
-          onClick={() => {
-            fetch("/api/")
-              .then((res) => res.json() as Promise<{ name: string }>)
-              .then((data) => setName(data.name));
-          }}
-          aria-label="get name"
-        >
-          Name from API is: {name}
-        </button>
-        <p>
-          Edit <code>api/index.ts</code> to change the name
-        </p>
-      </div>
-      <p className="read-the-docs">
-        Click on the Vite and React logos to learn more
-      </p>
-    </>
-  );
-}
-
-export default App;
-```
-
-Now, if you click the button, it will display 'Name from API is: Cloudflare'.
-
-Increment the counter to update the application state in the browser.
-Next, edit `api/index.ts` by changing the `name` it returns to `'Cloudflare Workers'`.
-If you click the button again, it will display the new `name` while preserving the previously set counter value.
-With Vite and the Cloudflare plugin, you can iterate on the client and server parts of your app quickly without losing UI state between edits.
-
-#### Build your application
-
-Run `npm run build` to build your application.
-
-If you inspect the `dist` directory, you will see that it contains two subdirectories: `client` and `cloudflare-vite-tutorial`.
-The `cloudflare-vite-tutorial` directory contains your Worker code and the output `wrangler.json` configuration.
-
-#### Preview your application
-
-Run `npm run preview` to validate that your application runs as expected.
-This command will run your build output locally in the Workers runtime, closely matching its behaviour in production.
-
-#### Deploy to Cloudflare
-
-Run `npm exec wrangler deploy` to deploy your application to Cloudflare.
-This command will automatically use the output `wrangler.json` that was included in the build output.
-
-### Next steps
-
-In this tutorial, we created an SPA that could be deployed as a Worker with Workers Assets.
-We then added an API Worker that could be accessed from the front-end code and deployed to Cloudflare.
-Possible next steps include:
-
-- Adding a binding to another Cloudflare service such as a [KV namespace](https://developers.cloudflare.com/kv/) or [D1 database](https://developers.cloudflare.com/d1/)
-- Expanding the API to include additional routes
-- Using a library, such as [tRPC](https://trpc.io/) or [Hono](https://hono.dev/), in your API Worker
-
-## API
-
-### `cloudflare`
-
-The `cloudflare` plugin should be included in the Vite `plugins` array:
-
 ```ts
 // vite.config.ts
 
@@ -346,215 +14,22 @@ export default defineConfig({
 });
 ```
 
-It accepts an optional `PluginConfig` parameter.
-
-### `interface PluginConfig`
-
-- `configPath?: string`
-
-  An optional path to your Worker config file.
-  By default, a `wrangler.toml`, `wrangler.json`, or `wrangler.jsonc` file in the root of your application will be used as the Worker config.
-
-- `viteEnvironment?: { name?: string }`
-
-  Optional Vite environment options.
-  By default, the environment name is the Worker name with `-` characters replaced with `_`.
-  Setting the name here will override this.
-
-- `persistState?: boolean | { path: string }`
-
-  An optional override for state persistence.
-  By default, state is persisted to `.wrangler/state` in a `v3` subdirectory.
-  A custom `path` can be provided or, alternatively, persistence can be disabled by setting the value to `false`.
-
-- `auxiliaryWorkers?: Array<AuxiliaryWorkerConfig>`
-
-  An optional array of auxiliary workers.
-  You can use [service bindings](https://developers.cloudflare.com/workers/runtime-apis/bindings/service-bindings/) to call auxiliary workers from your main (entry) Worker.
-  All requests are routed through your entry Worker.
-  During the build, each Worker is output to a separate subdirectory of `dist`.
-
-- `inspectorPort?: number | false`
-
-  Optional inspector port to use for debugging your workers, for more details on debugging see the [devtools section](#devtools). Can be set to `false` to disable the debugging inspector altogether. Defaults to `9229`.
-
-> [!NOTE]
-> When running `wrangler deploy`, only your main (entry) Worker will be deployed.
-> If using multiple Workers, each must be deployed individually.
-> You can inspect the `dist` directory and then run `wrangler deploy -c path-to-worker-output-config` for each.
-
-### `interface AuxiliaryWorkerConfig`
-
-- `configPath: string`
-
-  A required path to your Worker config file.
-
-- `viteEnvironment?: { name?: string }`
-
-  Optional Vite environment options.
-  By default, the environment name is the Worker name with `-` characters replaced with `_`.
-  Setting the name here will override this.
-
-## Cloudflare environments
-
-A Worker config file may contain configuration for multiple [Cloudflare environments](https://developers.cloudflare.com/workers/wrangler/environments/).
-With the Cloudflare Vite plugin, you select a Cloudflare environment at dev or build time by providing the `CLOUDFLARE_ENV` environment variable.
-Consider the following example `wrangler.toml` file:
-
-```toml
-# wrangler.toml
-
-name = "my-worker"
-compatibility_date = "2024-12-30"
-main = "./src/index.ts"
-
-vars = { MY_VAR = "Top-level var" }
-
-[env.staging]
-vars = { MY_VAR = "Staging var" }
-
-[env.production]
-vars = { MY_VAR = "Production var" }
-```
-
-If you run `CLOUDFLARE_ENV=production vite build` then the output `wrangler.json` file generated by the build will be a flattened configuration for the 'production' Cloudflare environment.
-This combines [top-level only](https://developers.cloudflare.com/workers/wrangler/configuration/#top-level-only-keys), [inheritable](https://developers.cloudflare.com/workers/wrangler/configuration/#inheritable-keys), and [non-inheritable](https://developers.cloudflare.com/workers/wrangler/configuration/#non-inheritable-keys) keys.
-The value of `MY_VAR` will therefore be `'Production var'`.
-The name of the Worker will be `'my-worker-production'`.
-This is because the environment name is automatically appended to the top-level Worker name.
-
-> [!NOTE]
-> The default Vite environment name for a Worker is always the top-level Worker name.
-> This enables you to reference the Worker consistently in your Vite config when using multiple Cloudflare environments.
-
-Cloudflare environments can also be used in development.
-For example, you could run `CLOUDFLARE_ENV=development vite dev`.
-It is common to use the default top-level environment as the development environment and then add additional environments as necessary.
-
-> [!NOTE]
-> Running `vite dev` or `vite build` without providing `CLOUDFLARE_ENV` will use the default top-level Cloudflare environment.
-> The value of `MY_VAR` will therefore be `'Top-level var'`.
-> As Cloudflare environments are applied at dev and build time, specifying `CLOUDFLARE_ENV` when running `vite preview` or `wrangler deploy` will have no effect.
-
-### Combining Cloudflare environments and Vite modes
-
-You may wish to combine the concepts of [Cloudflare environments](https://developers.cloudflare.com/workers/wrangler/environments/) and [Vite modes](https://vite.dev/guide/env-and-mode.html#modes).
-With this approach, the Vite mode can be used to select the Cloudflare environment and a single method can be used to determine environment specific configuration and code.
-Consider again the previous example:
-
-```toml
-# wrangler.toml
-
-name = "my-worker"
-compatibility_date = "2024-12-30"
-main = "./src/index.ts"
-
-vars = { MY_VAR = "Top-level var" }
-
-[env.staging]
-vars = { MY_VAR = "Staging var" }
-
-[env.production]
-vars = { MY_VAR = "Production var" }
-```
-
-Next, provide `.env.staging` and `.env.production` files:
-
-```sh
-# .env.staging
-
-CLOUDFLARE_ENV=staging
-```
-
-```sh
-# .env.production
-
-CLOUDFLARE_ENV=production
-```
-
-By default, `vite build` uses the 'production' Vite mode.
-Vite will therefore load the `.env.production` file to get the environment variables that are used in the build.
-Since the `.env.production` file contains `CLOUDFLARE_ENV=production`, the Cloudflare Vite plugin will select the 'production' Cloudflare environment.
-The value of `MY_VAR` will therefore be `'Production var'`.
-If you run `vite build --mode staging` then the 'staging' Vite mode will be used and the 'staging' Cloudflare environment will be selected.
-The value of `MY_VAR` will therefore be `'Staging var'`.
-
-## Secrets
+## Documentation
 
-Secrets can be provided to your Worker in local development using a [`.dev.vars`](https://developers.cloudflare.com/workers/configuration/secrets/#local-development-with-secrets) file. If you are using [Cloudflare Environments](#cloudflare-environments) then the relevant `.dev.vars` file will be selected. For example, `CLOUDFLARE_ENV=staging vite dev` will load `.dev.vars.staging` if it exists and fall back to `.dev.vars`.
+Full documentation can be found [here](https://developers.cloudflare.com/workers/vite-plugin/).
 
-> [!NOTE]
-> The `vite build` command copies the relevant `.dev.vars[.env-name]` file to the output directory. This is only used when running `vite preview` and is not deployed with your Worker.
+## Features
 
-## Debugging
-
-The Cloudflare Vite plugin allows you to conveniently debug your Worker code during local development.
-
-By default the inspector port used by the plugin is `9229`, which can be customized by providing a different port to the plugin's `inspectorPort` option.
-
-There are two recommended ways of doing so, which we'll explore in this section.
-
-### Devtools
-
-When running `vite dev` or `vite preview` a `/__debug` route in your local server will be made available which gives you access to [Cloudflare's implementation](/packages/chrome-devtools-patches) of [Chrome's DevTools](https://developer.chrome.com/docs/devtools/overview).
-
-Navigating to this route will open a devtools tab for each of the workers in your application (Note: in case of multiple workers you might need to allow your browser to open pop-ups).
-
-Once the tab or tabs are open, you can make a request to your application and start debugging your workers' code.
-
-Note: If you're not interested in debugging all your workers you can close the tabs of the workers you don't want to debug.
-
-### VS Code
-
-To setup VS Code for breakpoint debugging for your application, you will need to create a `.vscode/launch.json` file that contains a configuration following this structure:
-
-```json
-{
-  "configurations": [
-    {
-      "name": "<NAME_OF_WORKER>",
-      "type": "node",
-      "request": "attach",
-      "websocketAddress": "ws://localhost:9229/<NAME_OF_WORKER>",
-      "resolveSourceMapLocations": null,
-      "attachExistingChildren": false,
-      "autoAttachChildProcesses": false,
-      "sourceMaps": true
-    }
-  ],
-  "compounds": [
-    {
-      "name": "Debug All Workers",
-      "configurations": ["<NAME_OF_WORKER>"],
-      "stopAll": true
-    }
-  ]
-}
-```
-
-Where, `<NAME_OF_WORKER>` indicates the name of your worker as specified in your Wrangler configuration.
-
-Note: if you customized your `inspectorPort` you need to use that port in the `websocketAddress` field.
-
-If you have more than one worker you need add a configuration in the `configurations` field for each one and then include the configuration name in the `configurations` array in the compound configuration.
-
-Once your `launch.json` file is ready, after running `vite dev` or `vite preview` you can select **Debug All Workers** at the top of the **Run & Debug** panel to attach debuggers to all the various Workers. Then you can add breakpoints to your code and start debugging.
-
-Note: You can also manually select the configurations to run (e.g. **Debug Worker1**) to filter which workers you want to debug.
-
-## Migrating from `wrangler dev`
-
-Migrating from `wrangler dev` is a simple process and you can follow the instructions in the [Quick start](#quick-start) to get started.
-There are a few key differences to highlight:
-
-### Input and output Worker config files
-
-In the Vite integration, your Worker config file (for example, `wrangler.toml`) is the input configuration and a separate output configuration is created as part of the build.
-This output file is a snapshot of your configuration at the time of the build and is modified to reference your build artifacts.
-It is the configuration that is used for preview and deployment.
+- Uses the Vite [Environment API](https://vite.dev/guide/api-environment) to integrate Vite with the Workers runtime
+- Provides direct access to [Workers runtime APIs](https://developers.cloudflare.com/workers/runtime-apis/) and [bindings](https://developers.cloudflare.com/workers/runtime-apis/bindings/)
+- Builds your front-end assets for deployment to Cloudflare, enabling you to build static sites, SPAs, and full-stack applications
+- Official support for [React Router v7](https://reactrouter.com/) with server-side rendering
+- Leverages Vite's hot module replacement for consistently fast updates
+- Supports `vite preview` for previewing your build output in the Workers runtime prior to deployment
 
-### Redundant fields in the Wrangler config file
+## Use cases
 
-There are various options in the Worker config file that are ignored when using Vite, as they are either no longer applicable or are replaced by Vite equivalents.
-If these options are provided, then warnings will be printed to the console with suggestions for how to proceed.
-Examples where the Vite configuration should be used instead include `alias` and `define`.
+- React Router v7 (support for more full-stack frameworks is coming soon)
+- Static sites, such as single-page applications, with or without an integrated backend API
+- Standalone Workers
+- Multi-Worker applications

package/dist/index.js

@@ -485,11 +485,12 @@ var require_mime = __commonJS({
 });
 
 // src/index.ts
-import assert8 from "node:assert";
+import assert10 from "node:assert";
 import * as fs5 from "node:fs";
 import * as fsp2 from "node:fs/promises";
 import * as path9 from "node:path";
 import { createMiddleware } from "@hattip/adapter-node";
+import replace from "@rollup/plugin-replace";
 
 // ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
 var comma = ",".charCodeAt(0);
@@ -1557,6 +1558,7 @@ var MagicString = class _MagicString {
 
 // src/index.ts
 import { Miniflare } from "miniflare";
+import colors2 from "picocolors";
 import * as vite7 from "vite";
 
 // src/constants.ts
@@ -12939,8 +12941,9 @@ function getNodeCompatEntries() {
   return entries;
 }
 var NodeJsCompatWarnings = class {
-  constructor(environment) {
-    this.environment = environment;
+  constructor(environmentName, resolvedViteConfig) {
+    this.environmentName = environmentName;
+    this.resolvedViteConfig = resolvedViteConfig;
   }
   sources = /* @__PURE__ */ new Map();
   timer;
@@ -12948,6 +12951,7 @@ var NodeJsCompatWarnings = class {
     const importers = this.sources.get(source) ?? /* @__PURE__ */ new Set();
     this.sources.set(source, importers);
     importers.add(importer);
+    this.renderWarningsOnIdle();
   }
   renderWarningsOnIdle() {
     if (this.timer) {
@@ -12960,19 +12964,16 @@ var NodeJsCompatWarnings = class {
   }
   renderWarnings() {
     if (this.sources.size > 0) {
-      let message = `
-
-Unexpected Node.js imports for environment "${this.environment.name}". Do you need to enable the "nodejs_compat" compatibility flag?
-Refer to https://developers.cloudflare.com/workers/runtime-apis/nodejs/ for more details.
+      let message = `Unexpected Node.js imports for environment "${this.environmentName}". Do you need to enable the "nodejs_compat" compatibility flag? Refer to https://developers.cloudflare.com/workers/runtime-apis/nodejs/ for more details.
 `;
       this.sources.forEach((importers, source) => {
         importers.forEach((importer) => {
-          message += ` - "${source}" imported from "${path3.relative(this.environment.config.root, importer)}"
+          message += ` - "${source}" imported from "${path3.relative(this.resolvedViteConfig.root, importer)}"
 `;
         });
       });
-      this.environment.logger.warn(message, {
-        environment: this.environment.name
+      this.resolvedViteConfig.logger.warn(message, {
+        timestamp: true
       });
       this.sources.clear();
     }
@@ -12992,6 +12993,7 @@ var VITE_DEV_METADATA_HEADER = "__VITE_DEV_METADATA__";
 
 // src/utils.ts
 import * as path4 from "node:path";
+import getPort, { portNumbers } from "get-port";
 import { Request as MiniflareRequest } from "miniflare";
 import "vite";
 function getOutputDirectory(userConfig, environmentName) {
@@ -13002,6 +13004,10 @@ function getRouterWorker(miniflare2) {
   return miniflare2.getWorker(ROUTER_WORKER_NAME);
 }
 function toMiniflareRequest(request) {
+  const host = request.headers.get("Host");
+  if (host) {
+    request.headers.set("X-Forwarded-Host", host);
+  }
   const secFetchMode = request.headers.get("Sec-Fetch-Mode");
   if (secFetchMode) {
     request.headers.set("X-Mf-Sec-Fetch-Mode", secFetchMode);
@@ -13030,6 +13036,9 @@ var postfixRE = /[?#].*$/;
 function cleanUrl(url) {
   return url.replace(postfixRE, "");
 }
+function getFirstAvailablePort(start) {
+  return getPort({ port: portNumbers(start, 65535) });
+}
 
 // src/cloudflare-environment.ts
 var webSocketUndefinedError = "The WebSocket is undefined";
@@ -13440,7 +13449,7 @@ function getEntryWorkerConfig(resolvedPluginConfig) {
   }
   return resolvedPluginConfig.workers[resolvedPluginConfig.entryWorkerEnvironmentName];
 }
-function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
+function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspectorPort) {
   const resolvedViteConfig = viteDevServer.config;
   const entryWorkerConfig = getEntryWorkerConfig(resolvedPluginConfig);
   const assetsConfig = getAssetsConfig(
@@ -13532,7 +13541,7 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
         worker: {
           ...workerOptions,
           name: workerOptions.name ?? workerConfig.name,
-          unsafeInspectorProxy: resolvedPluginConfig.inspectorPort !== false,
+          unsafeInspectorProxy: inspectorPort !== false,
           modulesRoot: miniflareModulesRoot,
           unsafeEvalBinding: "__VITE_UNSAFE_EVAL__",
           serviceBindings: {
@@ -13574,8 +13583,8 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
   const logger = new ViteMiniflareLogger(resolvedViteConfig);
   return {
     log: logger,
-    inspectorPort: resolvedPluginConfig.inspectorPort || void 0,
-    unsafeInspectorProxy: resolvedPluginConfig.inspectorPort !== false,
+    inspectorPort: inspectorPort === false ? void 0 : inspectorPort,
+    unsafeInspectorProxy: inspectorPort !== false,
     handleRuntimeStdio(stdout, stderr) {
       const decoder = new TextDecoder();
       stdout.forEach((data2) => logger.info(decoder.decode(data2)));
@@ -13712,7 +13721,7 @@ function getPreviewModules(main, modulesRules) {
     ]
   };
 }
-function getPreviewMiniflareOptions(vitePreviewServer, workerConfigs, persistState, inspectorPort = DEFAULT_INSPECTOR_PORT) {
+function getPreviewMiniflareOptions(vitePreviewServer, workerConfigs, persistState, inspectorPort) {
   const resolvedViteConfig = vitePreviewServer.config;
   const workers = workerConfigs.flatMap((config) => {
     const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(config);
@@ -13731,7 +13740,7 @@ function getPreviewMiniflareOptions(vitePreviewServer, workerConfigs, persistSta
   const logger = new ViteMiniflareLogger(resolvedViteConfig);
   return {
     log: logger,
-    inspectorPort: inspectorPort || void 0,
+    inspectorPort: inspectorPort === false ? void 0 : inspectorPort,
     unsafeInspectorProxy: inspectorPort !== false,
     handleRuntimeStdio(stdout, stderr) {
       const decoder = new TextDecoder();
@@ -13781,11 +13790,12 @@ function miniflareLogLevelFromViteLogLevel(level = "info") {
 }
 
 // src/plugin-config.ts
-import assert7 from "node:assert";
+import assert8 from "node:assert";
 import * as path8 from "node:path";
 import * as vite6 from "vite";
 
 // src/workers-configs.ts
+import assert7 from "node:assert";
 import * as fs4 from "node:fs";
 import * as path7 from "node:path";
 import { unstable_readConfig as unstable_readConfig2 } from "wrangler";
@@ -13819,8 +13829,7 @@ var nonApplicableWorkerConfigs = {
     "preserve_file_names",
     "rules",
     "site",
-    "tsconfig",
-    "upload_source_maps"
+    "tsconfig"
   ]
 };
 var nullableNonApplicable = [
@@ -13831,8 +13840,7 @@ var nullableNonApplicable = [
   "no_bundle",
   "preserve_file_names",
   "site",
-  "tsconfig",
-  "upload_source_maps"
+  "tsconfig"
 ];
 function readWorkerConfig(configPath, env2) {
   const nonApplicable = {
@@ -13994,14 +14002,52 @@ function getWorkerConfig(configPath, env2, opts) {
     nonApplicable
   };
 }
+function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliaryWorker = false) {
+  if (requestedConfigPath) {
+    const configPath2 = path7.resolve(root, requestedConfigPath);
+    const forAuxiliaryWorkerErrorMessage = isForAuxiliaryWorker ? " requested for one of your auxiliary workers" : "";
+    const errorMessagePrefix = `The provided configPath (${configPath2})${forAuxiliaryWorkerErrorMessage}`;
+    const fileExtension = path7.extname(configPath2).slice(1);
+    if (!allowedWranglerConfigExtensions.includes(fileExtension)) {
+      const foundExtensionMessage = !fileExtension ? "no extension found" : `"${fileExtension}" found`;
+      throw new Error(
+        `${errorMessagePrefix} doesn't point to a file with the correct file extension. It should point to a jsonc, json or toml file (${foundExtensionMessage} instead)`
+      );
+    }
+    const mainStat = fs4.statSync(configPath2, { throwIfNoEntry: false });
+    if (!mainStat) {
+      throw new Error(
+        `${errorMessagePrefix} doesn't point to an existing file`
+      );
+    }
+    if (mainStat.isDirectory()) {
+      throw new Error(
+        `${errorMessagePrefix} points to a directory. It should point to a file.`
+      );
+    }
+    return configPath2;
+  }
+  assert7(
+    isForAuxiliaryWorker === false,
+    "Unexpected Error: trying to find the wrangler config for an auxiliary worker"
+  );
+  const configPath = findWranglerConfig(root);
+  if (!configPath) {
+    throw new Error(
+      `No config file found in the ${root} directory. Please add a wrangler.(jsonc|json|toml) file.`
+    );
+  }
+  return configPath;
+}
 function findWranglerConfig(root) {
-  for (const extension of ["json", "jsonc", "toml"]) {
+  for (const extension of allowedWranglerConfigExtensions) {
     const configPath = path7.join(root, `wrangler.${extension}`);
     if (fs4.existsSync(configPath)) {
       return configPath;
     }
   }
 }
+var allowedWranglerConfigExtensions = ["jsonc", "json", "toml"];
 
 // src/plugin-config.ts
 function workerNameToEnvironmentName(workerName) {
@@ -14010,7 +14056,6 @@ function workerNameToEnvironmentName(workerName) {
 function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
   const configPaths = /* @__PURE__ */ new Set();
   const persistState = pluginConfig.persistState ?? true;
-  const inspectorPort = pluginConfig.inspectorPort ?? DEFAULT_INSPECTOR_PORT;
   const experimental = pluginConfig.experimental ?? {};
   const root = userConfig.root ? path8.resolve(userConfig.root) : process.cwd();
   const { CLOUDFLARE_ENV: cloudflareEnv } = vite6.loadEnv(
@@ -14019,22 +14064,23 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     /* prefixes */
     ""
   );
-  const configPath = pluginConfig.configPath ? path8.resolve(root, pluginConfig.configPath) : findWranglerConfig(root);
-  if (!configPath) {
-    throw new Error(
-      `Config not found. Have you created a wrangler.json(c) or wrangler.toml file?`
-    );
-  }
-  const entryWorkerResolvedConfig = getWorkerConfig(configPath, cloudflareEnv, {
-    visitedConfigPaths: configPaths,
-    isEntryWorker: true
-  });
+  const entryWorkerConfigPath = getValidatedWranglerConfigPath(
+    root,
+    pluginConfig.configPath
+  );
+  const entryWorkerResolvedConfig = getWorkerConfig(
+    entryWorkerConfigPath,
+    cloudflareEnv,
+    {
+      visitedConfigPaths: configPaths,
+      isEntryWorker: true
+    }
+  );
   if (entryWorkerResolvedConfig.type === "assets-only") {
     return {
       type: "assets-only",
       config: entryWorkerResolvedConfig.config,
       configPaths,
-      inspectorPort,
       persistState,
       rawConfigs: {
         entryWorker: entryWorkerResolvedConfig
@@ -14050,15 +14096,20 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
   };
   const auxiliaryWorkersResolvedConfigs = [];
   for (const auxiliaryWorker of pluginConfig.auxiliaryWorkers ?? []) {
+    const workerConfigPath = getValidatedWranglerConfigPath(
+      root,
+      auxiliaryWorker.configPath,
+      true
+    );
     const workerResolvedConfig = getWorkerConfig(
-      path8.resolve(root, auxiliaryWorker.configPath),
+      workerConfigPath,
       cloudflareEnv,
       {
         visitedConfigPaths: configPaths
       }
     );
     auxiliaryWorkersResolvedConfigs.push(workerResolvedConfig);
-    assert7(
+    assert8(
       workerResolvedConfig.type === "worker",
       "Unexpected error: received AssetsOnlyResult with auxiliary workers."
     );
@@ -14075,7 +14126,6 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     type: "workers",
     configPaths,
     persistState,
-    inspectorPort,
     workers,
     entryWorkerEnvironmentName,
     rawConfigs: {
@@ -14123,6 +14173,54 @@ function handleWebSocket(httpServer, getFetcher) {
   );
 }
 
+// src/worker-environments-validation.ts
+import assert9 from "node:assert";
+function validateWorkerEnvironmentsResolvedConfigs(resolvedPluginConfig, resolvedViteConfig) {
+  const workersEnvironmentNames = Object.keys(resolvedPluginConfig.workers);
+  const disallowedEnvsConfigs = /* @__PURE__ */ new Map();
+  for (const envName of workersEnvironmentNames) {
+    const workerEnvConfig = resolvedViteConfig.environments[envName];
+    assert9(workerEnvConfig, `Missing environment config for "${envName}"`);
+    const { optimizeDeps, resolve: resolve8 } = workerEnvConfig;
+    const disallowedConfig = {};
+    const disallowedOptimizeDepsExcludeEntries = (optimizeDeps.exclude ?? []).filter((entry) => {
+      if (cloudflareBuiltInModules.includes(entry)) {
+        return false;
+      }
+      if (NODEJS_MODULES_RE.test(entry) && isNodeCompat(resolvedPluginConfig.workers[envName])) {
+        return false;
+      }
+      return true;
+    });
+    if (disallowedOptimizeDepsExcludeEntries.length > 0) {
+      disallowedConfig.optimizeDepsExclude = disallowedOptimizeDepsExcludeEntries;
+    }
+    if (resolve8.external === true || resolve8.external.length > 0) {
+      disallowedConfig.resolveExternal = resolve8.external;
+    }
+    if (Object.keys(disallowedConfig).length > 0) {
+      disallowedEnvsConfigs.set(envName, disallowedConfig);
+    }
+  }
+  if (disallowedEnvsConfigs.size > 0) {
+    const errorMessage = `The following environment configurations are incompatible with the Cloudflare Vite plugin:
+${[
+      ...disallowedEnvsConfigs
+    ].map(
+      ([envName, disallowedConfig]) => [
+        disallowedConfig.optimizeDepsExclude ? `	- "${envName}" environment: \`optimizeDeps.exclude\`: ${JSON.stringify(disallowedConfig.optimizeDepsExclude)}
+` : null,
+        disallowedConfig.resolveExternal ? `	- "${envName}" environment: \`resolve.external\`: ${JSON.stringify(disallowedConfig.resolveExternal)}
+` : null
+      ].join("")
+    ).join(
+      ""
+    )}To resolve this issue, avoid setting \`optimizeDeps.exclude\` and \`resolve.external\` in your Cloudflare Worker environments.
+`;
+    throw new Error(errorMessage);
+  }
+}
+
 // src/index.ts
 var workersConfigsWarningShown = false;
 var miniflare;
@@ -14193,7 +14291,7 @@ function cloudflare2(pluginConfig = {}) {
                   resolvedPluginConfig.workers
                 ).map((environmentName) => {
                   const environment = builder.environments[environmentName];
-                  assert8(
+                  assert10(
                     environment,
                     `${environmentName} environment not found`
                   );
@@ -14214,6 +14312,12 @@ function cloudflare2(pluginConfig = {}) {
       },
       configResolved(config) {
         resolvedViteConfig = config;
+        if (resolvedPluginConfig?.type === "workers") {
+          validateWorkerEnvironmentsResolvedConfigs(
+            resolvedPluginConfig,
+            resolvedViteConfig
+          );
+        }
       },
       generateBundle(_, bundle) {
         let config;
@@ -14234,7 +14338,7 @@ function cloudflare2(pluginConfig = {}) {
           if (isEntryWorker && hasClientBuild) {
             const workerOutputDirectory = this.environment.config.build.outDir;
             const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
-            assert8(
+            assert10(
               clientOutputDirectory,
               "Unexpected error: client output directory is undefined"
             );
@@ -14311,23 +14415,36 @@ function cloudflare2(pluginConfig = {}) {
         }
       },
       async configureServer(viteDevServer) {
-        assert8(
+        assert10(
           viteDevServer.httpServer,
           "Unexpected error: No Vite HTTP server"
         );
-        if (miniflare) {
-          await miniflare.setOptions(
-            getDevMiniflareOptions(resolvedPluginConfig, viteDevServer)
+        if (!miniflare) {
+          const inputInspectorPort = await getInputInspectorPortOption(
+            pluginConfig,
+            viteDevServer
           );
-        } else {
           miniflare = new Miniflare(
-            getDevMiniflareOptions(resolvedPluginConfig, viteDevServer)
+            getDevMiniflareOptions(
+              resolvedPluginConfig,
+              viteDevServer,
+              inputInspectorPort
+            )
+          );
+        } else {
+          const resolvedInspectorPort = await getResolvedInspectorPort(pluginConfig);
+          await miniflare.setOptions(
+            getDevMiniflareOptions(
+              resolvedPluginConfig,
+              viteDevServer,
+              resolvedInspectorPort ?? false
+            )
           );
         }
         await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
         const middleware = createMiddleware(
           async ({ request }) => {
-            assert8(miniflare, `Miniflare not defined`);
+            assert10(miniflare, `Miniflare not defined`);
             const routerWorker = await getRouterWorker(miniflare);
             return routerWorker.fetch(toMiniflareRequest(request), {
               redirect: "manual"
@@ -14336,7 +14453,7 @@ function cloudflare2(pluginConfig = {}) {
           { alwaysCallNext: false }
         );
         handleWebSocket(viteDevServer.httpServer, async () => {
-          assert8(miniflare, `Miniflare not defined`);
+          assert10(miniflare, `Miniflare not defined`);
           const routerWorker = await getRouterWorker(miniflare);
           return routerWorker.fetch;
         });
@@ -14346,14 +14463,18 @@ function cloudflare2(pluginConfig = {}) {
           });
         };
       },
-      configurePreviewServer(vitePreviewServer) {
+      async configurePreviewServer(vitePreviewServer) {
         const workerConfigs = getWorkerConfigs(vitePreviewServer.config.root);
+        const inputInspectorPort = await getInputInspectorPortOption(
+          pluginConfig,
+          vitePreviewServer
+        );
         const miniflare2 = new Miniflare(
           getPreviewMiniflareOptions(
             vitePreviewServer,
             workerConfigs,
             pluginConfig.persistState ?? true,
-            pluginConfig.inspectorPort
+            inputInspectorPort
           )
         );
         const middleware = createMiddleware(
@@ -14432,7 +14553,7 @@ function cloudflare2(pluginConfig = {}) {
         for (const match of matches) {
           magicString ??= new MagicString(code);
           const [full, _, modulePath] = match;
-          assert8(
+          assert10(
             modulePath,
             `Unexpected error: module path not found in reference ${full}.`
           );
@@ -14478,17 +14599,21 @@ function cloudflare2(pluginConfig = {}) {
       configEnvironment(name) {
         if (isNodeCompat(getWorkerConfig2(name))) {
           return {
+            build: {
+              rollupOptions: {
+                plugins: [
+                  replace({
+                    "process.env.NODE_ENV": JSON.stringify(
+                      process.env.NODE_ENV ?? "production"
+                    )
+                  })
+                ]
+              }
+            },
             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;
@@ -14512,7 +14637,7 @@ function cloudflare2(pluginConfig = {}) {
           return this.resolve(source, importer, options);
         }
         if (this.environment.mode === "dev") {
-          assert8(
+          assert10(
             this.environment.depsOptimizer,
             "depsOptimizer is required in dev mode"
           );
@@ -14526,11 +14651,35 @@ function cloudflare2(pluginConfig = {}) {
       },
       async transform(code, id) {
         const workerConfig = getWorkerConfig2(this.environment.name);
-        assert8(workerConfig, "Expected a worker config");
+        if (!workerConfig) {
+          return;
+        }
         const resolvedId = await this.resolve(workerConfig.main);
         if (id === resolvedId?.id) {
           return injectGlobalCode(id, code);
         }
+      },
+      async configureServer(viteDevServer) {
+        await Promise.all(
+          Object.values(viteDevServer.environments).flatMap(
+            async (environment) => {
+              const workerConfig = getWorkerConfig2(environment.name);
+              if (isNodeCompat(workerConfig)) {
+                await environment.depsOptimizer?.init();
+                return Array.from(nodeCompatEntries).map((entry) => {
+                  const result = resolveNodeJSImport(entry);
+                  if (result) {
+                    const registration = environment.depsOptimizer?.registerMissingImport(
+                      result.unresolved,
+                      result.resolved
+                    );
+                    return registration?.processing;
+                  }
+                });
+              }
+            }
+          )
+        );
       }
     },
     // Plugin that provides an __debug path for debugging the Cloudflare Workers.
@@ -14540,39 +14689,35 @@ function cloudflare2(pluginConfig = {}) {
       //       the preview middleware here can take precedence
       enforce: "pre",
       configureServer(viteDevServer) {
-        if (resolvedPluginConfig.type === "workers" && resolvedPluginConfig.inspectorPort !== false) {
+        if (resolvedPluginConfig.type === "workers" && pluginConfig.inspectorPort !== false) {
           addDebugToVitePrintUrls(viteDevServer);
         }
         const workerNames = resolvedPluginConfig.type === "assets-only" ? [] : Object.values(resolvedPluginConfig.workers).map(
           (worker) => worker.name
         );
-        viteDevServer.middlewares.use((req, res, next) => {
-          if (req.url === debuggingPath && resolvedPluginConfig.inspectorPort !== false) {
-            const html = getDebugPathHtml(
-              workerNames,
-              resolvedPluginConfig.inspectorPort
-            );
+        viteDevServer.middlewares.use(async (req, res, next) => {
+          const resolvedInspectorPort = await getResolvedInspectorPort(pluginConfig);
+          if (req.url === debuggingPath && resolvedInspectorPort) {
+            const html = getDebugPathHtml(workerNames, resolvedInspectorPort);
             res.setHeader("Content-Type", "text/html");
             return res.end(html);
           }
           next();
         });
       },
-      configurePreviewServer(vitePreviewServer) {
+      async configurePreviewServer(vitePreviewServer) {
         const workerConfigs = getWorkerConfigs(vitePreviewServer.config.root);
         if (workerConfigs.length >= 1 && pluginConfig.inspectorPort !== false) {
           addDebugToVitePrintUrls(vitePreviewServer);
         }
         const workerNames = workerConfigs.map((worker) => {
-          assert8(worker.name, "Expected the Worker to have a name");
+          assert10(worker.name, "Expected the Worker to have a name");
           return worker.name;
         });
-        vitePreviewServer.middlewares.use((req, res, next) => {
-          if (req.url === debuggingPath && pluginConfig.inspectorPort !== false) {
-            const html = getDebugPathHtml(
-              workerNames,
-              pluginConfig.inspectorPort ?? DEFAULT_INSPECTOR_PORT
-            );
+        vitePreviewServer.middlewares.use(async (req, res, next) => {
+          const resolvedInspectorPort = await getResolvedInspectorPort(pluginConfig);
+          if (req.url === debuggingPath && resolvedInspectorPort) {
+            const html = getDebugPathHtml(workerNames, resolvedInspectorPort);
             res.setHeader("Content-Type", "text/html");
             return res.end(html);
           }
@@ -14586,6 +14731,9 @@ function cloudflare2(pluginConfig = {}) {
       apply(_config, env2) {
         return !env2.isPreview;
       },
+      // We must ensure that the `resolveId` hook runs before the built-in ones.
+      // Otherwise we never see the Node.js built-in imports since they get handled by default Vite behavior.
+      enforce: "pre",
       configEnvironment(environmentName) {
         const workerConfig = getWorkerConfig2(environmentName);
         if (workerConfig && !isNodeCompat(workerConfig)) {
@@ -14600,20 +14748,10 @@ function cloudflare2(pluginConfig = {}) {
                         { filter: NODEJS_MODULES_RE },
                         ({ path: path10, importer }) => {
                           const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
-                          assert8(
-                            nodeJsCompatWarnings,
-                            `expected nodeJsCompatWarnings to be defined for Worker "${workerConfig.name}"`
-                          );
-                          nodeJsCompatWarnings.registerImport(path10, importer);
+                          nodeJsCompatWarnings?.registerImport(path10, importer);
                           return { path: path10, external: true };
                         }
                       );
-                      build.onEnd(() => {
-                        const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
-                        if (nodeJsCompatWarnings) {
-                          nodeJsCompatWarnings.renderWarnings();
-                        }
-                      });
                     }
                   }
                 ]
@@ -14622,51 +14760,25 @@ function cloudflare2(pluginConfig = {}) {
           };
         }
       },
-      configureServer(viteDevServer) {
-        for (const environment of Object.values(viteDevServer.environments)) {
-          const workerConfig = getWorkerConfig2(environment.name);
+      configResolved(resolvedViteConfig2) {
+        for (const environmentName of Object.keys(
+          resolvedViteConfig2.environments
+        )) {
+          const workerConfig = getWorkerConfig2(environmentName);
           if (workerConfig && !isNodeCompat(workerConfig)) {
             nodeJsCompatWarningsMap.set(
               workerConfig,
-              new NodeJsCompatWarnings(environment)
+              new NodeJsCompatWarnings(environmentName, resolvedViteConfig2)
             );
           }
         }
       },
-      buildStart() {
-        const workerConfig = getWorkerConfig2(this.environment.name);
-        if (workerConfig && !isNodeCompat(workerConfig)) {
-          nodeJsCompatWarningsMap.set(
-            workerConfig,
-            new NodeJsCompatWarnings(this.environment)
-          );
-        }
-      },
-      buildEnd() {
-        const workerConfig = getWorkerConfig2(this.environment.name);
-        if (workerConfig && !isNodeCompat(workerConfig)) {
-          const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
-          assert8(
-            nodeJsCompatWarnings,
-            `expected nodeJsCompatWarnings to be defined for Worker "${workerConfig.name}"`
-          );
-          nodeJsCompatWarnings.renderWarnings();
-        }
-      },
-      // We must ensure that the `resolveId` hook runs before the built-in ones otherwise we
-      // never see the Node.js built-in imports since they get handled by default Vite behavior.
-      enforce: "pre",
       async resolveId(source, importer) {
         const workerConfig = getWorkerConfig2(this.environment.name);
         if (workerConfig && !isNodeCompat(workerConfig)) {
           const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
-          assert8(
-            nodeJsCompatWarnings,
-            `expected nodeJsCompatWarnings to be defined for Worker "${workerConfig.name}"`
-          );
           if (nodejsBuiltins.has(source)) {
-            nodeJsCompatWarnings.registerImport(source, importer);
-            nodeJsCompatWarnings.renderWarningsOnIdle();
+            nodeJsCompatWarnings?.registerImport(source, importer);
             return {
               id: source,
               external: true
@@ -14677,10 +14789,29 @@ function cloudflare2(pluginConfig = {}) {
     }
   ];
   function getWorkerConfig2(environmentName) {
-    assert8(resolvedPluginConfig, "Expected resolvedPluginConfig to be defined");
+    assert10(resolvedPluginConfig, "Expected resolvedPluginConfig to be defined");
     return resolvedPluginConfig.type !== "assets-only" ? resolvedPluginConfig.workers[environmentName] : void 0;
   }
 }
+async function getInputInspectorPortOption(pluginConfig, viteServer) {
+  const inputInspectorPort = pluginConfig.inspectorPort ?? await getFirstAvailablePort(DEFAULT_INSPECTOR_PORT);
+  if (pluginConfig.inspectorPort === void 0 && inputInspectorPort !== DEFAULT_INSPECTOR_PORT) {
+    viteServer.config.logger.warn(
+      colors2.dim(
+        `Default inspector port ${DEFAULT_INSPECTOR_PORT} not available, using ${inputInspectorPort} instead
+`
+      )
+    );
+  }
+  return inputInspectorPort;
+}
+async function getResolvedInspectorPort(pluginConfig) {
+  if (miniflare && pluginConfig.inspectorPort !== false) {
+    const miniflareInspectorUrl = await miniflare.getInspectorURL();
+    return Number.parseInt(miniflareInspectorUrl.port);
+  }
+  return null;
+}
 function getDotDevDotVarsContent(configPath, cloudflareEnv) {
   const configDir = path9.dirname(configPath);
   const defaultDotDevDotVarsPath = `${configDir}/.dev.vars`;

package/dist/runner-worker/index.js

@@ -1394,13 +1394,6 @@ async function createModuleRunner(env, webSocket, viteRoot) {
     },
     {
       async runInlinedModule(context, transformed, module) {
-        if (module.file.includes("/node_modules") && !module.file.includes("/node_modules/.vite")) {
-          throw new Error(
-            `[Error] Trying to import non-prebundled module (only prebundled modules are allowed): ${module.id}
-
-(have you excluded the module via \`optimizeDeps.exclude\`?)`
-          );
-        }
         const codeDefinition = `'use strict';async (${Object.keys(context).join(
           ","
         )})=>{{`;
@@ -1426,13 +1419,6 @@ async function createModuleRunner(env, webSocket, viteRoot) {
             )
           });
         }
-        if (!additionalModuleRE.test(filepath) && filepath.includes("/node_modules") && !filepath.includes("/node_modules/.vite")) {
-          throw new Error(
-            `[Error] Trying to import non-prebundled module (only prebundled modules are allowed): ${filepath}
-
-(have you externalized the module via \`resolve.external\`?)`
-          );
-        }
         filepath = filepath.replace(/^file:\/\//, "");
         return import(filepath);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudflare/vite-plugin",
-  "version": "0.0.0-910007bce",
+  "version": "0.0.0-930ebb279",
   "description": "Cloudflare plugin for Vite",
   "keywords": [
     "cloudflare",
@@ -34,16 +34,18 @@
   ],
   "dependencies": {
     "@hattip/adapter-node": "^0.0.49",
+    "@rollup/plugin-replace": "^6.0.1",
+    "get-port": "^7.1.0",
     "picocolors": "^1.1.1",
     "tinyglobby": "^0.2.12",
     "unenv": "2.0.0-rc.15",
     "ws": "8.18.0",
-    "@cloudflare/unenv-preset": "0.0.0-910007bce",
-    "miniflare": "0.0.0-910007bce",
-    "wrangler": "0.0.0-910007bce"
+    "miniflare": "0.0.0-930ebb279",
+    "@cloudflare/unenv-preset": "0.0.0-930ebb279",
+    "wrangler": "0.0.0-930ebb279"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20250321.0",
+    "@cloudflare/workers-types": "^4.20250405.0",
     "@types/node": "^22.10.1",
     "@types/ws": "^8.5.13",
     "magic-string": "^0.30.12",
@@ -53,9 +55,9 @@
     "undici": "^5.28.5",
     "vite": "^6.1.0",
     "vitest": "~3.0.8",
-    "@cloudflare/workers-shared": "0.0.0-910007bce",
     "@cloudflare/mock-npm-registry": "0.0.0",
-    "@cloudflare/workers-tsconfig": "0.0.0"
+    "@cloudflare/workers-tsconfig": "0.0.0",
+    "@cloudflare/workers-shared": "0.0.0-930ebb279"
   },
   "peerDependencies": {
     "vite": "^6.1.0",