@cloudflare/vite-plugin 1.10.0 → 1.10.1

package/dist/index.js

@@ -248,17 +248,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path14, originalPath, doThrow) => {
-      if (!isString2(path14)) {
+    var checkPath = (path13, originalPath, doThrow) => {
+      if (!isString2(path13)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path14) {
+      if (!path13) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path14)) {
+      if (checkPath.isNotRelative(path13)) {
         const r2 = "`path.relative()`d";
         return doThrow(
           `path should be a ${r2} string, but got "${originalPath}"`,
@@ -267,7 +267,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path14) => REGEX_TEST_INVALID_PATH.test(path14);
+    var isNotRelative = (path13) => REGEX_TEST_INVALID_PATH.test(path13);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -326,7 +326,7 @@ var require_ignore = __commonJS({
       //   setting `checkUnignored` to `false` could reduce additional
       //   path matching.
       // @returns {TestResult} true if a file is ignored
-      _testOne(path14, checkUnignored) {
+      _testOne(path13, checkUnignored) {
         let ignored = false;
         let unignored = false;
         this._rules.forEach((rule) => {
@@ -334,7 +334,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule.regex.test(path14);
+          const matched = rule.regex.test(path13);
           if (matched) {
             ignored = !negative;
             unignored = negative;
@@ -347,24 +347,24 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache2, checkUnignored, slices) {
-        const path14 = originalPath && checkPath.convert(originalPath);
+        const path13 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path14,
+          path13,
           originalPath,
           this._allowRelativePaths ? RETURN_FALSE : throwError
         );
-        return this._t(path14, cache2, checkUnignored, slices);
+        return this._t(path13, cache2, checkUnignored, slices);
       }
-      _t(path14, cache2, checkUnignored, slices) {
-        if (path14 in cache2) {
-          return cache2[path14];
+      _t(path13, cache2, checkUnignored, slices) {
+        if (path13 in cache2) {
+          return cache2[path13];
         }
         if (!slices) {
-          slices = path14.split(SLASH);
+          slices = path13.split(SLASH);
         }
         slices.pop();
         if (!slices.length) {
-          return cache2[path14] = this._testOne(path14, checkUnignored);
+          return cache2[path13] = this._testOne(path13, checkUnignored);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -372,24 +372,24 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache2[path14] = parent.ignored ? parent : this._testOne(path14, checkUnignored);
+        return cache2[path13] = parent.ignored ? parent : this._testOne(path13, checkUnignored);
       }
-      ignores(path14) {
-        return this._test(path14, this._ignoreCache, false).ignored;
+      ignores(path13) {
+        return this._test(path13, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path14) => !this.ignores(path14);
+        return (path13) => !this.ignores(path13);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path14) {
-        return this._test(path14, this._testCache, true);
+      test(path13) {
+        return this._test(path13, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path14) => checkPath(path14 && checkPath.convert(path14), path14, RETURN_FALSE);
+    var isPathValid = (path13) => checkPath(path13 && checkPath.convert(path13), path13, RETURN_FALSE);
     factory.isPathValid = isPathValid;
     factory.default = factory;
     module.exports = factory;
@@ -400,7 +400,7 @@ var require_ignore = __commonJS({
       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 = (path14) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path14) || isNotRelative(path14);
+      checkPath.isNotRelative = (path13) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path13) || isNotRelative(path13);
     }
   }
 });
@@ -443,11 +443,11 @@ var require_Mime = __commonJS({
         }
       }
     };
-    Mime.prototype.getType = function(path14) {
-      path14 = String(path14);
-      let last = path14.replace(/^.*[/\\]/, "").toLowerCase();
+    Mime.prototype.getType = function(path13) {
+      path13 = String(path13);
+      let last = path13.replace(/^.*[/\\]/, "").toLowerCase();
       let ext = last.replace(/^.*\./, "").toLowerCase();
-      let hasPath = last.length < path14.length;
+      let hasPath = last.length < path13.length;
       let hasDot = ext.length < last.length - 1;
       return (hasDot || !hasPath) && this._types[ext] || null;
     };
@@ -487,13 +487,12 @@ var require_mime = __commonJS({
 // src/index.ts
 import assert11 from "node:assert";
 import * as fsp2 from "node:fs/promises";
-import * as path13 from "node:path";
+import * as path12 from "node:path";
 
 // ../containers-shared/src/build.ts
 import { spawn } from "child_process";
 import { readFileSync } from "fs";
-import path from "path";
-async function constructBuildCommand(options, configPath, logger) {
+async function constructBuildCommand(options, logger) {
   const platform = options.platform ?? "linux/amd64";
   const buildCmd = [
     "build",
@@ -511,12 +510,9 @@ async function constructBuildCommand(options, configPath, logger) {
   if (options.setNetworkToHost) {
     buildCmd.push("--network", "host");
   }
-  const baseDir = configPath ? path.dirname(configPath) : process.cwd();
-  const absDockerfilePath = path.resolve(baseDir, options.pathToDockerfile);
-  const dockerfile = readFileSync(absDockerfilePath, "utf-8");
-  const absBuildContext = options.buildContext ? path.resolve(baseDir, options.buildContext) : path.dirname(absDockerfilePath);
+  const dockerfile = readFileSync(options.pathToDockerfile, "utf-8");
   buildCmd.push("-f", "-");
-  buildCmd.push(absBuildContext);
+  buildCmd.push(options.buildContext);
   logger?.debug(`Building image with command: ${buildCmd.join(" ")}`);
   return { buildCmd, dockerfile };
 }
@@ -563,17 +559,14 @@ function dockerBuild(dockerPath, options) {
     ready
   };
 }
-async function buildImage(dockerPath, options, configPath) {
-  const { buildCmd, dockerfile } = await constructBuildCommand(
-    {
-      tag: options.imageTag,
-      pathToDockerfile: options.image,
-      buildContext: options.imageBuildContext,
-      args: options.args,
-      platform: "linux/amd64"
-    },
-    configPath
-  );
+async function buildImage(dockerPath, options) {
+  const { buildCmd, dockerfile } = await constructBuildCommand({
+    tag: options.image_tag,
+    pathToDockerfile: options.dockerfile,
+    buildContext: options.image_build_context,
+    args: options.image_vars,
+    platform: "linux/amd64"
+  });
   return dockerBuild(dockerPath, { buildCmd, dockerfile });
 }
 
@@ -957,13 +950,13 @@ var getQueryString = (params) => {
 };
 var getUrl = (config, options) => {
   const encoder = config.ENCODE_PATH || encodeURI;
-  const path14 = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+  const path13 = 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}${path14}`;
+  const url = `${config.BASE}${path13}`;
   if (options.query) {
     return `${url}${getQueryString(options.query)}`;
   }
@@ -1381,7 +1374,7 @@ async function dockerLoginManagedRegistry(pathToDocker) {
 import { execFile, spawn as spawn4 } from "child_process";
 import { randomUUID } from "crypto";
 import { existsSync, statSync } from "fs";
-import path2 from "path";
+import path from "path";
 
 // ../containers-shared/src/inspect.ts
 import { spawn as spawn3 } from "child_process";
@@ -1450,7 +1443,7 @@ var runDockerCmd = (dockerPath, args, stdio) => {
       }
     },
     ready,
-    then: async (resolve10, reject2) => ready.then(resolve10).catch(reject2)
+    then: async (onResolve, onReject) => ready.then(onResolve).catch(onReject)
   };
 };
 var runDockerCmdWithOutput = async (dockerPath, args) => {
@@ -1477,13 +1470,13 @@ Other container tooling that is compatible with the Docker CLI and engine may wo
     );
   }
 };
-function isDir(path14) {
-  const stats = statSync(path14);
+function isDir(inputPath) {
+  const stats = statSync(inputPath);
   return stats.isDirectory();
 }
 var isDockerfile = (image, configPath) => {
-  const baseDir = configPath ? path2.dirname(configPath) : process.cwd();
-  const maybeDockerfile = path2.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 Error(
@@ -1539,7 +1532,7 @@ var getContainerIdsFromImage = async (dockerPath, ancestorImage) => {
 };
 async function checkExposedPorts(dockerPath, options) {
   const output = await dockerImageInspect(dockerPath, {
-    imageTag: options.imageTag,
+    imageTag: options.image_tag,
     formatString: "{{ len .Config.ExposedPorts }}"
   });
   if (output === "0") {
@@ -1559,14 +1552,18 @@ async function pullImage(dockerPath, options) {
   await dockerLoginManagedRegistry(dockerPath);
   const pull = runDockerCmd(dockerPath, [
     "pull",
-    options.image,
+    options.image_uri,
     // All containers running on our platform need to be built for amd64 architecture, but by default docker pull seems to look for an image matching the host system, so we need to specify this here
     "--platform",
     "linux/amd64"
   ]);
   const ready = pull.ready.then(async ({ aborted }) => {
     if (!aborted) {
-      await runDockerCmd(dockerPath, ["tag", options.image, options.imageTag]);
+      await runDockerCmd(dockerPath, [
+        "tag",
+        options.image_uri,
+        options.image_tag
+      ]);
     }
   });
   return {
@@ -1576,14 +1573,13 @@ async function pullImage(dockerPath, options) {
     ready
   };
 }
-async function prepareContainerImagesForDev(options) {
+async function prepareContainerImagesForDev(args) {
   const {
     dockerPath,
-    configPath,
     containerOptions,
     onContainerImagePreparationStart,
     onContainerImagePreparationEnd
-  } = options;
+  } = args;
   let aborted = false;
   if (process.platform === "win32") {
     throw new Error(
@@ -1591,11 +1587,11 @@ async function prepareContainerImagesForDev(options) {
     );
   }
   await verifyDockerInstalled(dockerPath);
-  for (const options2 of containerOptions) {
-    if (isDockerfile(options2.image, configPath)) {
-      const build = await buildImage(dockerPath, options2, configPath);
+  for (const options of containerOptions) {
+    if ("dockerfile" in options) {
+      const build = await buildImage(dockerPath, options);
       onContainerImagePreparationStart({
-        containerOptions: options2,
+        containerOptions: options,
         abort: () => {
           aborted = true;
           build.abort();
@@ -1603,18 +1599,18 @@ async function prepareContainerImagesForDev(options) {
       });
       await build.ready;
       onContainerImagePreparationEnd({
-        containerOptions: options2
+        containerOptions: options
       });
     } else {
-      if (!isCloudflareRegistryLink(options2.image)) {
+      if (!isCloudflareRegistryLink(options.image_uri)) {
         throw new Error(
-          `Image "${options2.image}" is a registry link but does not point to the Cloudflare container registry.
+          `Image "${options.image_uri}" is a registry link but does not point to the Cloudflare container registry.
 To use an existing image from another repository, see https://developers.cloudflare.com/containers/image-management/#using-existing-images`
         );
       }
-      const pull = await pullImage(dockerPath, options2);
+      const pull = await pullImage(dockerPath, options);
       onContainerImagePreparationStart({
-        containerOptions: options2,
+        containerOptions: options,
         abort: () => {
           aborted = true;
           pull.abort();
@@ -1622,11 +1618,11 @@ To use an existing image from another repository, see https://developers.cloudfl
       });
       await pull.ready;
       onContainerImagePreparationEnd({
-        containerOptions: options2
+        containerOptions: options
       });
     }
     if (!aborted) {
-      await checkExposedPorts(dockerPath, options2);
+      await checkExposedPorts(dockerPath, options);
     }
   }
 }
@@ -2761,7 +2757,7 @@ function createModuleReference(type, id) {
 }
 
 // src/asset-config.ts
-import * as path3 from "node:path";
+import * as path2 from "node:path";
 
 // ../workers-shared/utils/configuration/constructConfiguration.ts
 import { relative } from "node:path";
@@ -2897,11 +2893,11 @@ ${invalidHeaderRulesList}`
 }
 
 // ../workers-shared/utils/configuration/validateURL.ts
-var extractPathname = (path14 = "/", includeSearch, includeHash) => {
-  if (!path14.startsWith("/")) {
-    path14 = `/${path14}`;
+var extractPathname = (path13 = "/", includeSearch, includeHash) => {
+  if (!path13.startsWith("/")) {
+    path13 = `/${path13}`;
   }
-  const url = new URL(`//${path14}`, "relative://");
+  const url = new URL(`//${path13}`, "relative://");
   return `${url.pathname}${includeSearch ? url.search : ""}${includeHash ? url.hash : ""}`;
 };
 var URL_REGEX = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/;
@@ -2934,8 +2930,8 @@ var validateUrl = (token, onlyRelative = false, disallowPorts = false, includeSe
     if (!token.startsWith("/") && onlyRelative) {
       token = `/${token}`;
     }
-    const path14 = PATH_REGEX.exec(token);
-    if (path14) {
+    const path13 = PATH_REGEX.exec(token);
+    if (path13) {
       try {
         return [extractPathname(token, includeSearch, includeHash), void 0];
       } catch {
@@ -2996,7 +2992,7 @@ function parseHeaders(input, {
           });
         }
       }
-      const [path14, pathError] = validateUrl(line, false, true);
+      const [path13, pathError] = validateUrl(line, false, true);
       if (pathError) {
         invalid.push({
           line,
@@ -3007,7 +3003,7 @@ function parseHeaders(input, {
         continue;
       }
       rule = {
-        path: path14,
+        path: path13,
         line,
         headers: {},
         unsetHeaders: []
@@ -3582,8 +3578,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (params) => {
-  const { data: data2, path: path14, errorMaps, issueData } = params;
-  const fullPath = [...path14, ...issueData.path || []];
+  const { data: data2, path: path13, errorMaps, issueData } = params;
+  const fullPath = [...path13, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -3682,11 +3678,11 @@ var errorUtil;
   errorUtil2.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
 })(errorUtil || (errorUtil = {}));
 var ParseInputLazyPath = class {
-  constructor(parent, value, path14, key) {
+  constructor(parent, value, path13, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path14;
+    this._path = path13;
     this._key = key;
   }
   get path() {
@@ -7082,22 +7078,22 @@ function getAssetsConfig(resolvedPluginConfig, entryWorkerConfig, resolvedConfig
   };
 }
 function getRedirectsConfigPath(config) {
-  return path3.join(config.publicDir, REDIRECTS_FILENAME);
+  return path2.join(config.publicDir, REDIRECTS_FILENAME);
 }
 function getHeadersConfigPath(config) {
-  return path3.join(config.publicDir, HEADERS_FILENAME);
+  return path2.join(config.publicDir, HEADERS_FILENAME);
 }
 
 // src/build.ts
 import assert from "node:assert";
 import * as fs from "node:fs";
-import * as path4 from "node:path";
+import * as path3 from "node:path";
 import colors from "picocolors";
 function createBuildApp(resolvedPluginConfig) {
   return async (builder) => {
     const clientEnvironment = builder.environments.client;
     assert(clientEnvironment, `No "client" environment`);
-    const defaultHtmlPath = path4.resolve(builder.config.root, "index.html");
+    const defaultHtmlPath = path3.resolve(builder.config.root, "index.html");
     const hasClientEntry = clientEnvironment.config.build.rollupOptions.input || fs.existsSync(defaultHtmlPath);
     if (resolvedPluginConfig.type === "assets-only") {
       if (hasClientEntry) {
@@ -7123,7 +7119,7 @@ function createBuildApp(resolvedPluginConfig) {
       entryWorkerEnvironment,
       `No "${entryWorkerEnvironmentName}" environment`
     );
-    const entryWorkerBuildDirectory = path4.resolve(
+    const entryWorkerBuildDirectory = path3.resolve(
       builder.config.root,
       entryWorkerEnvironment.config.build.outDir
     );
@@ -7134,7 +7130,7 @@ function createBuildApp(resolvedPluginConfig) {
     } else if (importedAssetPaths.size || getHasPublicAssets(builder.config)) {
       await fallbackBuild(builder, clientEnvironment);
     } else {
-      const entryWorkerConfigPath = path4.join(
+      const entryWorkerConfigPath = path3.join(
         entryWorkerBuildDirectory,
         "wrangler.json"
       );
@@ -7145,21 +7141,21 @@ function createBuildApp(resolvedPluginConfig) {
       fs.writeFileSync(entryWorkerConfigPath, JSON.stringify(workerConfig));
       return;
     }
-    const clientBuildDirectory = path4.resolve(
+    const clientBuildDirectory = path3.resolve(
       builder.config.root,
       clientEnvironment.config.build.outDir
     );
     const movedAssetPaths = [];
     for (const assetPath of importedAssetPaths) {
-      const src = path4.join(entryWorkerBuildDirectory, assetPath);
-      const dest = path4.join(clientBuildDirectory, assetPath);
+      const src = path3.join(entryWorkerBuildDirectory, assetPath);
+      const dest = path3.join(clientBuildDirectory, assetPath);
       if (!fs.existsSync(src)) {
         continue;
       }
       if (fs.existsSync(dest)) {
         fs.unlinkSync(src);
       } else {
-        const destDir = path4.dirname(dest);
+        const destDir = path3.dirname(dest);
         fs.mkdirSync(destDir, { recursive: true });
         fs.renameSync(src, dest);
         movedAssetPaths.push(dest);
@@ -7170,7 +7166,7 @@ function createBuildApp(resolvedPluginConfig) {
         [
           `${colors.green("\u2713")} ${movedAssetPaths.length} asset${movedAssetPaths.length > 1 ? "s" : ""} moved from "${entryWorkerEnvironmentName}" to "client" build output.`,
           ...movedAssetPaths.map(
-            (assetPath) => colors.dim(path4.relative(builder.config.root, assetPath))
+            (assetPath) => colors.dim(path3.relative(builder.config.root, assetPath))
           )
         ].join("\n")
       );
@@ -7200,7 +7196,7 @@ async function fallbackBuild(builder, environment) {
     }
   };
   await builder.build(environment);
-  const fallbackEntryPath = path4.resolve(
+  const fallbackEntryPath = path3.resolve(
     builder.config.root,
     environment.config.build.outDir,
     fallbackEntryName
@@ -7209,7 +7205,7 @@ async function fallbackBuild(builder, environment) {
 }
 function loadViteManifest(directory) {
   const contents = fs.readFileSync(
-    path4.resolve(directory, ".vite", "manifest.json"),
+    path3.resolve(directory, ".vite", "manifest.json"),
     "utf-8"
   );
   return JSON.parse(contents);
@@ -7228,7 +7224,7 @@ import * as vite2 from "vite";
 // src/node-js-compat.ts
 import assert3 from "node:assert";
 import { builtinModules as builtinModules2 } from "node:module";
-import path6 from "node:path";
+import path5 from "node:path";
 import { cloudflare } from "@cloudflare/unenv-preset";
 import { getNodeCompat } from "miniflare";
 
@@ -12780,17 +12776,17 @@ function withTrailingSlash(input = "", respectQueryAndFragment) {
   if (hasTrailingSlash(input, true)) {
     return input || "/";
   }
-  let path14 = input;
+  let path13 = input;
   let fragment = "";
   const fragmentIndex = input.indexOf("#");
   if (fragmentIndex >= 0) {
-    path14 = input.slice(0, fragmentIndex);
+    path13 = input.slice(0, fragmentIndex);
     fragment = input.slice(fragmentIndex);
-    if (!path14) {
+    if (!path13) {
       return fragment;
     }
   }
-  const [s0, ...s] = path14.split("?");
+  const [s0, ...s] = path13.split("?");
   return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -12820,12 +12816,12 @@ var isAbsolute = function(p) {
 import { fileURLToPath as fileURLToPath$1, URL as URL$1, pathToFileURL as pathToFileURL$1 } from "node:url";
 import assert2 from "node:assert";
 import process$1 from "node:process";
-import path5, { dirname as dirname3 } from "node:path";
+import path4, { dirname as dirname3 } from "node:path";
 import v8 from "node:v8";
 import { format as format2, inspect } from "node:util";
 var BUILTIN_MODULES = new Set(builtinModules);
-function normalizeSlash(path14) {
-  return path14.replace(/\\/g, "/");
+function normalizeSlash(path13) {
+  return path13.replace(/\\/g, "/");
 }
 var own$1 = {}.hasOwnProperty;
 var classRegExp = /^([A-Z][a-z\d]*)+$/;
@@ -12938,8 +12934,8 @@ codes.ERR_INVALID_PACKAGE_CONFIG = createError(
    * @param {string} [base]
    * @param {string} [message]
    */
-  (path14, base, message) => {
-    return `Invalid package config ${path14}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  (path13, base, message) => {
+    return `Invalid package config ${path13}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
   },
   Error
 );
@@ -12971,8 +12967,8 @@ codes.ERR_MODULE_NOT_FOUND = createError(
    * @param {string} base
    * @param {boolean} [exactUrl]
    */
-  (path14, base, exactUrl = false) => {
-    return `Cannot find ${exactUrl ? "module" : "package"} '${path14}' imported from ${base}`;
+  (path13, base, exactUrl = false) => {
+    return `Cannot find ${exactUrl ? "module" : "package"} '${path13}' imported from ${base}`;
   },
   Error
 );
@@ -13023,8 +13019,8 @@ codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
    * @param {string} extension
    * @param {string} path
    */
-  (extension, path14) => {
-    return `Unknown file extension "${extension}" for ${path14}`;
+  (extension, path13) => {
+    return `Unknown file extension "${extension}" for ${path13}`;
   },
   TypeError
 );
@@ -13169,7 +13165,7 @@ function read(jsonPath, { base, specifier }) {
   }
   let string;
   try {
-    string = fs2.readFileSync(path5.toNamespacedPath(jsonPath), "utf8");
+    string = fs2.readFileSync(path4.toNamespacedPath(jsonPath), "utf8");
   } catch (error) {
     const exception = (
       /** @type {ErrnoException} */
@@ -13385,7 +13381,7 @@ Default "index" lookups for the main are deprecated for ES modules.`,
       "DeprecationWarning",
       "DEP0151"
     );
-  } else if (path5.resolve(packagePath, main) !== urlPath) {
+  } else if (path4.resolve(packagePath, main) !== urlPath) {
     process$1.emitWarning(
       `Package ${packagePath} has a "main" field set to "${main}", excluding the full filename and extension to the resolved file at "${urlPath.slice(
         packagePath.length
@@ -13396,9 +13392,9 @@ Default "index" lookups for the main are deprecated for ES modules.`,
     );
   }
 }
-function tryStatSync(path14) {
+function tryStatSync(path13) {
   try {
-    return statSync2(path14);
+    return statSync2(path13);
   } catch {
   }
 }
@@ -13492,7 +13488,7 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
   {
     const real = realpathSync(filePath);
     const { search, hash } = resolved;
-    resolved = pathToFileURL$1(real + (filePath.endsWith(path5.sep) ? "/" : ""));
+    resolved = pathToFileURL$1(real + (filePath.endsWith(path4.sep) ? "/" : ""));
     resolved.search = search;
     resolved.hash = hash;
   }
@@ -14203,8 +14199,8 @@ function isNodeAls(workerConfig) {
     workerConfig.compatibility_flags ?? []
   ).mode === "als";
 }
-function isNodeAlsModule(path14) {
-  return /^(node:)?async_hooks$/.test(path14);
+function isNodeAlsModule(path13) {
+  return /^(node:)?async_hooks$/.test(path13);
 }
 var injectsByModule = /* @__PURE__ */ new Map();
 var virtualModulePathToSpecifier = /* @__PURE__ */ new Map();
@@ -14311,7 +14307,7 @@ var NodeJsCompatWarnings = class {
 `;
       this.sources.forEach((importers, source) => {
         importers.forEach((importer) => {
-          message += ` - "${source}" imported from "${path6.relative(this.resolvedViteConfig.root, importer)}"
+          message += ` - "${source}" imported from "${path5.relative(this.resolvedViteConfig.root, importer)}"
 `;
         });
       });
@@ -14335,7 +14331,7 @@ var additionalModuleGlobalRE = new RegExp(
 var VITE_DEV_METADATA_HEADER = "__VITE_DEV_METADATA__";
 
 // src/utils.ts
-import * as path7 from "node:path";
+import * as path6 from "node:path";
 import { createRequest, sendResponse } from "@mjackson/node-fetch-server";
 import {
   Request as MiniflareRequest,
@@ -14343,14 +14339,14 @@ import {
 } from "miniflare";
 function getOutputDirectory(userConfig, environmentName) {
   const rootOutputDirectory = userConfig.build?.outDir ?? "dist";
-  return userConfig.environments?.[environmentName]?.build?.outDir ?? path7.join(rootOutputDirectory, environmentName);
+  return userConfig.environments?.[environmentName]?.build?.outDir ?? path6.join(rootOutputDirectory, environmentName);
 }
 var postfixRE = /[?#].*$/;
 function cleanUrl(url) {
   return url.replace(postfixRE, "");
 }
-function withTrailingSlash2(path14) {
-  return path14.endsWith("/") ? path14 : `${path14}/`;
+function withTrailingSlash2(path13) {
+  return path13.endsWith("/") ? path13 : `${path13}/`;
 }
 function createRequestHandler(handler) {
   return async (req, res, next) => {
@@ -14645,11 +14641,11 @@ function getDebugPathHtml(workerNames, inspectorPort) {
 // src/deploy-config.ts
 import assert6 from "node:assert";
 import * as fs3 from "node:fs";
-import * as path8 from "node:path";
+import * as path7 from "node:path";
 import "vite";
 import { unstable_readConfig } from "wrangler";
 function getDeployConfigPath(root) {
-  return path8.resolve(root, ".wrangler", "deploy", "config.json");
+  return path7.resolve(root, ".wrangler", "deploy", "config.json");
 }
 function getWorkerConfigs(root) {
   const deployConfigPath = getDeployConfigPath(root);
@@ -14660,22 +14656,22 @@ function getWorkerConfigs(root) {
     { configPath: deployConfig.configPath },
     ...deployConfig.auxiliaryWorkers
   ].map(({ configPath }) => {
-    const resolvedConfigPath = path8.resolve(
-      path8.dirname(deployConfigPath),
+    const resolvedConfigPath = path7.resolve(
+      path7.dirname(deployConfigPath),
       configPath
     );
     return unstable_readConfig({ config: resolvedConfigPath });
   });
 }
 function getRelativePathToWorkerConfig(deployConfigDirectory, root, outputDirectory) {
-  return path8.relative(
+  return path7.relative(
     deployConfigDirectory,
-    path8.resolve(root, outputDirectory, "wrangler.json")
+    path7.resolve(root, outputDirectory, "wrangler.json")
   );
 }
 function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
   const deployConfigPath = getDeployConfigPath(resolvedViteConfig.root);
-  const deployConfigDirectory = path8.dirname(deployConfigPath);
+  const deployConfigDirectory = path7.dirname(deployConfigPath);
   fs3.mkdirSync(deployConfigDirectory, { recursive: true });
   if (resolvedPluginConfig.type === "assets-only") {
     const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
@@ -14726,9 +14722,9 @@ function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
 
 // src/dev-vars.ts
 import * as fs4 from "node:fs";
-import * as path9 from "node:path";
+import * as path8 from "node:path";
 function getDotDevDotVarsContent(configPath, cloudflareEnv) {
-  const configDir = path9.dirname(configPath);
+  const configDir = path8.dirname(configPath);
   const defaultDotDevDotVarsPath = `${configDir}/.dev.vars`;
   const inputDotDevDotVarsPath = `${defaultDotDevDotVarsPath}${cloudflareEnv ? `.${cloudflareEnv}` : ""}`;
   const targetPath = fs4.existsSync(inputDotDevDotVarsPath) ? inputDotDevDotVarsPath : fs4.existsSync(defaultDotDevDotVarsPath) ? defaultDotDevDotVarsPath : null;
@@ -14740,7 +14736,7 @@ function getDotDevDotVarsContent(configPath, cloudflareEnv) {
 }
 function hasDotDevDotVarsFileChanged(resolvedPluginConfig, changedFilePath) {
   return [...resolvedPluginConfig.configPaths].some((configPath) => {
-    const dotDevDotVars = path9.join(path9.dirname(configPath), ".dev.vars");
+    const dotDevDotVars = path8.join(path8.dirname(configPath), ".dev.vars");
     if (dotDevDotVars === changedFilePath) {
       return true;
     }
@@ -14756,7 +14752,7 @@ function hasDotDevDotVarsFileChanged(resolvedPluginConfig, changedFilePath) {
 import assert7 from "node:assert";
 import * as fs5 from "node:fs";
 import * as fsp from "node:fs/promises";
-import * as path10 from "node:path";
+import * as path9 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import {
   getDefaultDevRegistryPath,
@@ -14778,7 +14774,7 @@ function getPersistenceRoot(root, persistState) {
     return;
   }
   const defaultPersistPath = ".wrangler/state";
-  const persistPath = path10.resolve(
+  const persistPath = path9.resolve(
     root,
     typeof persistState === "object" ? persistState.path : defaultPersistPath,
     "v3"
@@ -14913,7 +14909,7 @@ async function getDevMiniflareOptions(config) {
       modules: [
         {
           type: "ESModule",
-          path: path10.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
+          path: path9.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
           contents: fs5.readFileSync(
             fileURLToPath2(new URL(ROUTER_WORKER_PATH, import.meta.url))
           )
@@ -14936,7 +14932,7 @@ async function getDevMiniflareOptions(config) {
       modules: [
         {
           type: "ESModule",
-          path: path10.join(miniflareModulesRoot, ASSET_WORKER_PATH),
+          path: path9.join(miniflareModulesRoot, ASSET_WORKER_PATH),
           contents: fs5.readFileSync(
             fileURLToPath2(new URL(ASSET_WORKER_PATH, import.meta.url))
           )
@@ -14957,8 +14953,8 @@ async function getDevMiniflareOptions(config) {
             if (publicDirInRoot && pathname.startsWith(publicPath)) {
               return MiniflareResponse2.json(null);
             }
-            const publicDirFilePath = path10.join(publicDir, pathname);
-            const rootDirFilePath = path10.join(root, pathname);
+            const publicDirFilePath = path9.join(publicDir, pathname);
+            const rootDirFilePath = path9.join(root, pathname);
             for (const resolvedPath of [publicDirFilePath, rootDirFilePath]) {
               try {
                 const stats = await fsp.stat(resolvedPath);
@@ -14977,7 +14973,7 @@ async function getDevMiniflareOptions(config) {
           const { pathname } = new URL(request2.url);
           const { root, publicDir } = resolvedViteConfig;
           const isInPublicDir = pathname.startsWith(PUBLIC_DIR_PREFIX);
-          const resolvedPath = isInPublicDir ? path10.join(publicDir, pathname.slice(PUBLIC_DIR_PREFIX.length)) : path10.join(root, pathname);
+          const resolvedPath = isInPublicDir ? path9.join(publicDir, pathname.slice(PUBLIC_DIR_PREFIX.length)) : path9.join(root, pathname);
           try {
             let html = await fsp.readFile(resolvedPath, "utf-8");
             if (!isInPublicDir) {
@@ -15151,12 +15147,12 @@ async function getDevMiniflareOptions(config) {
           modules: [
             {
               type: "ESModule",
-              path: path10.join(miniflareModulesRoot, WRAPPER_PATH),
+              path: path9.join(miniflareModulesRoot, WRAPPER_PATH),
               contents: wrappers.join("\n")
             },
             {
               type: "ESModule",
-              path: path10.join(miniflareModulesRoot, RUNNER_PATH),
+              path: path9.join(miniflareModulesRoot, RUNNER_PATH),
               contents: fs5.readFileSync(
                 fileURLToPath2(new URL(RUNNER_PATH, import.meta.url))
               )
@@ -15211,8 +15207,8 @@ async function getDevMiniflareOptions(config) {
 }
 function getPreviewModules(main, modulesRules) {
   assert7(modulesRules, `Unexpected error: 'modulesRules' is undefined`);
-  const rootPath = path10.dirname(main);
-  const entryPath = path10.basename(main);
+  const rootPath = path9.dirname(main);
+  const entryPath = path9.basename(main);
   return {
     rootPath,
     modules: [
@@ -15221,9 +15217,9 @@ function getPreviewModules(main, modulesRules) {
         path: entryPath
       },
       ...modulesRules.flatMap(
-        ({ type, include }) => globSync(include, { cwd: rootPath, ignore: entryPath }).map((path14) => ({
+        ({ type, include }) => globSync(include, { cwd: rootPath, ignore: entryPath }).map((path13) => ({
           type,
-          path: path14
+          path: path13
         }))
       )
     ]
@@ -15333,7 +15329,7 @@ function miniflareLogLevelFromViteLogLevel(level = "info") {
 
 // src/plugin-config.ts
 import assert9 from "node:assert";
-import * as path12 from "node:path";
+import * as path11 from "node:path";
 
 // ../workers-shared/utils/configuration/parseStaticRouting.ts
 function parseStaticRouting(input) {
@@ -15417,7 +15413,7 @@ import * as vite5 from "vite";
 // src/workers-configs.ts
 import assert8 from "node:assert";
 import * as fs6 from "node:fs";
-import * as path11 from "node:path";
+import * as path10 from "node:path";
 import { unstable_readConfig as unstable_readConfig2 } from "wrangler";
 var nonApplicableWorkerConfigs = {
   /**
@@ -15509,7 +15505,7 @@ function getWarningForWorkersConfigs(configs) {
     const lines2 = [
       `
 
-\x1B[43mWARNING\x1B[0m: your worker config${configs.entryWorker.config.configPath ? ` (at \`${path11.relative("", configs.entryWorker.config.configPath)}\`)` : ""} contains the following configuration options which are ignored since they are not applicable when using Vite:`
+\x1B[43mWARNING\x1B[0m: your worker config${configs.entryWorker.config.configPath ? ` (at \`${path10.relative("", configs.entryWorker.config.configPath)}\`)` : ""} contains the following configuration options which are ignored since they are not applicable when using Vite:`
     ];
     nonApplicableLines.forEach((line) => lines2.push(line));
     lines2.push("");
@@ -15523,7 +15519,7 @@ function getWarningForWorkersConfigs(configs) {
     );
     if (nonApplicableLines.length > 0) {
       lines.push(
-        `  - (${isEntryWorker ? "entry" : "auxiliary"}) worker${workerConfig.config.name ? ` "${workerConfig.config.name}"` : ""}${workerConfig.config.configPath ? ` (config at \`${path11.relative("", workerConfig.config.configPath)}\`)` : ""}`
+        `  - (${isEntryWorker ? "entry" : "auxiliary"}) worker${workerConfig.config.name ? ` "${workerConfig.config.name}"` : ""}${workerConfig.config.configPath ? ` (config at \`${path10.relative("", workerConfig.config.configPath)}\`)` : ""}`
       );
       nonApplicableLines.forEach((line) => lines.push(line));
     }
@@ -15624,10 +15620,10 @@ function getWorkerConfig(configPath, env2, opts) {
 }
 function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliaryWorker = false) {
   if (requestedConfigPath) {
-    const configPath2 = path11.resolve(root, requestedConfigPath);
+    const configPath2 = path10.resolve(root, requestedConfigPath);
     const forAuxiliaryWorkerErrorMessage = isForAuxiliaryWorker ? " requested for one of your auxiliary workers" : "";
     const errorMessagePrefix = `The provided configPath (${configPath2})${forAuxiliaryWorkerErrorMessage}`;
-    const fileExtension = path11.extname(configPath2).slice(1);
+    const fileExtension = path10.extname(configPath2).slice(1);
     if (!allowedWranglerConfigExtensions.includes(fileExtension)) {
       const foundExtensionMessage = !fileExtension ? "no extension found" : `"${fileExtension}" found`;
       throw new Error(
@@ -15661,7 +15657,7 @@ function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliar
 }
 function findWranglerConfig(root) {
   for (const extension of allowedWranglerConfigExtensions) {
-    const configPath = path11.join(root, `wrangler.${extension}`);
+    const configPath = path10.join(root, `wrangler.${extension}`);
     if (fs6.existsSync(configPath)) {
       return configPath;
     }
@@ -15679,7 +15675,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     inspectorPort: pluginConfig.inspectorPort,
     experimental: pluginConfig.experimental ?? {}
   };
-  const root = userConfig.root ? path12.resolve(userConfig.root) : process.cwd();
+  const root = userConfig.root ? path11.resolve(userConfig.root) : process.cwd();
   if (viteEnv.isPreview) {
     return {
       ...shared,
@@ -15996,36 +15992,11 @@ if (import.meta.hot) {
             );
             workerConfig.assets = {
               ...workerConfig.assets,
-              directory: path13.relative(
-                path13.resolve(resolvedViteConfig.root, workerOutputDirectory),
-                path13.resolve(resolvedViteConfig.root, clientOutputDirectory)
+              directory: path12.relative(
+                path12.resolve(resolvedViteConfig.root, workerOutputDirectory),
+                path12.resolve(resolvedViteConfig.root, clientOutputDirectory)
               )
             };
-            if (workerConfig.containers?.length) {
-              workerConfig.containers = workerConfig.containers.map(
-                (container) => {
-                  const baseDir = workerConfig.configPath ? path13.dirname(workerConfig.configPath) : resolvedViteConfig.root;
-                  const image = container.configuration?.image ?? container.image;
-                  if (isDockerfile(image, workerConfig.configPath)) {
-                    const output = {
-                      ...container,
-                      image: path13.resolve(baseDir, image),
-                      ...container.image_build_context ? {
-                        image_build_context: path13.resolve(
-                          baseDir,
-                          container.image_build_context
-                        )
-                      } : {}
-                    };
-                    delete output.configuration?.image;
-                    if (output.configuration && Object.keys(output.configuration).length === 0) {
-                      delete output.configuration;
-                    }
-                    return output;
-                  } else return container;
-                }
-              );
-            }
           } else {
             workerConfig.assets = void 0;
           }
@@ -16078,7 +16049,7 @@ if (import.meta.hot) {
       },
       hotUpdate(options) {
         assertIsNotPreview(resolvedPluginConfig);
-        const changedFilePath = path13.resolve(options.file);
+        const changedFilePath = path12.resolve(options.file);
         if (resolvedPluginConfig.configPaths.has(changedFilePath) || hasDotDevDotVarsFileChanged(resolvedPluginConfig, changedFilePath) || hasAssetsConfigChanged(
           resolvedPluginConfig,
           resolvedViteConfig,
@@ -16159,18 +16130,17 @@ if (import.meta.hot) {
               containerBuildId,
               "Build ID should be set if containers are enabled and defined"
             );
-            const containerOptions = await getContainerOptions(
+            const containerOptions = getContainerOptions(
               entryWorkerConfig,
               containerBuildId
             );
             const dockerPath = getDockerPath();
             if (containerOptions) {
               for (const container of containerOptions) {
-                containerImageTagsSeen.add(container.imageTag);
+                containerImageTagsSeen.add(container.image_tag);
               }
               await prepareContainerImagesForDev({
                 dockerPath,
-                configPath: entryWorkerConfig.configPath,
                 containerOptions,
                 onContainerImagePreparationStart: () => {
                 },
@@ -16347,13 +16317,13 @@ if (import.meta.hot) {
           }
           const referenceId = this.emitFile({
             type: "asset",
-            name: path13.basename(modulePath),
+            name: path12.basename(modulePath),
             originalFileName: modulePath,
             source
           });
           const emittedFileName = this.getFileName(referenceId);
           const relativePath = vite6.normalizePath(
-            path13.relative(path13.dirname(chunk.fileName), emittedFileName)
+            path12.relative(path12.dirname(chunk.fileName), emittedFileName)
           );
           const importPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
           magicString.update(
@@ -16560,13 +16530,13 @@ if (import.meta.hot) {
                     setup(build) {
                       build.onResolve(
                         { filter: NODEJS_MODULES_RE },
-                        ({ path: path14, importer }) => {
-                          if (isNodeAls(workerConfig) && isNodeAlsModule(path14)) {
+                        ({ path: path13, importer }) => {
+                          if (isNodeAls(workerConfig) && isNodeAlsModule(path13)) {
                             return;
                           }
                           const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
-                          nodeJsCompatWarnings?.registerImport(path14, importer);
-                          return { path: path14, external: true };
+                          nodeJsCompatWarnings?.registerImport(path13, importer);
+                          return { path: path13, external: true };
                         }
                       );
                     }
@@ -16611,21 +16581,32 @@ if (import.meta.hot) {
   function getWorkerConfig2(environmentName) {
     return resolvedPluginConfig.type === "workers" ? resolvedPluginConfig.workers[environmentName] : void 0;
   }
-  async function getContainerOptions(config, containerBuildId) {
+  function getContainerOptions(config, containerBuildId) {
     if (!config.containers?.length || config.dev.enable_containers === false) {
       return void 0;
     }
     return config.containers.map((container) => {
-      return {
-        image: container.image ?? container.configuration?.image,
-        imageTag: getDevContainerImageName(
-          container.class_name,
-          containerBuildId
-        ),
-        args: container.image_vars,
-        imageBuildContext: container.image_build_context,
-        class_name: container.class_name
-      };
+      if (isDockerfile(container.image, config.configPath)) {
+        return {
+          dockerfile: container.image,
+          image_build_context: container.image_build_context ?? path12.dirname(container.image),
+          image_vars: container.image_vars,
+          class_name: container.class_name,
+          image_tag: getDevContainerImageName(
+            container.class_name,
+            containerBuildId
+          )
+        };
+      } else {
+        return {
+          image_uri: container.image,
+          class_name: container.class_name,
+          image_tag: getDevContainerImageName(
+            container.class_name,
+            containerBuildId
+          )
+        };
+      }
     });
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudflare/vite-plugin",
-  "version": "1.10.0",
+  "version": "1.10.1",
   "description": "Cloudflare plugin for Vite",
   "keywords": [
     "cloudflare",
@@ -33,7 +33,6 @@
     "dist"
   ],
   "dependencies": {
-    "@cloudflare/unenv-preset": "2.3.3",
     "@mjackson/node-fetch-server": "^0.6.1",
     "@rollup/plugin-replace": "^6.0.1",
     "get-port": "^7.1.0",
@@ -41,8 +40,9 @@
     "tinyglobby": "^0.2.12",
     "unenv": "2.0.0-rc.17",
     "ws": "8.18.0",
-    "miniflare": "4.20250712.1",
-    "wrangler": "4.25.1"
+    "@cloudflare/unenv-preset": "2.4.1",
+    "miniflare": "4.20250712.2",
+    "wrangler": "4.26.0"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20250712.0",
@@ -61,7 +61,7 @@
   },
   "peerDependencies": {
     "vite": "^6.1.0 || ^7.0.0",
-    "wrangler": "^4.25.1"
+    "wrangler": "^4.26.0"
   },
   "publishConfig": {
     "access": "public"