@cloudflare/vite-plugin 1.15.2 → 1.16.0

package/dist/index.mjs

@@ -2,14 +2,15 @@ import { builtinModules } from "node:module";
 import * as vite from "vite";
 import assert from "node:assert";
 import { CoreHeaders, Log, LogLevel, Miniflare, Request as Request$1, Response as Response$1, coupleWebSocket, getDefaultDevRegistryPath, getNodeCompat, kUnsafeEphemeralUniqueKey } from "miniflare";
-import { maybeStartOrUpdateRemoteProxySession, unstable_convertConfigBindingsToStartWorkerBindings, unstable_getDurableObjectClassNameToUseSQLiteMap, unstable_getMiniflareWorkerOptions, unstable_getVarsForDev, unstable_readConfig } from "wrangler";
-import * as path$2 from "node:path";
+import { maybeStartOrUpdateRemoteProxySession, unstable_convertConfigBindingsToStartWorkerBindings, unstable_defaultWranglerConfig, unstable_getDevCompatibilityDate, unstable_getDurableObjectClassNameToUseSQLiteMap, unstable_getMiniflareWorkerOptions, unstable_getVarsForDev, unstable_getWorkerNameFromProject, unstable_readConfig } from "wrangler";
+import * as path$1 from "node:path";
 import path, { relative } from "node:path";
 import * as util$1 from "node:util";
 import { format, inspect } from "node:util";
 import { createHeaders, createRequest, sendResponse } from "@remix-run/node-fetch-server";
+import { defu } from "defu";
 import * as fs$1 from "node:fs";
-import fs, { readFileSync, realpathSync, statSync } from "node:fs";
+import fs, { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { getCloudflarePreset } from "@cloudflare/unenv-preset";
 import { URL as URL$1, fileURLToPath, pathToFileURL } from "node:url";
 import process$1 from "node:process";
@@ -18,11 +19,8 @@ import { defineEnv } from "unenv";
 import * as fsp from "node:fs/promises";
 import colors from "picocolors";
 import getPort, { portNumbers } from "get-port";
-import { execFileSync, spawn } from "child_process";
-import { existsSync, readFileSync as readFileSync$1, statSync as statSync$1 } from "fs";
-import { spawn as spawn$1 } from "node:child_process";
-import { randomUUID } from "crypto";
-import path$1 from "path";
+import { execFileSync, spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { globSync } from "tinyglobby";
 import { WebSocketServer } from "ws";
 
@@ -69,14 +67,14 @@ function createPlugin(name, pluginFactory) {
 }
 function getOutputDirectory(userConfig, environmentName) {
 	const rootOutputDirectory = userConfig.build?.outDir ?? "dist";
-	return userConfig.environments?.[environmentName]?.build?.outDir ?? path$2.join(rootOutputDirectory, environmentName);
+	return userConfig.environments?.[environmentName]?.build?.outDir ?? path$1.join(rootOutputDirectory, environmentName);
 }
 const postfixRE = /[?#].*$/;
 function cleanUrl(url) {
 	return url.replace(postfixRE, "");
 }
-function withTrailingSlash(path$3) {
-	return path$3.endsWith("/") ? path$3 : `${path$3}/`;
+function withTrailingSlash(path$2) {
+	return path$2.endsWith("/") ? path$2 : `${path$2}/`;
 }
 function createRequestHandler(handler) {
 	return async (req, res, next) => {
@@ -156,6 +154,7 @@ function getInitialWorkerNameToExportTypesMap(resolvedPluginConfig) {
 * Fetches the export types for all Workers and returns them in a Map
 */
 async function getCurrentWorkerNameToExportTypesMap(resolvedPluginConfig, viteDevServer, miniflare) {
+	await viteDevServer.environments.client.pluginContainer.buildStart();
 	const results = await Promise.all([...resolvedPluginConfig.environmentNameToWorkerMap].map(async ([environmentName, worker]) => {
 		debuglog(`Fetching export types for worker "${worker.config.name}"`);
 		const exportTypes = await viteDevServer.environments[environmentName].fetchWorkerExportTypes(miniflare, worker.config);
@@ -357,21 +356,21 @@ const formatInvalidRoutes = (invalidRules) => {
 //#endregion
 //#region src/deploy-config.ts
 function getDeployConfigPath(root) {
-	return path$2.resolve(root, ".wrangler", "deploy", "config.json");
+	return path$1.resolve(root, ".wrangler", "deploy", "config.json");
 }
 function getWorkerConfigs(root) {
 	const deployConfigPath = getDeployConfigPath(root);
 	const deployConfig = JSON.parse(fs$1.readFileSync(deployConfigPath, "utf-8"));
 	return [{ configPath: deployConfig.configPath }, ...deployConfig.auxiliaryWorkers].map(({ configPath }) => {
-		return unstable_readConfig({ config: path$2.resolve(path$2.dirname(deployConfigPath), configPath) });
+		return unstable_readConfig({ config: path$1.resolve(path$1.dirname(deployConfigPath), configPath) });
 	});
 }
 function getRelativePathToWorkerConfig(deployConfigDirectory, root, outputDirectory) {
-	return path$2.relative(deployConfigDirectory, path$2.resolve(root, outputDirectory, "wrangler.json"));
+	return path$1.relative(deployConfigDirectory, path$1.resolve(root, outputDirectory, "wrangler.json"));
 }
 function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
 	const deployConfigPath = getDeployConfigPath(resolvedViteConfig.root);
-	const deployConfigDirectory = path$2.dirname(deployConfigPath);
+	const deployConfigDirectory = path$1.dirname(deployConfigPath);
 	fs$1.mkdirSync(deployConfigDirectory, { recursive: true });
 	if (resolvedPluginConfig.type === "assets-only") {
 		const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
@@ -5387,15 +5386,15 @@ function hasTrailingSlash(input = "", respectQueryAndFragment) {
 function withTrailingSlash$1(input = "", respectQueryAndFragment) {
 	if (!respectQueryAndFragment) return input.endsWith("/") ? input : input + "/";
 	if (hasTrailingSlash(input, true)) return input || "/";
-	let path$3 = input;
+	let path$2 = input;
 	let fragment = "";
 	const fragmentIndex = input.indexOf("#");
 	if (fragmentIndex >= 0) {
-		path$3 = input.slice(0, fragmentIndex);
+		path$2 = input.slice(0, fragmentIndex);
 		fragment = input.slice(fragmentIndex);
-		if (!path$3) return fragment;
+		if (!path$2) return fragment;
 	}
-	const [s0, ...s] = path$3.split("?");
+	const [s0, ...s] = path$2.split("?");
 	return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -5421,8 +5420,8 @@ const isAbsolute = function(p) {
 //#endregion
 //#region ../../node_modules/.pnpm/mlly@1.7.4/node_modules/mlly/dist/index.mjs
 const BUILTIN_MODULES = new Set(builtinModules);
-function normalizeSlash(path$3) {
-	return path$3.replace(/\\/g, "/");
+function normalizeSlash(path$2) {
+	return path$2.replace(/\\/g, "/");
 }
 /**
 * @typedef ErrnoExceptionFields
@@ -5542,8 +5541,8 @@ codes.ERR_INVALID_PACKAGE_CONFIG = createError(
 	* @param {string} [base]
 	* @param {string} [message]
 	*/
-	(path$3, base, message) => {
-		return `Invalid package config ${path$3}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+	(path$2, base, message) => {
+		return `Invalid package config ${path$2}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
 	},
 	Error
 );
@@ -5573,8 +5572,8 @@ codes.ERR_MODULE_NOT_FOUND = createError(
 	* @param {string} base
 	* @param {boolean} [exactUrl]
 	*/
-	(path$3, base, exactUrl = false) => {
-		return `Cannot find ${exactUrl ? "module" : "package"} '${path$3}' imported from ${base}`;
+	(path$2, base, exactUrl = false) => {
+		return `Cannot find ${exactUrl ? "module" : "package"} '${path$2}' imported from ${base}`;
 	},
 	Error
 );
@@ -5612,8 +5611,8 @@ codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
 	* @param {string} extension
 	* @param {string} path
 	*/
-	(extension, path$3) => {
-		return `Unknown file extension "${extension}" for ${path$3}`;
+	(extension, path$2) => {
+		return `Unknown file extension "${extension}" for ${path$2}`;
 	},
 	TypeError
 );
@@ -5982,9 +5981,9 @@ function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
 * @param {string} path
 * @returns {Stats | undefined}
 */
-function tryStatSync(path$3) {
+function tryStatSync(path$2) {
 	try {
-		return statSync(path$3);
+		return statSync(path$2);
 	} catch {}
 }
 /**
@@ -6715,8 +6714,8 @@ function hasNodeJsAls(workerConfig) {
 */
 const nodeJsBuiltins = new Set([...builtinModules, ...builtinModules.map((m) => `node:${m}`)]);
 const NODEJS_MODULES_RE = /* @__PURE__ */ new RegExp(`^(node:)?(${builtinModules.join("|")})$`);
-function isNodeAlsModule(path$3) {
-	return /^(node:)?async_hooks$/.test(path$3);
+function isNodeAlsModule(path$2) {
+	return /^(node:)?async_hooks$/.test(path$2);
 }
 function assertHasNodeJsCompat(nodeJsCompat) {
 	assert(nodeJsCompat, `expected nodeJsCompat to be defined`);
@@ -6747,7 +6746,7 @@ var NodeJsCompatWarnings = class {
 `;
 			this.sources.forEach((importers, source) => {
 				importers.forEach((importer) => {
-					message += ` - "${source}" imported from "${path$2.relative(this.resolvedViteConfig.root, importer)}"\n`;
+					message += ` - "${source}" imported from "${path$1.relative(this.resolvedViteConfig.root, importer)}"\n`;
 				});
 			});
 			this.resolvedViteConfig.logger.warn(message, { timestamp: true });
@@ -6832,7 +6831,7 @@ function getWarningForWorkersConfigs(configs) {
 	if (!("auxiliaryWorkers" in configs) || configs.auxiliaryWorkers.length === 0) {
 		const nonApplicableLines = getWorkerNonApplicableWarnLines(configs.entryWorker, `  - `);
 		if (nonApplicableLines.length === 0) return;
-		const lines$1 = [`\n\n\x1b[43mWARNING\x1b[0m: your worker config${configs.entryWorker.config.configPath ? ` (at \`${path$2.relative("", configs.entryWorker.config.configPath)}\`)` : ""} contains the following configuration options which are ignored since they are not applicable when using Vite:`];
+		const lines$1 = [`\n\n\x1b[43mWARNING\x1b[0m: your worker config${configs.entryWorker.config.configPath ? ` (at \`${path$1.relative("", configs.entryWorker.config.configPath)}\`)` : ""} contains the following configuration options which are ignored since they are not applicable when using Vite:`];
 		nonApplicableLines.forEach((line) => lines$1.push(line));
 		lines$1.push("");
 		return lines$1.join("\n");
@@ -6841,7 +6840,7 @@ function getWarningForWorkersConfigs(configs) {
 	const processWorkerConfig = (workerConfig, isEntryWorker = false) => {
 		const nonApplicableLines = getWorkerNonApplicableWarnLines(workerConfig, `    - `);
 		if (nonApplicableLines.length > 0) {
-			lines.push(`  - (${isEntryWorker ? "entry" : "auxiliary"}) worker${workerConfig.config.name ? ` "${workerConfig.config.name}"` : ""}${workerConfig.config.configPath ? ` (config at \`${path$2.relative("", workerConfig.config.configPath)}\`)` : ""}`);
+			lines.push(`  - (${isEntryWorker ? "entry" : "auxiliary"}) worker${workerConfig.config.name ? ` "${workerConfig.config.name}"` : ""}${workerConfig.config.configPath ? ` (config at \`${path$1.relative("", workerConfig.config.configPath)}\`)` : ""}`);
 			nonApplicableLines.forEach((line) => lines.push(line));
 		}
 	};
@@ -6868,15 +6867,30 @@ function isNotRelevant(configName) {
 	return nonApplicableWorkerConfigs.notRelevant.includes(configName);
 }
 function missingFieldErrorMessage(field, configPath, env) {
-	return `No ${field} field provided in '${configPath}'${env ? ` for '${env}' environment` : ""}`;
+	return `No '${field}' field provided${configPath ? ` in '${configPath}'` : ""}${env ? ` for '${env}' environment` : ""}`;
 }
-function getWorkerConfig(configPath, env, opts) {
+/**
+* Reads and sanitizes a worker config from a wrangler config file.
+*/
+function readWorkerConfigFromFile(configPath, env, opts) {
 	if (opts?.visitedConfigPaths?.has(configPath)) throw new Error(`Duplicate Wrangler config path found: ${configPath}`);
-	const { raw, config, nonApplicable } = readWorkerConfig(configPath, env);
+	const result = readWorkerConfig(configPath, env);
 	opts?.visitedConfigPaths?.add(configPath);
-	if (!config.name) throw new Error(missingFieldErrorMessage(`'name'`, configPath, env));
-	if (!config.topLevelName) throw new Error(missingFieldErrorMessage(`top-level 'name'`, configPath, env));
-	if (!config.compatibility_date) throw new Error(missingFieldErrorMessage(`'compatibility_date`, configPath, env));
+	return result;
+}
+/**
+* Validates required fields and determines whether the config represents
+* an assets-only worker or a worker with server logic.
+*
+* @param config The sanitized worker config (after merging defaults, file config, and config())
+* @param raw The raw config (before sanitization)
+* @param nonApplicable The non-applicable config map
+* @param opts Options for validation
+*/
+function resolveWorkerType(config, raw, nonApplicable, opts) {
+	if (!config.name) throw new Error(missingFieldErrorMessage("name", opts?.configPath, opts?.env));
+	if (!config.topLevelName) throw new Error(missingFieldErrorMessage("top-level name", opts?.configPath, opts?.env));
+	if (!config.compatibility_date) throw new Error(missingFieldErrorMessage("compatibility_date", opts?.configPath, opts?.env));
 	const requiredFields = {
 		topLevelName: config.topLevelName,
 		name: config.name,
@@ -6891,14 +6905,15 @@ function getWorkerConfig(configPath, env, opts) {
 		},
 		nonApplicable
 	};
-	if (!config.main) throw new Error(missingFieldErrorMessage(`'main'`, configPath, env));
+	if (!config.main) throw new Error(missingFieldErrorMessage("main", opts?.configPath, opts?.env));
+	const resolvedMain = maybeResolveMain(config.main, opts?.configPath, opts?.root);
 	return {
 		type: "worker",
 		raw,
 		config: {
 			...config,
 			...requiredFields,
-			main: maybeResolveMain(config.main, configPath)
+			main: resolvedMain
 		},
 		nonApplicable
 	};
@@ -6916,9 +6931,11 @@ const ENTRY_MODULE_EXTENSIONS = [
 * Else `main` is returned as is so that it can be resolved by Vite.
 * This enables resolving entry modules relative to the Worker config while also supporting virtual modules and package exports.
 */
-function maybeResolveMain(main, configPath) {
+function maybeResolveMain(main, configPath, root) {
 	if (!ENTRY_MODULE_EXTENSIONS.some((extension) => main.endsWith(extension))) return main;
-	const resolvedMain = path$2.resolve(path$2.dirname(configPath), main);
+	const baseDir = configPath ? path$1.dirname(configPath) : root;
+	if (!baseDir) return main;
+	const resolvedMain = path$1.resolve(baseDir, main);
 	if (!fs$1.existsSync(resolvedMain)) throw new Error(`The provided Wrangler config main field (${resolvedMain}) doesn't point to an existing file`);
 	return resolvedMain;
 }
@@ -6929,30 +6946,28 @@ function maybeResolveMain(main, configPath) {
 * @param root the root of the vite project
 * @param requestedConfigPath the requested config path, if any
 * @param isForAuxiliaryWorker whether the config path is being requested for an auxiliary worker
-* @returns a valid path to a config file
+* @returns a valid path to a config file, or undefined for entry workers when no config is found
 */
 function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliaryWorker = false) {
 	if (requestedConfigPath) {
-		const configPath$1 = path$2.resolve(root, requestedConfigPath);
-		const errorMessagePrefix = `The provided configPath (${configPath$1})${isForAuxiliaryWorker ? " requested for one of your auxiliary workers" : ""}`;
-		const fileExtension = path$2.extname(configPath$1).slice(1);
+		const configPath = path$1.resolve(root, requestedConfigPath);
+		const errorMessagePrefix = `The provided configPath (${configPath})${isForAuxiliaryWorker ? " requested for one of your auxiliary workers" : ""}`;
+		const fileExtension = path$1.extname(configPath).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 = fs$1.statSync(configPath$1, { throwIfNoEntry: false });
+		const mainStat = fs$1.statSync(configPath, { 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 configPath$1;
+		return configPath;
 	}
-	assert(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;
+	if (isForAuxiliaryWorker) return;
+	return findWranglerConfig(root);
 }
 function findWranglerConfig(root) {
 	for (const extension of allowedWranglerConfigExtensions) {
-		const configPath = path$2.join(root, `wrangler.${extension}`);
+		const configPath = path$1.join(root, `wrangler.${extension}`);
 		if (fs$1.existsSync(configPath)) return configPath;
 	}
 }
@@ -6964,13 +6979,45 @@ const allowedWranglerConfigExtensions = [
 
 //#endregion
 //#region src/plugin-config.ts
+function customizeWorkerConfig(resolvedConfig, config) {
+	const configResult = typeof config === "function" ? config(resolvedConfig) : config;
+	if (configResult) return defu(configResult, resolvedConfig);
+	return resolvedConfig;
+}
+/**
+* Resolves the config for a single worker, applying defaults, file config, and config().
+*/
+function resolveWorkerConfig({ configPath, env, config, visitedConfigPaths, isEntryWorker, root }) {
+	let workerConfig;
+	let raw;
+	let nonApplicable;
+	if (configPath) ({raw, config: workerConfig, nonApplicable} = readWorkerConfigFromFile(configPath, env, { visitedConfigPaths }));
+	else {
+		workerConfig = { ...unstable_defaultWranglerConfig };
+		raw = structuredClone(workerConfig);
+		nonApplicable = {
+			replacedByVite: /* @__PURE__ */ new Set(),
+			notRelevant: /* @__PURE__ */ new Set()
+		};
+	}
+	workerConfig = customizeWorkerConfig(workerConfig, config);
+	workerConfig.compatibility_date ??= unstable_getDevCompatibilityDate(void 0);
+	if (isEntryWorker) workerConfig.name ??= unstable_getWorkerNameFromProject(root);
+	workerConfig.topLevelName ??= workerConfig.name;
+	return resolveWorkerType(workerConfig, raw, nonApplicable, {
+		isEntryWorker,
+		configPath,
+		root,
+		env
+	});
+}
 function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 	const shared = {
 		persistState: pluginConfig.persistState ?? true,
 		inspectorPort: pluginConfig.inspectorPort,
 		experimental: pluginConfig.experimental ?? {}
 	};
-	const root = userConfig.root ? path$2.resolve(userConfig.root) : process.cwd();
+	const root = userConfig.root ? path$1.resolve(userConfig.root) : process.cwd();
 	const prefixedEnv = vite.loadEnv(viteEnv.mode, root, ["CLOUDFLARE_", "WRANGLER_HYPERDRIVE_LOCAL_CONNECTION_STRING_"]);
 	Object.assign(process.env, prefixedEnv);
 	if (viteEnv.isPreview) return {
@@ -6981,7 +7028,11 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 	};
 	const configPaths = /* @__PURE__ */ new Set();
 	const cloudflareEnv = prefixedEnv.CLOUDFLARE_ENV;
-	const entryWorkerResolvedConfig = getWorkerConfig(getValidatedWranglerConfigPath(root, pluginConfig.configPath), cloudflareEnv, {
+	const entryWorkerResolvedConfig = resolveWorkerConfig({
+		root,
+		configPath: getValidatedWranglerConfigPath(root, pluginConfig.configPath),
+		env: prefixedEnv.CLOUDFLARE_ENV,
+		config: pluginConfig.config,
 		visitedConfigPaths: configPaths,
 		isEntryWorker: true
 	});
@@ -7001,13 +7052,18 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 	const environmentNameToWorkerMap = new Map([[entryWorkerEnvironmentName, resolveWorker(entryWorkerConfig)]]);
 	const auxiliaryWorkersResolvedConfigs = [];
 	for (const auxiliaryWorker of pluginConfig.auxiliaryWorkers ?? []) {
-		const workerResolvedConfig = getWorkerConfig(getValidatedWranglerConfigPath(root, auxiliaryWorker.configPath, true), cloudflareEnv, { visitedConfigPaths: configPaths });
+		const workerResolvedConfig = resolveWorkerConfig({
+			root,
+			configPath: getValidatedWranglerConfigPath(root, auxiliaryWorker.configPath, true),
+			env: cloudflareEnv,
+			config: "config" in auxiliaryWorker ? auxiliaryWorker.config : void 0,
+			visitedConfigPaths: configPaths,
+			isEntryWorker: false
+		});
 		auxiliaryWorkersResolvedConfigs.push(workerResolvedConfig);
-		assert(workerResolvedConfig.type === "worker", "Unexpected error: received AssetsOnlyResult with auxiliary workers.");
-		const workerConfig = workerResolvedConfig.config;
-		const workerEnvironmentName = auxiliaryWorker.viteEnvironment?.name ?? workerNameToEnvironmentName(workerConfig.topLevelName);
+		const workerEnvironmentName = auxiliaryWorker.viteEnvironment?.name ?? workerNameToEnvironmentName(workerResolvedConfig.config.topLevelName);
 		if (environmentNameToWorkerMap.has(workerEnvironmentName)) throw new Error(`Duplicate Vite environment name found: ${workerEnvironmentName}`);
-		environmentNameToWorkerMap.set(workerEnvironmentName, resolveWorker(workerConfig));
+		environmentNameToWorkerMap.set(workerEnvironmentName, resolveWorker(workerResolvedConfig.config));
 	}
 	return {
 		...shared,
@@ -8078,12 +8134,12 @@ const additionalModulesPlugin = createPlugin("additional-modules", (ctx) => {
 				}
 				const referenceId = this.emitFile({
 					type: "asset",
-					name: path$2.basename(modulePath),
+					name: path$1.basename(modulePath),
 					originalFileName: modulePath,
 					source
 				});
 				const emittedFileName = this.getFileName(referenceId);
-				const relativePath = vite.normalizePath(path$2.relative(path$2.dirname(chunk.fileName), emittedFileName));
+				const relativePath = vite.normalizePath(path$1.relative(path$1.dirname(chunk.fileName), emittedFileName));
 				const importPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
 				magicString.update(match.index, match.index + full.length, importPath);
 			}
@@ -8194,9 +8250,9 @@ function constructHeaders({ headers, headersFile, logger }) {
 
 //#endregion
 //#region ../workers-shared/utils/configuration/validateURL.ts
-const extractPathname = (path$3 = "/", includeSearch, includeHash) => {
-	if (!path$3.startsWith("/")) path$3 = `/${path$3}`;
-	const url = new URL(`//${path$3}`, "relative://");
+const extractPathname = (path$2 = "/", includeSearch, includeHash) => {
+	if (!path$2.startsWith("/")) path$2 = `/${path$2}`;
+	const url = new URL(`//${path$2}`, "relative://");
 	return `${url.pathname}${includeSearch ? url.search : ""}${includeHash ? url.hash : ""}`;
 };
 const URL_REGEX = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/;
@@ -8253,7 +8309,7 @@ function parseHeaders(input, { maxRules = MAX_HEADER_RULES, maxLineLength = MAX_
 				lineNumber: i$1 + 1,
 				message: "No headers specified"
 			});
-			const [path$3, pathError] = validateUrl(line, false, true);
+			const [path$2, pathError] = validateUrl(line, false, true);
 			if (pathError) {
 				invalid.push({
 					line,
@@ -8264,7 +8320,7 @@ function parseHeaders(input, { maxRules = MAX_HEADER_RULES, maxLineLength = MAX_
 				continue;
 			}
 			rule = {
-				path: path$3,
+				path: path$2,
 				line,
 				headers: {},
 				unsetHeaders: []
@@ -8552,13 +8608,13 @@ var require_ignore = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/igno
 	const throwError = (message, Ctor) => {
 		throw new Ctor(message);
 	};
-	const checkPath = (path$3, originalPath, doThrow) => {
-		if (!isString$1(path$3)) return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
-		if (!path$3) return doThrow(`path must not be empty`, TypeError);
-		if (checkPath.isNotRelative(path$3)) return doThrow(`path should be a \`path.relative()\`d string, but got "${originalPath}"`, RangeError);
+	const checkPath = (path$2, originalPath, doThrow) => {
+		if (!isString$1(path$2)) return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
+		if (!path$2) return doThrow(`path must not be empty`, TypeError);
+		if (checkPath.isNotRelative(path$2)) return doThrow(`path should be a \`path.relative()\`d string, but got "${originalPath}"`, RangeError);
 		return true;
 	};
-	const isNotRelative = (path$3) => REGEX_TEST_INVALID_PATH.test(path$3);
+	const isNotRelative = (path$2) => REGEX_TEST_INVALID_PATH.test(path$2);
 	checkPath.isNotRelative = isNotRelative;
 	checkPath.convert = (p) => p;
 	var Ignore = class {
@@ -8594,13 +8650,13 @@ var require_ignore = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/igno
 		addPattern(pattern) {
 			return this.add(pattern);
 		}
-		_testOne(path$3, checkUnignored) {
+		_testOne(path$2, checkUnignored) {
 			let ignored = false;
 			let unignored = false;
 			this._rules.forEach((rule) => {
 				const { negative } = rule;
 				if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) return;
-				if (rule.regex.test(path$3)) {
+				if (rule.regex.test(path$2)) {
 					ignored = !negative;
 					unignored = negative;
 				}
@@ -8611,33 +8667,33 @@ var require_ignore = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/igno
 			};
 		}
 		_test(originalPath, cache$1, checkUnignored, slices) {
-			const path$3 = originalPath && checkPath.convert(originalPath);
-			checkPath(path$3, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
-			return this._t(path$3, cache$1, checkUnignored, slices);
+			const path$2 = originalPath && checkPath.convert(originalPath);
+			checkPath(path$2, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
+			return this._t(path$2, cache$1, checkUnignored, slices);
 		}
-		_t(path$3, cache$1, checkUnignored, slices) {
-			if (path$3 in cache$1) return cache$1[path$3];
-			if (!slices) slices = path$3.split(SLASH);
+		_t(path$2, cache$1, checkUnignored, slices) {
+			if (path$2 in cache$1) return cache$1[path$2];
+			if (!slices) slices = path$2.split(SLASH);
 			slices.pop();
-			if (!slices.length) return cache$1[path$3] = this._testOne(path$3, checkUnignored);
+			if (!slices.length) return cache$1[path$2] = this._testOne(path$2, checkUnignored);
 			const parent = this._t(slices.join(SLASH) + SLASH, cache$1, checkUnignored, slices);
-			return cache$1[path$3] = parent.ignored ? parent : this._testOne(path$3, checkUnignored);
+			return cache$1[path$2] = parent.ignored ? parent : this._testOne(path$2, checkUnignored);
 		}
-		ignores(path$3) {
-			return this._test(path$3, this._ignoreCache, false).ignored;
+		ignores(path$2) {
+			return this._test(path$2, this._ignoreCache, false).ignored;
 		}
 		createFilter() {
-			return (path$3) => !this.ignores(path$3);
+			return (path$2) => !this.ignores(path$2);
 		}
 		filter(paths) {
 			return makeArray(paths).filter(this.createFilter());
 		}
-		test(path$3) {
-			return this._test(path$3, this._testCache, true);
+		test(path$2) {
+			return this._test(path$2, this._testCache, true);
 		}
 	};
 	const factory = (options) => new Ignore(options);
-	const isPathValid = (path$3) => checkPath(path$3 && checkPath.convert(path$3), path$3, RETURN_FALSE);
+	const isPathValid = (path$2) => checkPath(path$2 && checkPath.convert(path$2), path$2, RETURN_FALSE);
 	factory.isPathValid = isPathValid;
 	factory.default = factory;
 	module.exports = factory;
@@ -8646,7 +8702,7 @@ var require_ignore = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/igno
 		const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
 		checkPath.convert = makePosix;
 		const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-		checkPath.isNotRelative = (path$3) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path$3) || isNotRelative(path$3);
+		checkPath.isNotRelative = (path$2) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path$2) || isNotRelative(path$2);
 	}
 }) });
 
@@ -10001,11 +10057,11 @@ var Mime = class {
 		}
 		return this;
 	}
-	getType(path$3) {
-		if (typeof path$3 !== "string") return null;
-		const last = path$3.replace(/^.*[/\\]/s, "").toLowerCase();
+	getType(path$2) {
+		if (typeof path$2 !== "string") return null;
+		const last = path$2.replace(/^.*[/\\]/s, "").toLowerCase();
 		const ext = last.replace(/^.*\./s, "").toLowerCase();
-		const hasPath = last.length < path$3.length;
+		const hasPath = last.length < path$2.length;
 		if (!(ext.length < last.length - 1) && hasPath) return null;
 		return __classPrivateFieldGet(this, _Mime_extensionToType, "f").get(ext) ?? null;
 	}
@@ -10327,8 +10383,8 @@ function getErrorMap() {
 	return overrideErrorMap;
 }
 const makeIssue = (params) => {
-	const { data: data$1, path: path$3, errorMaps, issueData } = params;
-	const fullPath = [...path$3, ...issueData.path || []];
+	const { data: data$1, path: path$2, errorMaps, issueData } = params;
+	const fullPath = [...path$2, ...issueData.path || []];
 	const fullIssue = {
 		...issueData,
 		path: fullPath
@@ -10425,11 +10481,11 @@ var errorUtil;
 	errorUtil$1.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
 })(errorUtil || (errorUtil = {}));
 var ParseInputLazyPath = class {
-	constructor(parent, value, path$3, key) {
+	constructor(parent, value, path$2, key) {
 		this._cachedPath = [];
 		this.parent = parent;
 		this.data = value;
-		this._path = path$3;
+		this._path = path$2;
 		this._key = key;
 	}
 	get path() {
@@ -13591,10 +13647,10 @@ function getAssetsConfig(resolvedPluginConfig, entryWorkerConfig, resolvedConfig
 	};
 }
 function getRedirectsConfigPath(config) {
-	return path$2.join(config.publicDir, REDIRECTS_FILENAME);
+	return path$1.join(config.publicDir, REDIRECTS_FILENAME);
 }
 function getHeadersConfigPath(config) {
-	return path$2.join(config.publicDir, HEADERS_FILENAME);
+	return path$1.join(config.publicDir, HEADERS_FILENAME);
 }
 
 //#endregion
@@ -13711,7 +13767,7 @@ function createBuildApp(resolvedPluginConfig) {
 	return async (builder) => {
 		const clientEnvironment = builder.environments.client;
 		assert(clientEnvironment, `No "client" environment`);
-		const defaultHtmlPath = path$2.resolve(builder.config.root, "index.html");
+		const defaultHtmlPath = path$1.resolve(builder.config.root, "index.html");
 		const hasClientEntry = clientEnvironment.config.build.rollupOptions.input || fs$1.existsSync(defaultHtmlPath);
 		if (resolvedPluginConfig.type === "assets-only") {
 			if (hasClientEntry) await builder.build(clientEnvironment);
@@ -13727,32 +13783,32 @@ function createBuildApp(resolvedPluginConfig) {
 		const { entryWorkerEnvironmentName } = resolvedPluginConfig;
 		const entryWorkerEnvironment = builder.environments[entryWorkerEnvironmentName];
 		assert(entryWorkerEnvironment, `No "${entryWorkerEnvironmentName}" environment`);
-		const entryWorkerBuildDirectory = path$2.resolve(builder.config.root, entryWorkerEnvironment.config.build.outDir);
+		const entryWorkerBuildDirectory = path$1.resolve(builder.config.root, entryWorkerEnvironment.config.build.outDir);
 		const importedAssetPaths = getImportedAssetPaths(loadViteManifest(entryWorkerBuildDirectory));
 		if (hasClientEntry) await builder.build(clientEnvironment);
 		else if (importedAssetPaths.size || getHasPublicAssets(builder.config)) await fallbackBuild(builder, clientEnvironment);
 		else {
-			const entryWorkerConfigPath = path$2.join(entryWorkerBuildDirectory, "wrangler.json");
+			const entryWorkerConfigPath = path$1.join(entryWorkerBuildDirectory, "wrangler.json");
 			const workerConfig = JSON.parse(fs$1.readFileSync(entryWorkerConfigPath, "utf-8"));
 			workerConfig.assets = void 0;
 			fs$1.writeFileSync(entryWorkerConfigPath, JSON.stringify(workerConfig));
 			return;
 		}
-		const clientBuildDirectory = path$2.resolve(builder.config.root, clientEnvironment.config.build.outDir);
+		const clientBuildDirectory = path$1.resolve(builder.config.root, clientEnvironment.config.build.outDir);
 		const movedAssetPaths = [];
 		for (const assetPath of importedAssetPaths) {
-			const src = path$2.join(entryWorkerBuildDirectory, assetPath);
-			const dest = path$2.join(clientBuildDirectory, assetPath);
+			const src = path$1.join(entryWorkerBuildDirectory, assetPath);
+			const dest = path$1.join(clientBuildDirectory, assetPath);
 			if (!fs$1.existsSync(src)) continue;
 			if (fs$1.existsSync(dest)) fs$1.unlinkSync(src);
 			else {
-				const destDir = path$2.dirname(dest);
+				const destDir = path$1.dirname(dest);
 				fs$1.mkdirSync(destDir, { recursive: true });
 				fs$1.renameSync(src, dest);
 				movedAssetPaths.push(dest);
 			}
 		}
-		if (movedAssetPaths.length) builder.config.logger.info([`${colors.green("✓")} ${movedAssetPaths.length} asset${movedAssetPaths.length > 1 ? "s" : ""} moved from "${entryWorkerEnvironmentName}" to "client" build output.`, ...movedAssetPaths.map((assetPath) => colors.dim(path$2.relative(builder.config.root, assetPath)))].join("\n"));
+		if (movedAssetPaths.length) builder.config.logger.info([`${colors.green("✓")} ${movedAssetPaths.length} asset${movedAssetPaths.length > 1 ? "s" : ""} moved from "${entryWorkerEnvironmentName}" to "client" build output.`, ...movedAssetPaths.map((assetPath) => colors.dim(path$1.relative(builder.config.root, assetPath)))].join("\n"));
 	};
 }
 function getHasPublicAssets({ publicDir }) {
@@ -13769,11 +13825,11 @@ async function fallbackBuild(builder, environment) {
 		output: { entryFileNames: CLIENT_FALLBACK_ENTRY_NAME }
 	};
 	await builder.build(environment);
-	const fallbackEntryPath = path$2.resolve(builder.config.root, environment.config.build.outDir, CLIENT_FALLBACK_ENTRY_NAME);
+	const fallbackEntryPath = path$1.resolve(builder.config.root, environment.config.build.outDir, CLIENT_FALLBACK_ENTRY_NAME);
 	fs$1.unlinkSync(fallbackEntryPath);
 }
 function loadViteManifest(directory) {
-	const contents = fs$1.readFileSync(path$2.resolve(directory, ".vite", "manifest.json"), "utf-8");
+	const contents = fs$1.readFileSync(path$1.resolve(directory, ".vite", "manifest.json"), "utf-8");
 	return JSON.parse(contents);
 }
 function getImportedAssetPaths(viteManifest) {
@@ -13975,12 +14031,12 @@ function getLocalDevVarsForPreview(configPath, cloudflareEnv) {
 */
 function hasLocalDevVarsFileChanged({ configPaths, cloudflareEnv }, changedFilePath) {
 	return [...configPaths].some((configPath) => {
-		const configDir = path$2.dirname(configPath);
+		const configDir = path$1.dirname(configPath);
 		return [
 			".dev.vars",
 			".env",
 			...cloudflareEnv ? [`.dev.vars.${cloudflareEnv}`, `.env.${cloudflareEnv}`] : []
-		].some((localDevFile) => changedFilePath === path$2.join(configDir, localDevFile));
+		].some((localDevFile) => changedFilePath === path$1.join(configDir, localDevFile));
 	});
 }
 
@@ -14550,11 +14606,11 @@ const getQueryString = (params) => {
 };
 const getUrl = (config, options) => {
 	const encoder = config.ENCODE_PATH || encodeURI;
-	const path$3 = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+	const path$2 = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
 		if (options.path?.hasOwnProperty(group)) return encoder(String(options.path[group]));
 		return substring;
 	});
-	const url = `${config.BASE}${path$3}`;
+	const url = `${config.BASE}${path$2}`;
 	if (options.query) return `${url}${getQueryString(options.query)}`;
 	return url;
 };
@@ -14895,7 +14951,7 @@ async function constructBuildCommand(options, logger) {
 	];
 	if (options.args) for (const arg in options.args) buildCmd.push("--build-arg", `${arg}=${options.args[arg]}`);
 	if (options.setNetworkToHost) buildCmd.push("--network", "host");
-	const dockerfile = readFileSync$1(options.pathToDockerfile, "utf-8");
+	const dockerfile = readFileSync(options.pathToDockerfile, "utf-8");
 	buildCmd.push("-f", "-");
 	buildCmd.push(options.buildContext);
 	logger?.debug(`Building image with command: ${buildCmd.join(" ")}`);
@@ -14971,7 +15027,7 @@ async function dockerLoginImageRegistry(pathToDocker, domain) {
 		expiration_minutes: 15,
 		permissions: [ImageRegistryPermissions.PUSH, ImageRegistryPermissions.PULL]
 	});
-	const child = spawn$1(pathToDocker, [
+	const child = spawn(pathToDocker, [
 		"login",
 		"--password-stdin",
 		"--username",
@@ -15000,6 +15056,9 @@ const MF_DEV_CONTAINER_PREFIX = "cloudflare-dev";
 
 //#endregion
 //#region ../containers-shared/src/knobs.ts
+const getCloudflareContainerRegistry = () => {
+	return process.env.CLOUDFLARE_CONTAINER_REGISTRY ?? (process.env.WRANGLER_API_ENVIRONMENT === "staging" ? "staging.registry.cloudflare.com" : "registry.cloudflare.com");
+};
 /** Prefixes with the cloudflare-dev namespace. The name should be the container's DO classname, and the tag a build uuid. */
 const getDevContainerImageName = (name, tag) => {
 	return `${MF_DEV_CONTAINER_PREFIX}/${name.toLowerCase()}:${tag}`;
@@ -15097,12 +15156,12 @@ const verifyDockerInstalled = async (dockerPath, isDev = true) => {
 Other container tooling that is compatible with the Docker CLI and engine may work, but is not yet guaranteed to do so. You can specify an executable with the environment variable WRANGLER_DOCKER_BIN and a socket with DOCKER_HOST.${isDev ? "\nTo suppress this error if you do not intend on triggering any container instances, set dev.enable_containers to false in your Wrangler config or passing in --enable-containers=false." : ""}`);
 };
 function isDir(inputPath) {
-	return statSync$1(inputPath).isDirectory();
+	return statSync(inputPath).isDirectory();
 }
 /** returns true if it is a dockerfile, false if it is a registry link, throws if neither */
 const isDockerfile = (image, configPath) => {
-	const baseDir = configPath ? path$1.dirname(configPath) : process.cwd();
-	const maybeDockerfile = path$1.resolve(baseDir, image);
+	const baseDir = configPath ? path.dirname(configPath) : process.cwd();
+	const maybeDockerfile = path.resolve(baseDir, image);
 	if (existsSync(maybeDockerfile)) {
 		if (isDir(maybeDockerfile)) throw new UserError(`${image} is a directory, you should specify a path to the Dockerfile`);
 		return true;
@@ -15233,11 +15292,33 @@ async function cleanupDuplicateImageTags(dockerPath, imageTag) {
 	} catch {}
 }
 
+//#endregion
+//#region ../containers-shared/src/client/models/ExternalRegistryKind.ts
+/* istanbul ignore file */
+/**
+* The type of external registry that is being configured.
+*/
+let ExternalRegistryKind = /* @__PURE__ */ function(ExternalRegistryKind$1) {
+	ExternalRegistryKind$1["ECR"] = "ECR";
+	return ExternalRegistryKind$1;
+}({});
+
 //#endregion
 //#region ../containers-shared/src/images.ts
-async function pullImage(dockerPath, options) {
+async function pullImage(dockerPath, options, logger, isVite) {
 	const domain = new URL(`http://${options.image_uri}`).hostname;
-	await dockerLoginImageRegistry(dockerPath, domain);
+	const isExternalRegistry = domain !== getCloudflareContainerRegistry();
+	try {
+		await dockerLoginImageRegistry(dockerPath, domain);
+	} catch (e) {
+		if (!isExternalRegistry) {
+			if (isVite) throw new UserError(`Using images from the Cloudflare-managed registry is not currently supported with the Vite plugin.
+You should use a Dockerfile or a supported external registry and authenticate to that registry separately using \`docker login\` or similar.
+Supported external registries are currently: ${Object.values(ExternalRegistryKind).join(", ")}.`);
+			throw e;
+		}
+		logger?.warn("Unable to retrieve configured registry credentials from Cloudflare.\nUnless this is a public image, you will need to run `wrangler containers registries configure` before deploying.\nAttempting to pull image anyway...");
+	}
 	const pull = runDockerCmd(dockerPath, [
 		"pull",
 		options.image_uri,
@@ -15285,7 +15366,7 @@ async function prepareContainerImagesForDev(args) {
 			await build.ready;
 			onContainerImagePreparationEnd({ containerOptions: options });
 		} else {
-			const pull = await pullImage(dockerPath, options);
+			const pull = await pullImage(dockerPath, options, args.logger, args.isVite);
 			onContainerImagePreparationStart({
 				containerOptions: options,
 				abort: () => {
@@ -15369,7 +15450,7 @@ const INTERNAL_WORKERS_COMPATIBILITY_DATE = "2024-10-04";
 const PUBLIC_DIR_PREFIX = "/__vite_public_dir__";
 function getPersistenceRoot(root, persistState) {
 	if (persistState === false) return;
-	return path$2.resolve(root, typeof persistState === "object" ? persistState.path : ".wrangler/state", "v3");
+	return path$1.resolve(root, typeof persistState === "object" ? persistState.path : ".wrangler/state", "v3");
 }
 const miniflareModulesRoot = process.platform === "win32" ? "Z:\\" : "/";
 const ROUTER_WORKER_PATH = "./workers/router-worker.js";
@@ -15377,15 +15458,6 @@ const ASSET_WORKER_PATH = "./workers/asset-worker.js";
 const VITE_PROXY_WORKER_PATH = "./workers/vite-proxy-worker.js";
 const RUNNER_PATH = "./workers/runner-worker.js";
 const WRAPPER_PATH = "__VITE_WORKER_ENTRY__";
-function logUnknownTails(tails, userWorkers, log) {
-	for (const tailService of tails ?? []) {
-		let name;
-		if (typeof tailService === "string") name = tailService;
-		else if (typeof tailService === "object" && "name" in tailService && typeof tailService.name === "string") name = tailService.name;
-		else continue;
-		if (!userWorkers.some((w) => w.name === name)) log(colors.dim(colors.yellow(`Tail consumer "${name}" was not found in your config. Make sure you add it to the config or run it in another dev session if you'd like to simulate receiving tail events locally.`)));
-	}
-}
 /** Map that maps worker configPaths to their existing remote proxy session data (if any) */
 const remoteProxySessionsDataMap = /* @__PURE__ */ new Map();
 async function getDevMiniflareOptions(ctx, viteDevServer) {
@@ -15399,7 +15471,7 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 			modulesRoot: miniflareModulesRoot,
 			modules: [{
 				type: "ESModule",
-				path: path$2.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
+				path: path$1.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
 				contents: fs$1.readFileSync(fileURLToPath(new URL(ROUTER_WORKER_PATH, import.meta.url)))
 			}],
 			bindings: { CONFIG: { has_user_worker: resolvedPluginConfig.type === "workers" } },
@@ -15414,7 +15486,7 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 			modulesRoot: miniflareModulesRoot,
 			modules: [{
 				type: "ESModule",
-				path: path$2.join(miniflareModulesRoot, ASSET_WORKER_PATH),
+				path: path$1.join(miniflareModulesRoot, ASSET_WORKER_PATH),
 				contents: fs$1.readFileSync(fileURLToPath(new URL(ASSET_WORKER_PATH, import.meta.url)))
 			}],
 			bindings: {
@@ -15429,8 +15501,8 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 						const publicDirInRoot = publicDir.startsWith(withTrailingSlash(root));
 						const publicPath = withTrailingSlash(publicDir.slice(root.length));
 						if (publicDirInRoot && pathname.startsWith(publicPath)) return Response$1.json(null);
-						const publicDirFilePath = path$2.join(publicDir, pathname);
-						const rootDirFilePath = path$2.join(root, pathname);
+						const publicDirFilePath = path$1.join(publicDir, pathname);
+						const rootDirFilePath = path$1.join(root, pathname);
 						for (const resolvedPath of [publicDirFilePath, rootDirFilePath]) try {
 							if ((await fsp.stat(resolvedPath)).isFile()) return Response$1.json(resolvedPath === publicDirFilePath ? `${PUBLIC_DIR_PREFIX}${pathname}` : pathname);
 						} catch (error) {}
@@ -15441,7 +15513,7 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 					const { pathname } = new URL(request$1.url);
 					const { root, publicDir } = resolvedViteConfig;
 					const isInPublicDir = pathname.startsWith(PUBLIC_DIR_PREFIX);
-					const resolvedPath = isInPublicDir ? path$2.join(publicDir, pathname.slice(20)) : path$2.join(root, pathname);
+					const resolvedPath = isInPublicDir ? path$1.join(publicDir, pathname.slice(20)) : path$1.join(root, pathname);
 					try {
 						let html = await fsp.readFile(resolvedPath, "utf-8");
 						if (!isInPublicDir) html = await viteDevServer.transformIndexHtml(resolvedPath, html);
@@ -15458,7 +15530,7 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 			modulesRoot: miniflareModulesRoot,
 			modules: [{
 				type: "ESModule",
-				path: path$2.join(miniflareModulesRoot, VITE_PROXY_WORKER_PATH),
+				path: path$1.join(miniflareModulesRoot, VITE_PROXY_WORKER_PATH),
 				contents: fs$1.readFileSync(fileURLToPath(new URL(VITE_PROXY_WORKER_PATH, import.meta.url)))
 			}],
 			serviceBindings: {
@@ -15473,7 +15545,8 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 		const preExistingRemoteProxySession = worker.config.configPath ? remoteProxySessionsDataMap.get(worker.config.configPath) : void 0;
 		const remoteProxySessionData = !resolvedPluginConfig.remoteBindings ? null : await maybeStartOrUpdateRemoteProxySession({
 			name: worker.config.name,
-			bindings: bindings ?? {}
+			bindings: bindings ?? {},
+			account_id: worker.config.account_id
 		}, preExistingRemoteProxySession ?? null);
 		if (worker.config.configPath && remoteProxySessionData) remoteProxySessionsDataMap.set(worker.config.configPath, remoteProxySessionData);
 		let containerBuildId;
@@ -15488,27 +15561,45 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 			});
 			for (const option of options ?? []) containerTagToOptionsMap.set(option.image_tag, option);
 		}
-		const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions({
+		const { externalWorkers: externalWorkers$1, workerOptions } = unstable_getMiniflareWorkerOptions({
 			...worker.config,
 			assets: void 0
 		}, resolvedPluginConfig.cloudflareEnv, {
 			remoteProxyConnectionString: remoteProxySessionData?.session?.remoteProxyConnectionString,
 			containerBuildId
 		});
-		const { externalWorkers: externalWorkers$1 } = miniflareWorkerOptions;
-		const workerOptions = miniflareWorkerOptions.workerOptions;
+		const wrappers = [
+			`import { createWorkerEntrypointWrapper, createDurableObjectWrapper, createWorkflowEntrypointWrapper } from "${RUNNER_PATH}";`,
+			`export { __VITE_RUNNER_OBJECT__ } from "${RUNNER_PATH}";`,
+			`export default createWorkerEntrypointWrapper("default");`
+		];
+		const exportTypes = ctx.workerNameToExportTypesMap.get(worker.config.name);
+		assert(exportTypes, `Expected exportTypes to be defined`);
+		for (const [name, type] of Object.entries(exportTypes)) wrappers.push(`export const ${name} = create${type}Wrapper("${name}");`);
 		return {
 			externalWorkers: externalWorkers$1,
 			worker: {
 				...workerOptions,
-				name: workerOptions.name ?? worker.config.name,
+				name: worker.config.name,
+				modulesRoot: miniflareModulesRoot,
+				modules: [{
+					type: "ESModule",
+					path: path$1.join(miniflareModulesRoot, WRAPPER_PATH),
+					contents: wrappers.join("\n")
+				}, {
+					type: "ESModule",
+					path: path$1.join(miniflareModulesRoot, RUNNER_PATH),
+					contents: fs$1.readFileSync(fileURLToPath(new URL(RUNNER_PATH, import.meta.url)))
+				}],
+				unsafeUseModuleFallbackService: true,
 				unsafeInspectorProxy: inputInspectorPort !== false,
 				unsafeDirectSockets: environmentName === resolvedPluginConfig.entryWorkerEnvironmentName ? [{
 					serviceName: VITE_PROXY_WORKER_NAME,
-					entrypoint: void 0,
 					proxy: true
-				}] : [],
-				modulesRoot: miniflareModulesRoot,
+				}, ...Object.entries(exportTypes).filter(([_, type]) => type === "WorkerEntrypoint").map(([entrypoint]) => ({
+					entrypoint,
+					proxy: true
+				}))] : [],
 				unsafeEvalBinding: "__VITE_UNSAFE_EVAL__",
 				serviceBindings: {
 					...workerOptions.serviceBindings,
@@ -15521,6 +15612,14 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 						const result = await viteDevServer.environments[environmentName].hot.handleInvoke(payload);
 						return Response$1.json(result);
 					}
+				},
+				durableObjects: {
+					...workerOptions.durableObjects,
+					__VITE_RUNNER_OBJECT__: {
+						className: "__VITE_RUNNER_OBJECT__",
+						unsafeUniqueKey: kUnsafeEphemeralUniqueKey,
+						unsafePreventEviction: true
+					}
 				}
 			}
 		};
@@ -15540,38 +15639,7 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 			workers: [
 				...assetWorkers,
 				...externalWorkers,
-				...userWorkers.map((workerOptions) => {
-					const wrappers = [
-						`import { createWorkerEntrypointWrapper, createDurableObjectWrapper, createWorkflowEntrypointWrapper } from "${RUNNER_PATH}";`,
-						`export { __VITE_RUNNER_OBJECT__ } from "${RUNNER_PATH}";`,
-						`export default createWorkerEntrypointWrapper("default");`
-					];
-					const exportTypes = ctx.workerNameToExportTypesMap.get(workerOptions.name);
-					assert(exportTypes, `Expected exportTypes to be defined`);
-					for (const [name, type] of Object.entries(exportTypes)) wrappers.push(`export const ${name} = create${type}Wrapper("${name}");`);
-					logUnknownTails(workerOptions.tails, userWorkers, viteDevServer.config.logger.warn);
-					return {
-						...workerOptions,
-						durableObjects: {
-							...workerOptions.durableObjects,
-							__VITE_RUNNER_OBJECT__: {
-								className: "__VITE_RUNNER_OBJECT__",
-								unsafeUniqueKey: kUnsafeEphemeralUniqueKey,
-								unsafePreventEviction: true
-							}
-						},
-						modules: [{
-							type: "ESModule",
-							path: path$2.join(miniflareModulesRoot, WRAPPER_PATH),
-							contents: wrappers.join("\n")
-						}, {
-							type: "ESModule",
-							path: path$2.join(miniflareModulesRoot, RUNNER_PATH),
-							contents: fs$1.readFileSync(fileURLToPath(new URL(RUNNER_PATH, import.meta.url)))
-						}],
-						unsafeUseModuleFallbackService: true
-					};
-				})
+				...userWorkers
 			],
 			async unsafeModuleFallbackService(request$1) {
 				const rawSpecifier = new URL(request$1.url).searchParams.get("rawSpecifier");
@@ -15600,8 +15668,8 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 }
 function getPreviewModules(main, modulesRules) {
 	assert(modulesRules, `Unexpected error: 'modulesRules' is undefined`);
-	const rootPath = path$2.dirname(main);
-	const entryPath = path$2.basename(main);
+	const rootPath = path$1.dirname(main);
+	const entryPath = path$1.basename(main);
 	return {
 		rootPath,
 		modules: [{
@@ -15610,9 +15678,9 @@ function getPreviewModules(main, modulesRules) {
 		}, ...modulesRules.flatMap(({ type, include }) => globSync(include, {
 			cwd: rootPath,
 			ignore: entryPath
-		}).map((path$3) => ({
+		}).map((path$2) => ({
 			type,
-			path: path$3
+			path: path$2
 		})))]
 	};
 }
@@ -15625,7 +15693,8 @@ async function getPreviewMiniflareOptions(ctx, vitePreviewServer) {
 		const preExistingRemoteProxySessionData = workerConfig.configPath ? remoteProxySessionsDataMap.get(workerConfig.configPath) : void 0;
 		const remoteProxySessionData = !resolvedPluginConfig.remoteBindings ? null : await maybeStartOrUpdateRemoteProxySession({
 			name: workerConfig.name,
-			bindings: bindings ?? {}
+			bindings: bindings ?? {},
+			account_id: workerConfig.account_id
 		}, preExistingRemoteProxySessionData ?? null);
 		if (workerConfig.configPath && remoteProxySessionData) remoteProxySessionsDataMap.set(workerConfig.configPath, remoteProxySessionData);
 		let containerBuildId;
@@ -15646,7 +15715,6 @@ async function getPreviewMiniflareOptions(ctx, vitePreviewServer) {
 		});
 		const { externalWorkers } = miniflareWorkerOptions;
 		const { modulesRules,...workerOptions } = miniflareWorkerOptions.workerOptions;
-		logUnknownTails(workerOptions.tails, resolvedPluginConfig.workers, vitePreviewServer.config.logger.warn);
 		return [{
 			...workerOptions,
 			name: workerOptions.name ?? workerConfig.name,
@@ -15823,7 +15891,9 @@ const devPlugin = createPlugin("dev", (ctx) => {
 						dockerPath: getDockerPath(),
 						containerOptions: [...containerTagToOptionsMap.values()],
 						onContainerImagePreparationStart: () => {},
-						onContainerImagePreparationEnd: () => {}
+						onContainerImagePreparationEnd: () => {},
+						logger: viteDevServer.config.logger,
+						isVite: true
 					});
 					containerImageTags = new Set(containerTagToOptionsMap.keys());
 					viteDevServer.config.logger.info(colors.dim(colors.yellow("\n⚡️ Containers successfully built. To rebuild your containers during development, restart the Vite dev server (r + enter).")));
@@ -15937,11 +16007,11 @@ const nodeJsCompatWarningsPlugin = createPlugin("nodejs-compat-warnings", (ctx)
 			if (workerConfig && !nodeJsCompat) return { optimizeDeps: { esbuildOptions: { plugins: [{
 				name: "vite-plugin-cloudflare:nodejs-compat-warnings-resolver",
 				setup(build) {
-					build.onResolve({ filter: NODEJS_MODULES_RE }, ({ path: path$3, importer }) => {
-						if (hasNodeJsAls(workerConfig) && isNodeAlsModule(path$3)) return;
-						nodeJsCompatWarningsMap.get(workerConfig)?.registerImport(path$3, importer);
+					build.onResolve({ filter: NODEJS_MODULES_RE }, ({ path: path$2, importer }) => {
+						if (hasNodeJsAls(workerConfig) && isNodeAlsModule(path$2)) return;
+						nodeJsCompatWarningsMap.get(workerConfig)?.registerImport(path$2, importer);
 						return {
-							path: path$3,
+							path: path$2,
 							external: true
 						};
 					});
@@ -16042,7 +16112,7 @@ const outputConfigPlugin = createPlugin("output-config", (ctx) => {
 function getAssetsDirectory(workerOutputDirectory, resolvedViteConfig) {
 	const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
 	assert(clientOutputDirectory, "Unexpected error: client output directory is undefined");
-	return path$2.relative(path$2.resolve(resolvedViteConfig.root, workerOutputDirectory), path$2.resolve(resolvedViteConfig.root, clientOutputDirectory));
+	return path$1.relative(path$1.resolve(resolvedViteConfig.root, workerOutputDirectory), path$1.resolve(resolvedViteConfig.root, clientOutputDirectory));
 }
 
 //#endregion
@@ -16070,7 +16140,9 @@ const previewPlugin = createPlugin("preview", (ctx) => {
 				dockerPath: getDockerPath(),
 				containerOptions: [...containerTagToOptionsMap.values()],
 				onContainerImagePreparationStart: () => {},
-				onContainerImagePreparationEnd: () => {}
+				onContainerImagePreparationEnd: () => {},
+				logger: vitePreviewServer.config.logger,
+				isVite: true
 			});
 			const containerImageTags = new Set(containerTagToOptionsMap.keys());
 			vitePreviewServer.config.logger.info(colors.dim(colors.yellow("\n⚡️ Containers successfully built.\n")));