@cloudflare/vite-plugin 1.9.6 → 1.10.0

package/dist/index.js

@@ -218,8 +218,8 @@ var require_ignore = __commonJS({
       }
       return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
     };
-    var isString = (subject) => typeof subject === "string";
-    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var isString2 = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString2(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
     var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF);
     var IgnoreRule = class {
       constructor(origin, pattern, negative, regex) {
@@ -248,17 +248,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path12, originalPath, doThrow) => {
-      if (!isString(path12)) {
+    var checkPath = (path14, originalPath, doThrow) => {
+      if (!isString2(path14)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path12) {
+      if (!path14) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path12)) {
+      if (checkPath.isNotRelative(path14)) {
         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 = (path12) => REGEX_TEST_INVALID_PATH.test(path12);
+    var isNotRelative = (path14) => REGEX_TEST_INVALID_PATH.test(path14);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -302,7 +302,7 @@ var require_ignore = __commonJS({
       add(pattern) {
         this._added = false;
         makeArray(
-          isString(pattern) ? splitPattern(pattern) : pattern
+          isString2(pattern) ? splitPattern(pattern) : pattern
         ).forEach(this._addPattern, this);
         if (this._added) {
           this._initCache();
@@ -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(path12, checkUnignored) {
+      _testOne(path14, 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(path12);
+          const matched = rule.regex.test(path14);
           if (matched) {
             ignored = !negative;
             unignored = negative;
@@ -347,24 +347,24 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache2, checkUnignored, slices) {
-        const path12 = originalPath && checkPath.convert(originalPath);
+        const path14 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path12,
+          path14,
           originalPath,
           this._allowRelativePaths ? RETURN_FALSE : throwError
         );
-        return this._t(path12, cache2, checkUnignored, slices);
+        return this._t(path14, cache2, checkUnignored, slices);
       }
-      _t(path12, cache2, checkUnignored, slices) {
-        if (path12 in cache2) {
-          return cache2[path12];
+      _t(path14, cache2, checkUnignored, slices) {
+        if (path14 in cache2) {
+          return cache2[path14];
         }
         if (!slices) {
-          slices = path12.split(SLASH);
+          slices = path14.split(SLASH);
         }
         slices.pop();
         if (!slices.length) {
-          return cache2[path12] = this._testOne(path12, checkUnignored);
+          return cache2[path14] = this._testOne(path14, checkUnignored);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -372,24 +372,24 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache2[path12] = parent.ignored ? parent : this._testOne(path12, checkUnignored);
+        return cache2[path14] = parent.ignored ? parent : this._testOne(path14, checkUnignored);
       }
-      ignores(path12) {
-        return this._test(path12, this._ignoreCache, false).ignored;
+      ignores(path14) {
+        return this._test(path14, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path12) => !this.ignores(path12);
+        return (path14) => !this.ignores(path14);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path12) {
-        return this._test(path12, this._testCache, true);
+      test(path14) {
+        return this._test(path14, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path12) => checkPath(path12 && checkPath.convert(path12), path12, RETURN_FALSE);
+    var isPathValid = (path14) => checkPath(path14 && checkPath.convert(path14), path14, 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 = (path12) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path12) || isNotRelative(path12);
+      checkPath.isNotRelative = (path14) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path14) || isNotRelative(path14);
     }
   }
 });
@@ -443,11 +443,11 @@ var require_Mime = __commonJS({
         }
       }
     };
-    Mime.prototype.getType = function(path12) {
-      path12 = String(path12);
-      let last = path12.replace(/^.*[/\\]/, "").toLowerCase();
+    Mime.prototype.getType = function(path14) {
+      path14 = String(path14);
+      let last = path14.replace(/^.*[/\\]/, "").toLowerCase();
       let ext = last.replace(/^.*\./, "").toLowerCase();
-      let hasPath = last.length < path12.length;
+      let hasPath = last.length < path14.length;
       let hasDot = ext.length < last.length - 1;
       return (hasDot || !hasPath) && this._types[ext] || null;
     };
@@ -487,7 +487,1149 @@ var require_mime = __commonJS({
 // src/index.ts
 import assert11 from "node:assert";
 import * as fsp2 from "node:fs/promises";
-import * as path11 from "node:path";
+import * as path13 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) {
+  const platform = options.platform ?? "linux/amd64";
+  const buildCmd = [
+    "build",
+    "-t",
+    options.tag,
+    "--platform",
+    platform,
+    "--provenance=false"
+  ];
+  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 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);
+  buildCmd.push("-f", "-");
+  buildCmd.push(absBuildContext);
+  logger?.debug(`Building image with command: ${buildCmd.join(" ")}`);
+  return { buildCmd, dockerfile };
+}
+function dockerBuild(dockerPath, options) {
+  let errorHandled = false;
+  let resolve9;
+  let reject;
+  const ready = new Promise((res, rej) => {
+    resolve9 = res;
+    reject = rej;
+  });
+  const child = spawn(dockerPath, options.buildCmd, {
+    stdio: ["pipe", "inherit", "inherit"],
+    // We need to set detached to true so that the child process
+    // will control all of its child processed and we can kill
+    // all of them in case we need to abort the build process
+    detached: true
+  });
+  if (child.stdin !== null) {
+    child.stdin.write(options.dockerfile);
+    child.stdin.end();
+  }
+  child.on("exit", (code) => {
+    if (code === 0) {
+      resolve9();
+    } else if (!errorHandled) {
+      errorHandled = true;
+      reject(new Error(`Docker build exited with code: ${code}`));
+    }
+  });
+  child.on("error", (err) => {
+    if (!errorHandled) {
+      errorHandled = true;
+      reject(err);
+    }
+  });
+  return {
+    abort: () => {
+      child.unref();
+      if (child.pid !== void 0) {
+        process.kill(-child.pid);
+      }
+    },
+    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
+  );
+  return dockerBuild(dockerPath, { buildCmd, dockerfile });
+}
+
+// ../containers-shared/src/registry.ts
+var MF_DEV_CONTAINER_PREFIX = "cloudflare-dev";
+
+// ../containers-shared/src/knobs.ts
+var getCloudflareContainerRegistry = () => {
+  return process.env.CLOUDFLARE_CONTAINER_REGISTRY ?? "registry.cloudflare.com";
+};
+function isCloudflareRegistryLink(image) {
+  const cfRegistry = getCloudflareContainerRegistry();
+  return image.includes(cfRegistry);
+}
+var getDevContainerImageName = (name, tag) => {
+  return `${MF_DEV_CONTAINER_PREFIX}/${name.toLowerCase()}:${tag}`;
+};
+
+// ../containers-shared/src/login.ts
+import { spawn as spawn2 } from "node:child_process";
+
+// ../containers-shared/src/client/core/ApiError.ts
+var ApiError = class extends Error {
+  url;
+  status;
+  statusText;
+  body;
+  request;
+  constructor(request2, response, message) {
+    super(message);
+    this.name = "ApiError";
+    this.url = response.url;
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.body = response.body;
+    this.request = request2;
+  }
+};
+
+// ../containers-shared/src/client/core/CancelablePromise.ts
+var CancelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CancelError";
+  }
+  get isCancelled() {
+    return true;
+  }
+};
+var CancelablePromise = class {
+  #isResolved;
+  #isRejected;
+  #isCancelled;
+  #cancelHandlers;
+  #promise;
+  #resolve;
+  #reject;
+  constructor(executor) {
+    this.#isResolved = false;
+    this.#isRejected = false;
+    this.#isCancelled = false;
+    this.#cancelHandlers = [];
+    this.#promise = new Promise((resolve9, reject) => {
+      this.#resolve = resolve9;
+      this.#reject = reject;
+      const onResolve = (value) => {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#isResolved = true;
+        this.#resolve?.(value);
+      };
+      const onReject = (reason) => {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#isRejected = true;
+        this.#reject?.(reason);
+      };
+      const onCancel = (cancelHandler) => {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#cancelHandlers.push(cancelHandler);
+      };
+      Object.defineProperty(onCancel, "isResolved", {
+        get: () => this.#isResolved
+      });
+      Object.defineProperty(onCancel, "isRejected", {
+        get: () => this.#isRejected
+      });
+      Object.defineProperty(onCancel, "isCancelled", {
+        get: () => this.#isCancelled
+      });
+      return executor(onResolve, onReject, onCancel);
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "Cancellable Promise";
+  }
+  then(onFulfilled, onRejected) {
+    return this.#promise.then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    return this.#promise.catch(onRejected);
+  }
+  finally(onFinally) {
+    return this.#promise.finally(onFinally);
+  }
+  cancel() {
+    if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+      return;
+    }
+    this.#isCancelled = true;
+    if (this.#cancelHandlers.length) {
+      try {
+        for (const cancelHandler of this.#cancelHandlers) {
+          cancelHandler();
+        }
+      } catch (error) {
+        console.warn("Cancellation threw an error", error);
+        return;
+      }
+    }
+    this.#cancelHandlers.length = 0;
+    this.#reject?.(new CancelError("Request aborted"));
+  }
+  get isCancelled() {
+    return this.#isCancelled;
+  }
+};
+
+// ../containers-shared/src/client/core/OpenAPI.ts
+var OpenAPI = {
+  BASE: "",
+  VERSION: "1.0.0",
+  WITH_CREDENTIALS: false,
+  CREDENTIALS: "include",
+  TOKEN: void 0,
+  USERNAME: void 0,
+  PASSWORD: void 0,
+  HEADERS: void 0,
+  ENCODE_PATH: void 0
+};
+
+// ../containers-shared/src/client/models/ApplicationRollout.ts
+var ApplicationRollout;
+((ApplicationRollout2) => {
+  let kind;
+  ((kind2) => {
+    kind2["FULL_AUTO"] = "full_auto";
+    kind2["FULL_MANUAL"] = "full_manual";
+    kind2["DURABLE_OBJECTS_AUTO"] = "durable_objects_auto";
+  })(kind = ApplicationRollout2.kind || (ApplicationRollout2.kind = {}));
+  let strategy;
+  ((strategy2) => {
+    strategy2["ROLLING"] = "rolling";
+  })(strategy = ApplicationRollout2.strategy || (ApplicationRollout2.strategy = {}));
+  let status;
+  ((status2) => {
+    status2["PENDING"] = "pending";
+    status2["PROGRESSING"] = "progressing";
+    status2["COMPLETED"] = "completed";
+    status2["REVERTED"] = "reverted";
+    status2["REPLACED"] = "replaced";
+  })(status = ApplicationRollout2.status || (ApplicationRollout2.status = {}));
+})(ApplicationRollout || (ApplicationRollout = {}));
+
+// ../containers-shared/src/client/models/BadRequestWithCodeError.ts
+var BadRequestWithCodeError;
+((BadRequestWithCodeError2) => {
+  let error;
+  ((error2) => {
+    error2["VALIDATE_INPUT"] = "VALIDATE_INPUT";
+  })(error = BadRequestWithCodeError2.error || (BadRequestWithCodeError2.error = {}));
+})(BadRequestWithCodeError || (BadRequestWithCodeError = {}));
+
+// ../containers-shared/src/client/models/CreateApplicationRolloutRequest.ts
+var CreateApplicationRolloutRequest;
+((CreateApplicationRolloutRequest2) => {
+  let strategy;
+  ((strategy2) => {
+    strategy2["ROLLING"] = "rolling";
+  })(strategy = CreateApplicationRolloutRequest2.strategy || (CreateApplicationRolloutRequest2.strategy = {}));
+  let step_percentage;
+  ((step_percentage2) => {
+    step_percentage2[step_percentage2["_5"] = 5] = "_5";
+    step_percentage2[step_percentage2["_10"] = 10] = "_10";
+    step_percentage2[step_percentage2["_20"] = 20] = "_20";
+    step_percentage2[step_percentage2["_25"] = 25] = "_25";
+    step_percentage2[step_percentage2["_50"] = 50] = "_50";
+    step_percentage2[step_percentage2["_100"] = 100] = "_100";
+  })(step_percentage = CreateApplicationRolloutRequest2.step_percentage || (CreateApplicationRolloutRequest2.step_percentage = {}));
+  let kind;
+  ((kind2) => {
+    kind2["FULL_AUTO"] = "full_auto";
+    kind2["FULL_MANUAL"] = "full_manual";
+  })(kind = CreateApplicationRolloutRequest2.kind || (CreateApplicationRolloutRequest2.kind = {}));
+})(CreateApplicationRolloutRequest || (CreateApplicationRolloutRequest = {}));
+
+// ../containers-shared/src/client/models/DeploymentNotFoundError.ts
+var DeploymentNotFoundError;
+((DeploymentNotFoundError2) => {
+  let error;
+  ((error2) => {
+    error2["DEPLOYMENT_NOT_FOUND"] = "DEPLOYMENT_NOT_FOUND";
+  })(error = DeploymentNotFoundError2.error || (DeploymentNotFoundError2.error = {}));
+})(DeploymentNotFoundError || (DeploymentNotFoundError = {}));
+
+// ../containers-shared/src/client/models/ImageRegistryAlreadyExistsError.ts
+var ImageRegistryAlreadyExistsError;
+((ImageRegistryAlreadyExistsError2) => {
+  let error;
+  ((error2) => {
+    error2["IMAGE_REGISTRY_ALREADY_EXISTS"] = "IMAGE_REGISTRY_ALREADY_EXISTS";
+  })(error = ImageRegistryAlreadyExistsError2.error || (ImageRegistryAlreadyExistsError2.error = {}));
+})(ImageRegistryAlreadyExistsError || (ImageRegistryAlreadyExistsError = {}));
+
+// ../containers-shared/src/client/models/ImageRegistryIsPublic.ts
+var ImageRegistryIsPublic;
+((ImageRegistryIsPublic2) => {
+  let error;
+  ((error2) => {
+    error2["IMAGE_REGISTRY_IS_PUBLIC"] = "IMAGE_REGISTRY_IS_PUBLIC";
+  })(error = ImageRegistryIsPublic2.error || (ImageRegistryIsPublic2.error = {}));
+})(ImageRegistryIsPublic || (ImageRegistryIsPublic = {}));
+
+// ../containers-shared/src/client/models/ImageRegistryNotAllowedError.ts
+var ImageRegistryNotAllowedError;
+((ImageRegistryNotAllowedError2) => {
+  let error;
+  ((error2) => {
+    error2["IMAGE_REGISTRY_NOT_ALLOWED"] = "IMAGE_REGISTRY_NOT_ALLOWED";
+  })(error = ImageRegistryNotAllowedError2.error || (ImageRegistryNotAllowedError2.error = {}));
+})(ImageRegistryNotAllowedError || (ImageRegistryNotAllowedError = {}));
+
+// ../containers-shared/src/client/models/ImageRegistryNotFoundError.ts
+var ImageRegistryNotFoundError;
+((ImageRegistryNotFoundError2) => {
+  let error;
+  ((error2) => {
+    error2["IMAGE_REGISTRY_NOT_FOUND"] = "IMAGE_REGISTRY_NOT_FOUND";
+  })(error = ImageRegistryNotFoundError2.error || (ImageRegistryNotFoundError2.error = {}));
+})(ImageRegistryNotFoundError || (ImageRegistryNotFoundError = {}));
+
+// ../containers-shared/src/client/models/ImageRegistryProtocolAlreadyExists.ts
+var ImageRegistryProtocolAlreadyExists;
+((ImageRegistryProtocolAlreadyExists2) => {
+  let error;
+  ((error2) => {
+    error2["IMAGE_REGISTRY_PROTOCOL_ALREADY_EXISTS"] = "IMAGE_REGISTRY_PROTOCOL_ALREADY_EXISTS";
+  })(error = ImageRegistryProtocolAlreadyExists2.error || (ImageRegistryProtocolAlreadyExists2.error = {}));
+})(ImageRegistryProtocolAlreadyExists || (ImageRegistryProtocolAlreadyExists = {}));
+
+// ../containers-shared/src/client/models/ImageRegistryProtocolIsReferencedError.ts
+var ImageRegistryProtocolIsReferencedError;
+((ImageRegistryProtocolIsReferencedError2) => {
+  let error;
+  ((error2) => {
+    error2["IMAGE_REGISTRY_PROTO_IS_REFERENCED"] = "IMAGE_REGISTRY_PROTO_IS_REFERENCED";
+  })(error = ImageRegistryProtocolIsReferencedError2.error || (ImageRegistryProtocolIsReferencedError2.error = {}));
+})(ImageRegistryProtocolIsReferencedError || (ImageRegistryProtocolIsReferencedError = {}));
+
+// ../containers-shared/src/client/models/ImageRegistryProtocolNotFound.ts
+var ImageRegistryProtocolNotFound;
+((ImageRegistryProtocolNotFound2) => {
+  let error;
+  ((error2) => {
+    error2["IMAGE_REGISTRY_PROTOCOL_NOT_FOUND"] = "IMAGE_REGISTRY_PROTOCOL_NOT_FOUND";
+  })(error = ImageRegistryProtocolNotFound2.error || (ImageRegistryProtocolNotFound2.error = {}));
+})(ImageRegistryProtocolNotFound || (ImageRegistryProtocolNotFound = {}));
+
+// ../containers-shared/src/client/models/ProvisionerConfiguration.ts
+var ProvisionerConfiguration;
+((ProvisionerConfiguration2) => {
+  let type;
+  ((type2) => {
+    type2["NONE"] = "none";
+    type2["CLOUDINIT"] = "cloudinit";
+  })(type = ProvisionerConfiguration2.type || (ProvisionerConfiguration2.type = {}));
+})(ProvisionerConfiguration || (ProvisionerConfiguration = {}));
+
+// ../containers-shared/src/client/models/RolloutStep.ts
+var RolloutStep;
+((RolloutStep2) => {
+  let status;
+  ((status2) => {
+    status2["PENDING"] = "pending";
+    status2["PROGRESSING"] = "progressing";
+    status2["REVERTING"] = "reverting";
+    status2["COMPLETED"] = "completed";
+    status2["REVERTED"] = "reverted";
+  })(status = RolloutStep2.status || (RolloutStep2.status = {}));
+})(RolloutStep || (RolloutStep = {}));
+
+// ../containers-shared/src/client/models/SecretNameAlreadyExists.ts
+var SecretNameAlreadyExists;
+((SecretNameAlreadyExists2) => {
+  let error;
+  ((error2) => {
+    error2["SECRET_NAME_ALREADY_EXISTS"] = "SECRET_NAME_ALREADY_EXISTS";
+  })(error = SecretNameAlreadyExists2.error || (SecretNameAlreadyExists2.error = {}));
+})(SecretNameAlreadyExists || (SecretNameAlreadyExists = {}));
+
+// ../containers-shared/src/client/models/SecretNotFound.ts
+var SecretNotFound;
+((SecretNotFound2) => {
+  let error;
+  ((error2) => {
+    error2["SECRET_NAME_NOT_FOUND"] = "SECRET_NAME_NOT_FOUND";
+  })(error = SecretNotFound2.error || (SecretNotFound2.error = {}));
+})(SecretNotFound || (SecretNotFound = {}));
+
+// ../containers-shared/src/client/models/SSHPublicKeyNotFoundError.ts
+var SSHPublicKeyNotFoundError;
+((SSHPublicKeyNotFoundError2) => {
+  let error;
+  ((error2) => {
+    error2["SSH_PUBLIC_KEY_NOT_FOUND"] = "SSH_PUBLIC_KEY_NOT_FOUND";
+  })(error = SSHPublicKeyNotFoundError2.error || (SSHPublicKeyNotFoundError2.error = {}));
+})(SSHPublicKeyNotFoundError || (SSHPublicKeyNotFoundError = {}));
+
+// ../containers-shared/src/client/models/UpdateApplicationRolloutRequest.ts
+var UpdateApplicationRolloutRequest;
+((UpdateApplicationRolloutRequest2) => {
+  let action;
+  ((action2) => {
+    action2["NEXT"] = "next";
+    action2["PREVIOUS"] = "previous";
+    action2["REVERT"] = "revert";
+  })(action = UpdateApplicationRolloutRequest2.action || (UpdateApplicationRolloutRequest2.action = {}));
+})(UpdateApplicationRolloutRequest || (UpdateApplicationRolloutRequest = {}));
+
+// ../containers-shared/src/client/core/request.ts
+var isDefined = (value) => {
+  return value !== void 0 && value !== null;
+};
+var isString = (value) => {
+  return typeof value === "string";
+};
+var isStringWithValue = (value) => {
+  return isString(value) && value !== "";
+};
+var isBlob = (value) => {
+  return typeof value === "object" && typeof value.type === "string" && typeof value.stream === "function" && typeof value.arrayBuffer === "function" && typeof value.constructor === "function" && typeof value.constructor.name === "string" && /^(Blob|File)$/.test(value.constructor.name) && /^(Blob|File)$/.test(value[Symbol.toStringTag]);
+};
+var base64 = (str) => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString("base64");
+  }
+};
+var getQueryString = (params) => {
+  const qs = [];
+  const append = (key, value) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  };
+  const process2 = (key, value) => {
+    if (isDefined(value)) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => {
+          process2(key, v);
+        });
+      } else if (typeof value === "object") {
+        Object.entries(value).forEach(([k, v]) => {
+          process2(`${key}[${k}]`, v);
+        });
+      } else {
+        append(key, value);
+      }
+    }
+  };
+  Object.entries(params).forEach(([key, value]) => {
+    process2(key, value);
+  });
+  if (qs.length > 0) {
+    return `?${qs.join("&")}`;
+  }
+  return "";
+};
+var getUrl = (config, options) => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+  const path14 = 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}`;
+  if (options.query) {
+    return `${url}${getQueryString(options.query)}`;
+  }
+  return url;
+};
+var getFormData = (options) => {
+  if (options.formData) {
+    const formData = new FormData();
+    const process2 = async (key, value) => {
+      if (isString(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
+    };
+    Object.entries(options.formData).filter(([_, value]) => isDefined(value)).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => process2(key, v));
+      } else {
+        process2(key, value);
+      }
+    });
+    return formData;
+  }
+  return void 0;
+};
+var resolve = async (options, resolver) => {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+};
+var getHeaders = async (config, options) => {
+  const token = await resolve(options, config.TOKEN);
+  const username = await resolve(options, config.USERNAME);
+  const password = await resolve(options, config.PASSWORD);
+  const additionalHeaders = await resolve(options, config.HEADERS);
+  const headers = Object.entries({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers
+  }).filter(([_, value]) => isDefined(value)).reduce(
+    (headers2, [key, value]) => ({
+      ...headers2,
+      [key]: String(value)
+    }),
+    {}
+  );
+  if (isStringWithValue(token)) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(`${username}:${password}`);
+    headers["Authorization"] = `Basic ${credentials}`;
+  }
+  if (options.body) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    } else if (isBlob(options.body)) {
+      headers["Content-Type"] = options.body.type || "application/octet-stream";
+    } else if (isString(options.body)) {
+      headers["Content-Type"] = "text/plain";
+    } else {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  return new Headers(headers);
+};
+var getRequestBody = (options) => {
+  if (options.body !== void 0) {
+    if (options.mediaType?.includes("/json")) {
+      return JSON.stringify(options.body);
+    } else if (isString(options.body) || isBlob(options.body)) {
+      return options.body;
+    } else {
+      return JSON.stringify(options.body);
+    }
+  }
+  return void 0;
+};
+var isResponseSchemaV4 = (config, _options) => {
+  return config.BASE.endsWith("/containers");
+};
+var parseResponseSchemaV4 = (url, response, responseHeader, responseBody) => {
+  const fetchResult = typeof responseBody === "object" ? responseBody : JSON.parse(responseBody);
+  const ok = response.ok && fetchResult.success;
+  let result;
+  if (ok) {
+    if (fetchResult.result !== void 0) {
+      result = fetchResult.result;
+    } else {
+      result = {};
+    }
+  } else {
+    result = { error: fetchResult.errors?.[0]?.message };
+  }
+  return {
+    url,
+    ok,
+    status: response.status,
+    statusText: response.statusText,
+    body: responseHeader ?? result
+  };
+};
+var sendRequest = async (config, options, url, body, formData, headers, onCancel) => {
+  const controller = new AbortController();
+  const request2 = {
+    headers,
+    body: body ?? formData,
+    method: options.method,
+    signal: controller.signal
+  };
+  if (config.WITH_CREDENTIALS) {
+    request2.credentials = config.CREDENTIALS;
+  }
+  onCancel(() => controller.abort());
+  return await fetch(url, request2);
+};
+var getResponseHeader = (response, responseHeader) => {
+  if (responseHeader) {
+    const content = response.headers.get(responseHeader);
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return void 0;
+};
+var getResponseBody = async (response) => {
+  if (response.status !== 204) {
+    try {
+      const contentType = response.headers.get("Content-Type");
+      if (contentType) {
+        const jsonTypes = ["application/json", "application/problem+json"];
+        const isJSON = jsonTypes.some(
+          (type) => contentType.toLowerCase().startsWith(type)
+        );
+        if (isJSON) {
+          return await response.json();
+        } else {
+          return await response.text();
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  return void 0;
+};
+var catchErrorCodes = (options, result) => {
+  const errors = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    ...options.errors
+  };
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
+  }
+  if (!result.ok) {
+    throw new ApiError(options, result, "Generic Error");
+  }
+};
+var request = (config, options) => {
+  return new CancelablePromise(async (resolve9, reject, onCancel) => {
+    try {
+      const url = getUrl(config, options);
+      const formData = getFormData(options);
+      const body = getRequestBody(options);
+      const headers = await getHeaders(config, options);
+      if (!onCancel.isCancelled) {
+        const response = await sendRequest(
+          config,
+          options,
+          url,
+          body,
+          formData,
+          headers,
+          onCancel
+        );
+        const responseBody = await getResponseBody(response);
+        const responseHeader = getResponseHeader(
+          response,
+          options.responseHeader
+        );
+        let result;
+        if (isResponseSchemaV4(config, options)) {
+          result = parseResponseSchemaV4(
+            url,
+            response,
+            responseHeader,
+            responseBody
+          );
+        } else {
+          result = {
+            url,
+            ok: response.ok,
+            status: response.status,
+            statusText: response.statusText,
+            body: responseHeader ?? responseBody
+          };
+        }
+        catchErrorCodes(options, result);
+        resolve9(result.body);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+// ../containers-shared/src/client/services/ImageRegistriesService.ts
+var ImageRegistriesService = class {
+  /**
+   * Create an image registry protocol that resolves to multiple domains.
+   * @param requestBody
+   * @returns ImageRegistryProtocol The image registry protocol was created
+   * @throws ApiError
+   */
+  static createImageRegistryProtocol(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/registries/protos",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request that contains a specific constant code and details object about the error.`,
+        403: `The registry that is being added is not allowed`,
+        409: `Image registry protocol already exists`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * List all image registry protocols.
+   * @returns ImageRegistryProtocols The image registry protocols in the account
+   * @throws ApiError
+   */
+  static listImageRegistryProtocols() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/registries/protos",
+      errors: {
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * Modify an image registry protocol. The previous list of domains will be replaced by the ones you specify in this endpoint.
+   * @param requestBody
+   * @returns ImageRegistryProtocol The image registry protocol was modified
+   * @throws ApiError
+   */
+  static modifyImageRegistryProtocol(requestBody) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/registries/protos",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request that contains a specific constant code and details object about the error.`,
+        403: `The registry that is being added is not allowed`,
+        404: `Image registry protocol doesn't exist`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * Delete an image registry protocol. Be careful, if there is deployments running referencing this protocol they won't be able to pull the image.
+   * @param proto
+   * @returns EmptyResponse Image registry protocol was deleted successfully
+   * @throws ApiError
+   */
+  static deleteImageRegistryProto(proto) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/registries/protos/{proto}",
+      path: {
+        proto
+      },
+      errors: {
+        400: `The image registry protocol couldn't be deleted because it's referenced by a deployment or application`,
+        404: `Image registry protocol doesn't exist`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * Get a JWT to pull from the image registry
+   * Get a JWT to pull from the image registry specifying its domain
+   * @param domain
+   * @param requestBody
+   * @returns AccountRegistryToken Credentials with 'pull' or 'push' permissions to access the registry
+   * @throws ApiError
+   */
+  static generateImageRegistryCredentials(domain, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/registries/{domain}/credentials",
+      path: {
+        domain
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request that contains a specific constant code and details object about the error.`,
+        404: `The image registry does not exist`,
+        409: `The registry was configured as public, so credentials can not be generated`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * Delete a registry from the account
+   * Delete a registry from the account, this will make Cloudchamber unable to pull images from the registry
+   * @param domain
+   * @returns EmptyResponse The image registry is deleted
+   * @throws ApiError
+   */
+  static deleteImageRegistry(domain) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/registries/{domain}",
+      path: {
+        domain
+      },
+      errors: {
+        404: `The image registry does not exist`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * Get the list of configured registries in the account
+   * Get the list of configured registries in the account
+   * @returns CustomerImageRegistry The list of registries that are added in the account
+   * @throws ApiError
+   */
+  static listImageRegistries() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/registries",
+      errors: {
+        500: `There has been an internal error`
+      }
+    });
+  }
+  /**
+   * Add a new image registry configuration
+   * Add a new image registry into your account, so then Cloudflare can pull docker images with public key JWT authentication
+   * @param requestBody
+   * @returns CustomerImageRegistry Created a new image registry in the account
+   * @throws ApiError
+   */
+  static createImageRegistry(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/registries",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Image registry input is malformed, see the error details`,
+        403: `The registry that is being added is not allowed`,
+        409: `The image registry already exists in the account`,
+        500: `There has been an internal error`
+      }
+    });
+  }
+};
+
+// ../containers-shared/src/login.ts
+async function dockerLoginManagedRegistry(pathToDocker) {
+  const expirationMinutes = 15;
+  const credentials = await ImageRegistriesService.generateImageRegistryCredentials(
+    getCloudflareContainerRegistry(),
+    {
+      expiration_minutes: expirationMinutes,
+      permissions: [
+        "push" /* PUSH */,
+        "pull" /* PULL */
+      ]
+    }
+  );
+  const child = spawn2(
+    pathToDocker,
+    [
+      "login",
+      "--password-stdin",
+      "--username",
+      "v1",
+      getCloudflareContainerRegistry()
+    ],
+    { stdio: ["pipe", "inherit", "inherit"] }
+  ).on("error", (err) => {
+    throw err;
+  });
+  child.stdin.write(credentials.password);
+  child.stdin.end();
+  await new Promise((resolve9, reject) => {
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve9();
+      } else {
+        reject(new Error(`Login failed with code: ${code}`));
+      }
+    });
+  });
+}
+
+// ../containers-shared/src/utils.ts
+import { execFile, spawn as spawn4 } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync, statSync } from "fs";
+import path2 from "path";
+
+// ../containers-shared/src/inspect.ts
+import { spawn as spawn3 } from "child_process";
+async function dockerImageInspect(dockerPath, options) {
+  return new Promise((resolve9, reject) => {
+    const proc = spawn3(
+      dockerPath,
+      ["image", "inspect", options.imageTag, "--format", options.formatString],
+      {
+        stdio: ["ignore", "pipe", "pipe"]
+      }
+    );
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (chunk) => stdout += chunk);
+    proc.stderr.on("data", (chunk) => stderr += chunk);
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        return reject(
+          new Error(`failed inspecting image locally: ${stderr.trim()}`)
+        );
+      }
+      resolve9(stdout.trim());
+    });
+    proc.on("error", (err) => reject(err));
+  });
+}
+
+// ../containers-shared/src/utils.ts
+var runDockerCmd = (dockerPath, args, stdio) => {
+  let aborted = false;
+  let resolve9;
+  let reject;
+  const ready = new Promise((res, rej) => {
+    resolve9 = res;
+    reject = rej;
+  });
+  const child = spawn4(dockerPath, args, {
+    stdio: stdio ?? "inherit",
+    // We need to set detached to true so that the child process
+    // will control all of its child processed and we can kill
+    // all of them in case we need to abort the build process
+    detached: true
+  });
+  let errorHandled = false;
+  child.on("close", (code) => {
+    if (code === 0 || aborted) {
+      resolve9({ aborted });
+    } else if (!errorHandled) {
+      errorHandled = true;
+      reject(new Error(`Docker command exited with code: ${code}`));
+    }
+  });
+  child.on("error", (err) => {
+    if (!errorHandled) {
+      errorHandled = true;
+      reject(new Error(`Docker command failed: ${err.message}`));
+    }
+  });
+  return {
+    abort: () => {
+      aborted = true;
+      child.unref();
+      if (child.pid !== void 0) {
+        process.kill(-child.pid);
+      }
+    },
+    ready,
+    then: async (resolve10, reject2) => ready.then(resolve10).catch(reject2)
+  };
+};
+var runDockerCmdWithOutput = async (dockerPath, args) => {
+  return new Promise((resolve9, reject) => {
+    execFile(dockerPath, args, (error, stdout) => {
+      if (error) {
+        return reject(
+          new Error(
+            `Failed running docker command: ${error.message}. Command: ${dockerPath} ${args.join(" ")}`
+          )
+        );
+      }
+      return resolve9(stdout.trim());
+    });
+  });
+};
+var verifyDockerInstalled = async (dockerPath, isDev = true) => {
+  try {
+    await runDockerCmd(dockerPath, ["info"], ["inherit", "pipe", "pipe"]);
+  } catch {
+    throw new Error(
+      `The Docker CLI could not be launched. Please ensure that the Docker CLI is installed and the daemon is running.
+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 WRANGLER_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(path14) {
+  const stats = statSync(path14);
+  return stats.isDirectory();
+}
+var isDockerfile = (image, configPath) => {
+  const baseDir = configPath ? path2.dirname(configPath) : process.cwd();
+  const maybeDockerfile = path2.resolve(baseDir, image);
+  if (existsSync(maybeDockerfile)) {
+    if (isDir(maybeDockerfile)) {
+      throw new Error(
+        `${image} is a directory, you should specify a path to the Dockerfile`
+      );
+    }
+    return true;
+  }
+  const errorPrefix = `The image "${image}" does not appear to be a valid path to a Dockerfile, or a valid image registry path:
+`;
+  try {
+    new URL(`https://${image}`);
+  } catch (e) {
+    if (e instanceof Error) {
+      throw new Error(errorPrefix + e.message);
+    }
+    throw e;
+  }
+  const imageParts = image.split("/");
+  if (!imageParts[imageParts.length - 1]?.includes(":")) {
+    throw new Error(
+      errorPrefix + `If this is an image registry path, it needs to include at least a tag ':' (e.g: docker.io/httpd:1)`
+    );
+  }
+  if (image.includes("://")) {
+    throw new Error(
+      errorPrefix + `Image reference should not include the protocol part (e.g: docker.io/httpd:1, not https://docker.io/httpd:1)`
+    );
+  }
+  return false;
+};
+async function getContainerIdsByImageTags(dockerPath, imageTags) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const imageTag of imageTags) {
+    const containerIdsFromImage = await getContainerIdsFromImage(
+      dockerPath,
+      imageTag
+    );
+    containerIdsFromImage.forEach((id) => ids.add(id));
+  }
+  return Array.from(ids);
+}
+var getContainerIdsFromImage = async (dockerPath, ancestorImage) => {
+  const output = await runDockerCmdWithOutput(dockerPath, [
+    "ps",
+    "-a",
+    "--filter",
+    `ancestor=${ancestorImage}`,
+    "--format",
+    "{{.ID}}"
+  ]);
+  return output.split("\n").filter((line) => line.trim());
+};
+async function checkExposedPorts(dockerPath, options) {
+  const output = await dockerImageInspect(dockerPath, {
+    imageTag: options.imageTag,
+    formatString: "{{ len .Config.ExposedPorts }}"
+  });
+  if (output === "0") {
+    throw new Error(
+      `The container "${options.class_name}" does not expose any ports. In your Dockerfile, please expose any ports you intend to connect to.
+For additional information please see: https://developers.cloudflare.com/containers/local-dev/#exposing-ports.
+`
+    );
+  }
+}
+function generateContainerBuildId() {
+  return randomUUID().slice(0, 8);
+}
+
+// ../containers-shared/src/images.ts
+async function pullImage(dockerPath, options) {
+  await dockerLoginManagedRegistry(dockerPath);
+  const pull = runDockerCmd(dockerPath, [
+    "pull",
+    options.image,
+    // 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]);
+    }
+  });
+  return {
+    abort: () => {
+      pull.abort();
+    },
+    ready
+  };
+}
+async function prepareContainerImagesForDev(options) {
+  const {
+    dockerPath,
+    configPath,
+    containerOptions,
+    onContainerImagePreparationStart,
+    onContainerImagePreparationEnd
+  } = options;
+  let aborted = false;
+  if (process.platform === "win32") {
+    throw new Error(
+      "Local development with containers is currently not supported on Windows. You should use WSL instead. You can also set `enable_containers` to false if you do not need to develop the container part of your application."
+    );
+  }
+  await verifyDockerInstalled(dockerPath);
+  for (const options2 of containerOptions) {
+    if (isDockerfile(options2.image, configPath)) {
+      const build = await buildImage(dockerPath, options2, configPath);
+      onContainerImagePreparationStart({
+        containerOptions: options2,
+        abort: () => {
+          aborted = true;
+          build.abort();
+        }
+      });
+      await build.ready;
+      onContainerImagePreparationEnd({
+        containerOptions: options2
+      });
+    } else {
+      if (!isCloudflareRegistryLink(options2.image)) {
+        throw new Error(
+          `Image "${options2.image}" 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);
+      onContainerImagePreparationStart({
+        containerOptions: options2,
+        abort: () => {
+          aborted = true;
+          pull.abort();
+        }
+      });
+      await pull.ready;
+      onContainerImagePreparationEnd({
+        containerOptions: options2
+      });
+    }
+    if (!aborted) {
+      await checkExposedPorts(dockerPath, options2);
+    }
+  }
+}
 
 // ../workers-shared/asset-worker/src/utils/rules-engine.ts
 var ESCAPE_REGEX_CHARACTERS = /[-/\\^$*+?.()|[\]{}]/g;
@@ -499,8 +1641,8 @@ var generateGlobOnlyRuleRegExp = (rule) => {
   rule = "^" + rule + "$";
   return RegExp(rule);
 };
-var generateStaticRoutingRuleMatcher = (rules) => ({ request }) => {
-  const { pathname } = new URL(request.url);
+var generateStaticRoutingRuleMatcher = (rules) => ({ request: request2 }) => {
+  const { pathname } = new URL(request2.url);
   for (const rule of rules) {
     try {
       const regExp = generateGlobOnlyRuleRegExp(rule);
@@ -761,7 +1903,7 @@ function getBtoa() {
     };
   }
 }
-var btoa = /* @__PURE__ */ getBtoa();
+var btoa2 = /* @__PURE__ */ getBtoa();
 var SourceMap = class {
   constructor(properties) {
     this.version = 3;
@@ -781,7 +1923,7 @@ var SourceMap = class {
     return JSON.stringify(this);
   }
   toUrl() {
-    return "data:application/json;charset=utf-8;base64," + btoa(this.toString());
+    return "data:application/json;charset=utf-8;base64," + btoa2(this.toString());
   }
 };
 function guessIndent(code) {
@@ -1619,7 +2761,7 @@ function createModuleReference(type, id) {
 }
 
 // src/asset-config.ts
-import * as path from "node:path";
+import * as path3 from "node:path";
 
 // ../workers-shared/utils/configuration/constructConfiguration.ts
 import { relative } from "node:path";
@@ -1755,11 +2897,11 @@ ${invalidHeaderRulesList}`
 }
 
 // ../workers-shared/utils/configuration/validateURL.ts
-var extractPathname = (path12 = "/", includeSearch, includeHash) => {
-  if (!path12.startsWith("/")) {
-    path12 = `/${path12}`;
+var extractPathname = (path14 = "/", includeSearch, includeHash) => {
+  if (!path14.startsWith("/")) {
+    path14 = `/${path14}`;
   }
-  const url = new URL(`//${path12}`, "relative://");
+  const url = new URL(`//${path14}`, "relative://");
   return `${url.pathname}${includeSearch ? url.search : ""}${includeHash ? url.hash : ""}`;
 };
 var URL_REGEX = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/;
@@ -1792,8 +2934,8 @@ var validateUrl = (token, onlyRelative = false, disallowPorts = false, includeSe
     if (!token.startsWith("/") && onlyRelative) {
       token = `/${token}`;
     }
-    const path12 = PATH_REGEX.exec(token);
-    if (path12) {
+    const path14 = PATH_REGEX.exec(token);
+    if (path14) {
       try {
         return [extractPathname(token, includeSearch, includeHash), void 0];
       } catch {
@@ -1854,7 +2996,7 @@ function parseHeaders(input, {
           });
         }
       }
-      const [path12, pathError] = validateUrl(line, false, true);
+      const [path14, pathError] = validateUrl(line, false, true);
       if (pathError) {
         invalid.push({
           line,
@@ -1865,7 +3007,7 @@ function parseHeaders(input, {
         continue;
       }
       rule = {
-        path: path12,
+        path: path14,
         line,
         headers: {},
         unsetHeaders: []
@@ -2076,7 +3218,7 @@ var REDIRECTS_FILENAME = "_redirects";
 var HEADERS_FILENAME = "_headers";
 
 // ../workers-shared/utils/helpers.ts
-import { readFileSync } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
 var import_ignore = __toESM(require_ignore());
 var import_mime = __toESM(require_mime());
 function thrownIsDoesNotExistError(thrown) {
@@ -2084,7 +3226,7 @@ function thrownIsDoesNotExistError(thrown) {
 }
 function maybeGetFile(filePath) {
   try {
-    return readFileSync(filePath, "utf8");
+    return readFileSync2(filePath, "utf8");
   } catch (e) {
     if (!thrownIsDoesNotExistError(e)) {
       throw e;
@@ -2440,8 +3582,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (params) => {
-  const { data: data2, path: path12, errorMaps, issueData } = params;
-  const fullPath = [...path12, ...issueData.path || []];
+  const { data: data2, path: path14, errorMaps, issueData } = params;
+  const fullPath = [...path14, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -2540,11 +3682,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, path12, key) {
+  constructor(parent, value, path14, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path12;
+    this._path = path14;
     this._key = key;
   }
   get path() {
@@ -5940,22 +7082,22 @@ function getAssetsConfig(resolvedPluginConfig, entryWorkerConfig, resolvedConfig
   };
 }
 function getRedirectsConfigPath(config) {
-  return path.join(config.publicDir, REDIRECTS_FILENAME);
+  return path3.join(config.publicDir, REDIRECTS_FILENAME);
 }
 function getHeadersConfigPath(config) {
-  return path.join(config.publicDir, HEADERS_FILENAME);
+  return path3.join(config.publicDir, HEADERS_FILENAME);
 }
 
 // src/build.ts
 import assert from "node:assert";
 import * as fs from "node:fs";
-import * as path2 from "node:path";
+import * as path4 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 = path2.resolve(builder.config.root, "index.html");
+    const defaultHtmlPath = path4.resolve(builder.config.root, "index.html");
     const hasClientEntry = clientEnvironment.config.build.rollupOptions.input || fs.existsSync(defaultHtmlPath);
     if (resolvedPluginConfig.type === "assets-only") {
       if (hasClientEntry) {
@@ -5981,7 +7123,7 @@ function createBuildApp(resolvedPluginConfig) {
       entryWorkerEnvironment,
       `No "${entryWorkerEnvironmentName}" environment`
     );
-    const entryWorkerBuildDirectory = path2.resolve(
+    const entryWorkerBuildDirectory = path4.resolve(
       builder.config.root,
       entryWorkerEnvironment.config.build.outDir
     );
@@ -5992,7 +7134,7 @@ function createBuildApp(resolvedPluginConfig) {
     } else if (importedAssetPaths.size || getHasPublicAssets(builder.config)) {
       await fallbackBuild(builder, clientEnvironment);
     } else {
-      const entryWorkerConfigPath = path2.join(
+      const entryWorkerConfigPath = path4.join(
         entryWorkerBuildDirectory,
         "wrangler.json"
       );
@@ -6003,21 +7145,21 @@ function createBuildApp(resolvedPluginConfig) {
       fs.writeFileSync(entryWorkerConfigPath, JSON.stringify(workerConfig));
       return;
     }
-    const clientBuildDirectory = path2.resolve(
+    const clientBuildDirectory = path4.resolve(
       builder.config.root,
       clientEnvironment.config.build.outDir
     );
     const movedAssetPaths = [];
     for (const assetPath of importedAssetPaths) {
-      const src = path2.join(entryWorkerBuildDirectory, assetPath);
-      const dest = path2.join(clientBuildDirectory, assetPath);
+      const src = path4.join(entryWorkerBuildDirectory, assetPath);
+      const dest = path4.join(clientBuildDirectory, assetPath);
       if (!fs.existsSync(src)) {
         continue;
       }
       if (fs.existsSync(dest)) {
         fs.unlinkSync(src);
       } else {
-        const destDir = path2.dirname(dest);
+        const destDir = path4.dirname(dest);
         fs.mkdirSync(destDir, { recursive: true });
         fs.renameSync(src, dest);
         movedAssetPaths.push(dest);
@@ -6028,7 +7170,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(path2.relative(builder.config.root, assetPath))
+            (assetPath) => colors.dim(path4.relative(builder.config.root, assetPath))
           )
         ].join("\n")
       );
@@ -6058,7 +7200,7 @@ async function fallbackBuild(builder, environment) {
     }
   };
   await builder.build(environment);
-  const fallbackEntryPath = path2.resolve(
+  const fallbackEntryPath = path4.resolve(
     builder.config.root,
     environment.config.build.outDir,
     fallbackEntryName
@@ -6067,7 +7209,7 @@ async function fallbackBuild(builder, environment) {
 }
 function loadViteManifest(directory) {
   const contents = fs.readFileSync(
-    path2.resolve(directory, ".vite", "manifest.json"),
+    path4.resolve(directory, ".vite", "manifest.json"),
     "utf-8"
   );
   return JSON.parse(contents);
@@ -6086,7 +7228,7 @@ import * as vite2 from "vite";
 // src/node-js-compat.ts
 import assert3 from "node:assert";
 import { builtinModules as builtinModules2 } from "node:module";
-import path4 from "node:path";
+import path6 from "node:path";
 import { cloudflare } from "@cloudflare/unenv-preset";
 import { getNodeCompat } from "miniflare";
 
@@ -11619,7 +12761,7 @@ Parser.acorn = {
 
 // ../../node_modules/.pnpm/mlly@1.7.4/node_modules/mlly/dist/index.mjs
 import { builtinModules, createRequire } from "node:module";
-import fs2, { realpathSync, statSync, promises } from "node:fs";
+import fs2, { realpathSync, statSync as statSync2, promises } from "node:fs";
 
 // ../../node_modules/.pnpm/ufo@1.5.4/node_modules/ufo/dist/index.mjs
 var r = String.fromCharCode;
@@ -11638,17 +12780,17 @@ function withTrailingSlash(input = "", respectQueryAndFragment) {
   if (hasTrailingSlash(input, true)) {
     return input || "/";
   }
-  let path12 = input;
+  let path14 = input;
   let fragment = "";
   const fragmentIndex = input.indexOf("#");
   if (fragmentIndex >= 0) {
-    path12 = input.slice(0, fragmentIndex);
+    path14 = input.slice(0, fragmentIndex);
     fragment = input.slice(fragmentIndex);
-    if (!path12) {
+    if (!path14) {
       return fragment;
     }
   }
-  const [s0, ...s] = path12.split("?");
+  const [s0, ...s] = path14.split("?");
   return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -11678,12 +12820,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 path3, { dirname as dirname3 } from "node:path";
+import path5, { 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(path12) {
-  return path12.replace(/\\/g, "/");
+function normalizeSlash(path14) {
+  return path14.replace(/\\/g, "/");
 }
 var own$1 = {}.hasOwnProperty;
 var classRegExp = /^([A-Z][a-z\d]*)+$/;
@@ -11784,8 +12926,8 @@ codes.ERR_INVALID_MODULE_SPECIFIER = createError(
    * @param {string} reason
    * @param {string} [base]
    */
-  (request, reason, base = void 0) => {
-    return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
+  (request2, reason, base = void 0) => {
+    return `Invalid module "${request2}" ${reason}${base ? ` imported from ${base}` : ""}`;
   },
   TypeError
 );
@@ -11796,8 +12938,8 @@ codes.ERR_INVALID_PACKAGE_CONFIG = createError(
    * @param {string} [base]
    * @param {string} [message]
    */
-  (path12, base, message) => {
-    return `Invalid package config ${path12}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  (path14, base, message) => {
+    return `Invalid package config ${path14}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
   },
   Error
 );
@@ -11829,8 +12971,8 @@ codes.ERR_MODULE_NOT_FOUND = createError(
    * @param {string} base
    * @param {boolean} [exactUrl]
    */
-  (path12, base, exactUrl = false) => {
-    return `Cannot find ${exactUrl ? "module" : "package"} '${path12}' imported from ${base}`;
+  (path14, base, exactUrl = false) => {
+    return `Cannot find ${exactUrl ? "module" : "package"} '${path14}' imported from ${base}`;
   },
   Error
 );
@@ -11881,8 +13023,8 @@ codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
    * @param {string} extension
    * @param {string} path
    */
-  (extension, path12) => {
-    return `Unknown file extension "${extension}" for ${path12}`;
+  (extension, path14) => {
+    return `Unknown file extension "${extension}" for ${path14}`;
   },
   TypeError
 );
@@ -12027,7 +13169,7 @@ function read(jsonPath, { base, specifier }) {
   }
   let string;
   try {
-    string = fs2.readFileSync(path3.toNamespacedPath(jsonPath), "utf8");
+    string = fs2.readFileSync(path5.toNamespacedPath(jsonPath), "utf8");
   } catch (error) {
     const exception = (
       /** @type {ErrnoException} */
@@ -12213,14 +13355,14 @@ var patternRegEx = /\*/g;
 var encodedSeparatorRegEx = /%2f|%5c/i;
 var emittedPackageWarnings = /* @__PURE__ */ new Set();
 var doubleSlashRegEx = /[/\\]{2}/;
-function emitInvalidSegmentDeprecation(target2, request, match, packageJsonUrl, internal, base, isTarget) {
+function emitInvalidSegmentDeprecation(target2, request2, match, packageJsonUrl, internal, base, isTarget) {
   if (process$1.noDeprecation) {
     return;
   }
   const pjsonPath = fileURLToPath$1(packageJsonUrl);
-  const double = doubleSlashRegEx.exec(isTarget ? target2 : request) !== null;
+  const double = doubleSlashRegEx.exec(isTarget ? target2 : request2) !== null;
   process$1.emitWarning(
-    `Use of deprecated ${double ? "double slash" : "leading or trailing slash matching"} resolving "${target2}" for module request "${request}" ${request === match ? "" : `matched to "${match}" `}in the "${internal ? "imports" : "exports"}" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${fileURLToPath$1(base)}` : ""}.`,
+    `Use of deprecated ${double ? "double slash" : "leading or trailing slash matching"} resolving "${target2}" for module request "${request2}" ${request2 === match ? "" : `matched to "${match}" `}in the "${internal ? "imports" : "exports"}" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${fileURLToPath$1(base)}` : ""}.`,
     "DeprecationWarning",
     "DEP0166"
   );
@@ -12243,7 +13385,7 @@ Default "index" lookups for the main are deprecated for ES modules.`,
       "DeprecationWarning",
       "DEP0151"
     );
-  } else if (path3.resolve(packagePath, main) !== urlPath) {
+  } else if (path5.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
@@ -12254,14 +13396,14 @@ Default "index" lookups for the main are deprecated for ES modules.`,
     );
   }
 }
-function tryStatSync(path12) {
+function tryStatSync(path14) {
   try {
-    return statSync(path12);
+    return statSync2(path14);
   } catch {
   }
 }
 function fileExists(url) {
-  const stats = statSync(url, { throwIfNoEntry: false });
+  const stats = statSync2(url, { throwIfNoEntry: false });
   const isFile = stats ? stats.isFile() : void 0;
   return isFile === null || isFile === void 0 ? false : isFile;
 }
@@ -12350,7 +13492,7 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
   {
     const real = realpathSync(filePath);
     const { search, hash } = resolved;
-    resolved = pathToFileURL$1(real + (filePath.endsWith(path3.sep) ? "/" : ""));
+    resolved = pathToFileURL$1(real + (filePath.endsWith(path5.sep) ? "/" : ""));
     resolved.search = search;
     resolved.hash = hash;
   }
@@ -12370,10 +13512,10 @@ function exportsNotFound(subpath, packageJsonUrl, base) {
     base && fileURLToPath$1(base)
   );
 }
-function throwInvalidSubpath(request, match, packageJsonUrl, internal, base) {
+function throwInvalidSubpath(request2, match, packageJsonUrl, internal, base) {
   const reason = `request is not a valid match in pattern "${match}" for the "${internal ? "imports" : "exports"}" resolution of ${fileURLToPath$1(packageJsonUrl)}`;
   throw new ERR_INVALID_MODULE_SPECIFIER(
-    request,
+    request2,
     reason,
     base && fileURLToPath$1(base)
   );
@@ -12413,7 +13555,7 @@ function resolvePackageTargetString(target2, subpath, match, packageJsonUrl, bas
   if (invalidSegmentRegEx.exec(target2.slice(2)) !== null) {
     if (deprecatedInvalidSegmentRegEx.exec(target2.slice(2)) === null) {
       if (!isPathMap) {
-        const request = pattern ? match.replace("*", () => subpath) : match + subpath;
+        const request2 = pattern ? match.replace("*", () => subpath) : match + subpath;
         const resolvedTarget = pattern ? RegExpPrototypeSymbolReplace.call(
           patternRegEx,
           target2,
@@ -12421,7 +13563,7 @@ function resolvePackageTargetString(target2, subpath, match, packageJsonUrl, bas
         ) : target2;
         emitInvalidSegmentDeprecation(
           resolvedTarget,
-          request,
+          request2,
           match,
           packageJsonUrl,
           internal,
@@ -12440,7 +13582,7 @@ function resolvePackageTargetString(target2, subpath, match, packageJsonUrl, bas
     throw invalidPackageTarget(match, target2, packageJsonUrl, internal, base);
   if (subpath === "") return resolved;
   if (invalidSegmentRegEx.exec(subpath) !== null) {
-    const request = pattern ? match.replace("*", () => subpath) : match + subpath;
+    const request2 = pattern ? match.replace("*", () => subpath) : match + subpath;
     if (deprecatedInvalidSegmentRegEx.exec(subpath) === null) {
       if (!isPathMap) {
         const resolvedTarget = pattern ? RegExpPrototypeSymbolReplace.call(
@@ -12450,7 +13592,7 @@ function resolvePackageTargetString(target2, subpath, match, packageJsonUrl, bas
         ) : target2;
         emitInvalidSegmentDeprecation(
           resolvedTarget,
-          request,
+          request2,
           match,
           packageJsonUrl,
           internal,
@@ -12459,7 +13601,7 @@ function resolvePackageTargetString(target2, subpath, match, packageJsonUrl, bas
         );
       }
     } else {
-      throwInvalidSubpath(request, match, packageJsonUrl, internal, base);
+      throwInvalidSubpath(request2, match, packageJsonUrl, internal, base);
     }
   }
   if (pattern) {
@@ -12953,7 +14095,7 @@ function _resolve(id, options = {}) {
   }
   if (isAbsolute(id)) {
     try {
-      const stat2 = statSync(id);
+      const stat2 = statSync2(id);
       if (stat2.isFile()) {
         return pathToFileURL(id);
       }
@@ -13061,8 +14203,8 @@ function isNodeAls(workerConfig) {
     workerConfig.compatibility_flags ?? []
   ).mode === "als";
 }
-function isNodeAlsModule(path12) {
-  return /^(node:)?async_hooks$/.test(path12);
+function isNodeAlsModule(path14) {
+  return /^(node:)?async_hooks$/.test(path14);
 }
 var injectsByModule = /* @__PURE__ */ new Map();
 var virtualModulePathToSpecifier = /* @__PURE__ */ new Map();
@@ -13169,7 +14311,7 @@ var NodeJsCompatWarnings = class {
 `;
       this.sources.forEach((importers, source) => {
         importers.forEach((importer) => {
-          message += ` - "${source}" imported from "${path4.relative(this.resolvedViteConfig.root, importer)}"
+          message += ` - "${source}" imported from "${path6.relative(this.resolvedViteConfig.root, importer)}"
 `;
         });
       });
@@ -13193,7 +14335,7 @@ var additionalModuleGlobalRE = new RegExp(
 var VITE_DEV_METADATA_HEADER = "__VITE_DEV_METADATA__";
 
 // src/utils.ts
-import * as path5 from "node:path";
+import * as path7 from "node:path";
 import { createRequest, sendResponse } from "@mjackson/node-fetch-server";
 import {
   Request as MiniflareRequest,
@@ -13201,20 +14343,20 @@ import {
 } from "miniflare";
 function getOutputDirectory(userConfig, environmentName) {
   const rootOutputDirectory = userConfig.build?.outDir ?? "dist";
-  return userConfig.environments?.[environmentName]?.build?.outDir ?? path5.join(rootOutputDirectory, environmentName);
+  return userConfig.environments?.[environmentName]?.build?.outDir ?? path7.join(rootOutputDirectory, environmentName);
 }
 var postfixRE = /[?#].*$/;
 function cleanUrl(url) {
   return url.replace(postfixRE, "");
 }
-function withTrailingSlash2(path12) {
-  return path12.endsWith("/") ? path12 : `${path12}/`;
+function withTrailingSlash2(path14) {
+  return path14.endsWith("/") ? path14 : `${path14}/`;
 }
 function createRequestHandler(handler) {
   return async (req, res, next) => {
     try {
-      const request = createRequest(req, res);
-      let response = await handler(toMiniflareRequest(request), req);
+      const request2 = createRequest(req, res);
+      let response = await handler(toMiniflareRequest(request2), req);
       if (req.httpVersionMajor === 2) {
         response = new MiniflareResponse(response.body, response);
         response.headers.delete("transfer-encoding");
@@ -13225,19 +14367,19 @@ function createRequestHandler(handler) {
     }
   };
 }
-function toMiniflareRequest(request) {
-  const host = request.headers.get("Host");
+function toMiniflareRequest(request2) {
+  const host = request2.headers.get("Host");
   if (host) {
-    request.headers.set("X-Forwarded-Host", host);
+    request2.headers.set("X-Forwarded-Host", host);
   }
-  const secFetchMode = request.headers.get("Sec-Fetch-Mode");
+  const secFetchMode = request2.headers.get("Sec-Fetch-Mode");
   if (secFetchMode) {
-    request.headers.set("X-Mf-Sec-Fetch-Mode", secFetchMode);
+    request2.headers.set("X-Mf-Sec-Fetch-Mode", secFetchMode);
   }
-  return new MiniflareRequest(request.url, {
-    method: request.method,
-    headers: [["accept-encoding", "identity"], ...request.headers],
-    body: request.body,
+  return new MiniflareRequest(request2.url, {
+    method: request2.method,
+    headers: [["accept-encoding", "identity"], ...request2.headers],
+    body: request2.body,
     duplex: "half"
   });
 }
@@ -13355,7 +14497,9 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
       copyPublicDir: false,
       ssr: true,
       rollupOptions: {
-        input: workerConfig.main
+        input: workerConfig.main,
+        // rolldown-only option
+        ..."rolldownVersion" in vite2 ? { platform: "neutral" } : {}
       }
     },
     optimizeDeps: {
@@ -13397,6 +14541,27 @@ function initRunners(resolvedPluginConfig, viteDevServer, miniflare2) {
   );
 }
 
+// src/containers.ts
+function getDockerPath() {
+  const defaultDockerPath = "docker";
+  const dockerPathEnvVar = "WRANGLER_DOCKER_BIN";
+  return process.env[dockerPathEnvVar] || defaultDockerPath;
+}
+async function removeContainersByIds(dockerPath, containerIds) {
+  try {
+    if (containerIds.length === 0) {
+      return;
+    }
+    await runDockerCmd(
+      dockerPath,
+      ["rm", "--force", ...containerIds],
+      ["inherit", "pipe", "pipe"]
+    );
+  } catch (error) {
+    return;
+  }
+}
+
 // src/debugging.ts
 import assert5 from "node:assert";
 import getPort, { portNumbers } from "get-port";
@@ -13480,11 +14645,11 @@ function getDebugPathHtml(workerNames, inspectorPort) {
 // src/deploy-config.ts
 import assert6 from "node:assert";
 import * as fs3 from "node:fs";
-import * as path6 from "node:path";
+import * as path8 from "node:path";
 import "vite";
 import { unstable_readConfig } from "wrangler";
 function getDeployConfigPath(root) {
-  return path6.resolve(root, ".wrangler", "deploy", "config.json");
+  return path8.resolve(root, ".wrangler", "deploy", "config.json");
 }
 function getWorkerConfigs(root) {
   const deployConfigPath = getDeployConfigPath(root);
@@ -13495,22 +14660,22 @@ function getWorkerConfigs(root) {
     { configPath: deployConfig.configPath },
     ...deployConfig.auxiliaryWorkers
   ].map(({ configPath }) => {
-    const resolvedConfigPath = path6.resolve(
-      path6.dirname(deployConfigPath),
+    const resolvedConfigPath = path8.resolve(
+      path8.dirname(deployConfigPath),
       configPath
     );
     return unstable_readConfig({ config: resolvedConfigPath });
   });
 }
 function getRelativePathToWorkerConfig(deployConfigDirectory, root, outputDirectory) {
-  return path6.relative(
+  return path8.relative(
     deployConfigDirectory,
-    path6.resolve(root, outputDirectory, "wrangler.json")
+    path8.resolve(root, outputDirectory, "wrangler.json")
   );
 }
 function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
   const deployConfigPath = getDeployConfigPath(resolvedViteConfig.root);
-  const deployConfigDirectory = path6.dirname(deployConfigPath);
+  const deployConfigDirectory = path8.dirname(deployConfigPath);
   fs3.mkdirSync(deployConfigDirectory, { recursive: true });
   if (resolvedPluginConfig.type === "assets-only") {
     const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
@@ -13561,9 +14726,9 @@ function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
 
 // src/dev-vars.ts
 import * as fs4 from "node:fs";
-import * as path7 from "node:path";
+import * as path9 from "node:path";
 function getDotDevDotVarsContent(configPath, cloudflareEnv) {
-  const configDir = path7.dirname(configPath);
+  const configDir = path9.dirname(configPath);
   const defaultDotDevDotVarsPath = `${configDir}/.dev.vars`;
   const inputDotDevDotVarsPath = `${defaultDotDevDotVarsPath}${cloudflareEnv ? `.${cloudflareEnv}` : ""}`;
   const targetPath = fs4.existsSync(inputDotDevDotVarsPath) ? inputDotDevDotVarsPath : fs4.existsSync(defaultDotDevDotVarsPath) ? defaultDotDevDotVarsPath : null;
@@ -13575,7 +14740,7 @@ function getDotDevDotVarsContent(configPath, cloudflareEnv) {
 }
 function hasDotDevDotVarsFileChanged(resolvedPluginConfig, changedFilePath) {
   return [...resolvedPluginConfig.configPaths].some((configPath) => {
-    const dotDevDotVars = path7.join(path7.dirname(configPath), ".dev.vars");
+    const dotDevDotVars = path9.join(path9.dirname(configPath), ".dev.vars");
     if (dotDevDotVars === changedFilePath) {
       return true;
     }
@@ -13591,7 +14756,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 path8 from "node:path";
+import * as path10 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import {
   getDefaultDevRegistryPath,
@@ -13613,7 +14778,7 @@ function getPersistenceRoot(root, persistState) {
     return;
   }
   const defaultPersistPath = ".wrangler/state";
-  const persistPath = path8.resolve(
+  const persistPath = path10.resolve(
     root,
     typeof persistState === "object" ? persistState.path : defaultPersistPath,
     "v3"
@@ -13726,7 +14891,13 @@ function logUnknownTails(tails, userWorkers, log) {
   }
 }
 var remoteProxySessionsDataMap = /* @__PURE__ */ new Map();
-async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspectorPort) {
+async function getDevMiniflareOptions(config) {
+  const {
+    resolvedPluginConfig,
+    viteDevServer,
+    inspectorPort,
+    containerBuildId
+  } = config;
   const resolvedViteConfig = viteDevServer.config;
   const entryWorkerConfig = getEntryWorkerConfig(resolvedPluginConfig);
   const assetsConfig = getAssetsConfig(
@@ -13742,7 +14913,7 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
       modules: [
         {
           type: "ESModule",
-          path: path8.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
+          path: path10.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
           contents: fs5.readFileSync(
             fileURLToPath2(new URL(ROUTER_WORKER_PATH, import.meta.url))
           )
@@ -13765,7 +14936,7 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
       modules: [
         {
           type: "ESModule",
-          path: path8.join(miniflareModulesRoot, ASSET_WORKER_PATH),
+          path: path10.join(miniflareModulesRoot, ASSET_WORKER_PATH),
           contents: fs5.readFileSync(
             fileURLToPath2(new URL(ASSET_WORKER_PATH, import.meta.url))
           )
@@ -13775,8 +14946,8 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
         CONFIG: assetsConfig
       },
       serviceBindings: {
-        __VITE_HTML_EXISTS__: async (request) => {
-          const { pathname } = new URL(request.url);
+        __VITE_HTML_EXISTS__: async (request2) => {
+          const { pathname } = new URL(request2.url);
           if (pathname.endsWith(".html")) {
             const { root, publicDir } = resolvedViteConfig;
             const publicDirInRoot = publicDir.startsWith(
@@ -13786,8 +14957,8 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
             if (publicDirInRoot && pathname.startsWith(publicPath)) {
               return MiniflareResponse2.json(null);
             }
-            const publicDirFilePath = path8.join(publicDir, pathname);
-            const rootDirFilePath = path8.join(root, pathname);
+            const publicDirFilePath = path10.join(publicDir, pathname);
+            const rootDirFilePath = path10.join(root, pathname);
             for (const resolvedPath of [publicDirFilePath, rootDirFilePath]) {
               try {
                 const stats = await fsp.stat(resolvedPath);
@@ -13802,11 +14973,11 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
           }
           return MiniflareResponse2.json(null);
         },
-        __VITE_FETCH_HTML__: async (request) => {
-          const { pathname } = new URL(request.url);
+        __VITE_FETCH_HTML__: async (request2) => {
+          const { pathname } = new URL(request2.url);
           const { root, publicDir } = resolvedViteConfig;
           const isInPublicDir = pathname.startsWith(PUBLIC_DIR_PREFIX);
-          const resolvedPath = isInPublicDir ? path8.join(publicDir, pathname.slice(PUBLIC_DIR_PREFIX.length)) : path8.join(root, pathname);
+          const resolvedPath = isInPublicDir ? path10.join(publicDir, pathname.slice(PUBLIC_DIR_PREFIX.length)) : path10.join(root, pathname);
           try {
             let html = await fsp.readFile(resolvedPath, "utf-8");
             if (!isInPublicDir) {
@@ -13850,7 +15021,8 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
           resolvedPluginConfig.cloudflareEnv,
           {
             remoteProxyConnectionString: remoteProxySessionData?.session?.remoteProxyConnectionString,
-            remoteBindingsEnabled: resolvedPluginConfig.experimental.remoteBindings
+            remoteBindingsEnabled: resolvedPluginConfig.experimental.remoteBindings,
+            containerBuildId
           }
         );
         const { externalWorkers: externalWorkers2 } = miniflareWorkerOptions;
@@ -13877,8 +15049,8 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
                   }
                 }
               } : {},
-              __VITE_INVOKE_MODULE__: async (request) => {
-                const payload = await request.json();
+              __VITE_INVOKE_MODULE__: async (request2) => {
+                const payload = await request2.json();
                 const invokePayloadData = payload.data;
                 assert7(
                   invokePayloadData.name === "fetchModule",
@@ -13979,12 +15151,12 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
           modules: [
             {
               type: "ESModule",
-              path: path8.join(miniflareModulesRoot, WRAPPER_PATH),
+              path: path10.join(miniflareModulesRoot, WRAPPER_PATH),
               contents: wrappers.join("\n")
             },
             {
               type: "ESModule",
-              path: path8.join(miniflareModulesRoot, RUNNER_PATH),
+              path: path10.join(miniflareModulesRoot, RUNNER_PATH),
               contents: fs5.readFileSync(
                 fileURLToPath2(new URL(RUNNER_PATH, import.meta.url))
               )
@@ -13994,8 +15166,8 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
         };
       })
     ],
-    async unsafeModuleFallbackService(request) {
-      const url = new URL(request.url);
+    async unsafeModuleFallbackService(request2) {
+      const url = new URL(request2.url);
       const rawSpecifier = url.searchParams.get("rawSpecifier");
       assert7(
         rawSpecifier,
@@ -14039,8 +15211,8 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
 }
 function getPreviewModules(main, modulesRules) {
   assert7(modulesRules, `Unexpected error: 'modulesRules' is undefined`);
-  const rootPath = path8.dirname(main);
-  const entryPath = path8.basename(main);
+  const rootPath = path10.dirname(main);
+  const entryPath = path10.basename(main);
   return {
     rootPath,
     modules: [
@@ -14049,9 +15221,9 @@ function getPreviewModules(main, modulesRules) {
         path: entryPath
       },
       ...modulesRules.flatMap(
-        ({ type, include }) => globSync(include, { cwd: rootPath, ignore: entryPath }).map((path12) => ({
+        ({ type, include }) => globSync(include, { cwd: rootPath, ignore: entryPath }).map((path14) => ({
           type,
-          path: path12
+          path: path14
         }))
       )
     ]
@@ -14161,7 +15333,7 @@ function miniflareLogLevelFromViteLogLevel(level = "info") {
 
 // src/plugin-config.ts
 import assert9 from "node:assert";
-import * as path10 from "node:path";
+import * as path12 from "node:path";
 
 // ../workers-shared/utils/configuration/parseStaticRouting.ts
 function parseStaticRouting(input) {
@@ -14245,7 +15417,7 @@ import * as vite5 from "vite";
 // src/workers-configs.ts
 import assert8 from "node:assert";
 import * as fs6 from "node:fs";
-import * as path9 from "node:path";
+import * as path11 from "node:path";
 import { unstable_readConfig as unstable_readConfig2 } from "wrangler";
 var nonApplicableWorkerConfigs = {
   /**
@@ -14337,7 +15509,7 @@ function getWarningForWorkersConfigs(configs) {
     const lines2 = [
       `
 
-\x1B[43mWARNING\x1B[0m: your worker config${configs.entryWorker.config.configPath ? ` (at \`${path9.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 \`${path11.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("");
@@ -14351,7 +15523,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 \`${path9.relative("", workerConfig.config.configPath)}\`)` : ""}`
+        `  - (${isEntryWorker ? "entry" : "auxiliary"}) worker${workerConfig.config.name ? ` "${workerConfig.config.name}"` : ""}${workerConfig.config.configPath ? ` (config at \`${path11.relative("", workerConfig.config.configPath)}\`)` : ""}`
       );
       nonApplicableLines.forEach((line) => lines.push(line));
     }
@@ -14452,10 +15624,10 @@ function getWorkerConfig(configPath, env2, opts) {
 }
 function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliaryWorker = false) {
   if (requestedConfigPath) {
-    const configPath2 = path9.resolve(root, requestedConfigPath);
+    const configPath2 = path11.resolve(root, requestedConfigPath);
     const forAuxiliaryWorkerErrorMessage = isForAuxiliaryWorker ? " requested for one of your auxiliary workers" : "";
     const errorMessagePrefix = `The provided configPath (${configPath2})${forAuxiliaryWorkerErrorMessage}`;
-    const fileExtension = path9.extname(configPath2).slice(1);
+    const fileExtension = path11.extname(configPath2).slice(1);
     if (!allowedWranglerConfigExtensions.includes(fileExtension)) {
       const foundExtensionMessage = !fileExtension ? "no extension found" : `"${fileExtension}" found`;
       throw new Error(
@@ -14489,7 +15661,7 @@ function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliar
 }
 function findWranglerConfig(root) {
   for (const extension of allowedWranglerConfigExtensions) {
-    const configPath = path9.join(root, `wrangler.${extension}`);
+    const configPath = path11.join(root, `wrangler.${extension}`);
     if (fs6.existsSync(configPath)) {
       return configPath;
     }
@@ -14507,7 +15679,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     inspectorPort: pluginConfig.inspectorPort,
     experimental: pluginConfig.experimental ?? {}
   };
-  const root = userConfig.root ? path10.resolve(userConfig.root) : process.cwd();
+  const root = userConfig.root ? path12.resolve(userConfig.root) : process.cwd();
   if (viteEnv.isPreview) {
     return {
       ...shared,
@@ -14623,10 +15795,10 @@ function validateWorkerEnvironmentOptions(resolvedPluginConfig, resolvedViteConf
       environmentOptions,
       `Missing environment config for "${environmentName}"`
     );
-    const { resolve: resolve8 } = environmentOptions;
+    const { resolve: resolve9 } = environmentOptions;
     const disallowedEnvironmentOptions = {};
-    if (resolve8.external === true || resolve8.external.length) {
-      disallowedEnvironmentOptions.resolveExternal = resolve8.external;
+    if (resolve9.external === true || resolve9.external.length) {
+      disallowedEnvironmentOptions.resolveExternal = resolve9.external;
     }
     if (Object.keys(disallowedEnvironmentOptions).length) {
       disallowedEnvironmentOptionsMap.set(
@@ -14658,16 +15830,16 @@ function handleWebSocket(httpServer, getFetcher) {
   const nodeWebSocket = new WebSocketServer({ noServer: true });
   httpServer.on(
     "upgrade",
-    async (request, socket, head) => {
-      const url = new URL(request.url ?? "", UNKNOWN_HOST);
-      if (request.headers["sec-websocket-protocol"]?.startsWith("vite")) {
+    async (request2, socket, head) => {
+      const url = new URL(request2.url ?? "", UNKNOWN_HOST);
+      if (request2.headers["sec-websocket-protocol"]?.startsWith("vite")) {
         return;
       }
-      const headers = createHeaders(request);
+      const headers = createHeaders(request2);
       const fetcher = await getFetcher();
       const response = await fetcher(url, {
         headers,
-        method: request.method
+        method: request2.method
       });
       const workerWebSocket = response.webSocket;
       if (!workerWebSocket) {
@@ -14675,12 +15847,12 @@ function handleWebSocket(httpServer, getFetcher) {
         return;
       }
       nodeWebSocket.handleUpgrade(
-        request,
+        request2,
         socket,
         head,
         async (clientWebSocket) => {
           coupleWebSocket(clientWebSocket, workerWebSocket);
-          nodeWebSocket.emit("connection", clientWebSocket, request);
+          nodeWebSocket.emit("connection", clientWebSocket, request2);
         }
       );
     }
@@ -14695,11 +15867,15 @@ function cloudflare2(pluginConfig = {}) {
   let resolvedViteConfig;
   const additionalModulePaths = /* @__PURE__ */ new Set();
   const nodeJsCompatWarningsMap = /* @__PURE__ */ new Map();
+  const containerImageTagsSeen = /* @__PURE__ */ new Set();
+  let runningContainerIds;
   return [
     {
       name: "vite-plugin-cloudflare",
       // This only applies to this plugin so is safe to use while other plugins migrate to the Environment API
       sharedDuringBuild: true,
+      // Vite `config` Hook
+      // see https://vite.dev/guide/api-plugin.html#config
       config(userConfig, env2) {
         resolvedPluginConfig = resolvePluginConfig(
           pluginConfig,
@@ -14763,6 +15939,8 @@ function cloudflare2(pluginConfig = {}) {
       buildStart() {
         workersConfigsWarningShown = false;
       },
+      // Vite `configResolved` Hook
+      // see https://vite.dev/guide/api-plugin.html#configresolved
       configResolved(config) {
         resolvedViteConfig = config;
         if (resolvedPluginConfig.type === "workers") {
@@ -14772,6 +15950,26 @@ function cloudflare2(pluginConfig = {}) {
           );
         }
       },
+      async transform(code, id) {
+        const workerConfig = getWorkerConfig2(this.environment.name);
+        if (!workerConfig) {
+          return;
+        }
+        const resolvedWorkerEntry = await this.resolve(workerConfig.main);
+        if (id === resolvedWorkerEntry?.id) {
+          const modified = new MagicString(code);
+          const hmrCode = `
+if (import.meta.hot) {
+  import.meta.hot.accept();
+}
+						`;
+          modified.append(hmrCode);
+          return {
+            code: modified.toString(),
+            map: modified.generateMap({ hires: "boundary", source: id })
+          };
+        }
+      },
       generateBundle(_, bundle) {
         assertIsNotPreview(resolvedPluginConfig);
         let config;
@@ -14798,11 +15996,36 @@ function cloudflare2(pluginConfig = {}) {
             );
             workerConfig.assets = {
               ...workerConfig.assets,
-              directory: path11.relative(
-                path11.resolve(resolvedViteConfig.root, workerOutputDirectory),
-                path11.resolve(resolvedViteConfig.root, clientOutputDirectory)
+              directory: path13.relative(
+                path13.resolve(resolvedViteConfig.root, workerOutputDirectory),
+                path13.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;
           }
@@ -14855,7 +16078,7 @@ function cloudflare2(pluginConfig = {}) {
       },
       hotUpdate(options) {
         assertIsNotPreview(resolvedPluginConfig);
-        const changedFilePath = path11.resolve(options.file);
+        const changedFilePath = path13.resolve(options.file);
         if (resolvedPluginConfig.configPaths.has(changedFilePath) || hasDotDevDotVarsFileChanged(resolvedPluginConfig, changedFilePath) || hasAssetsConfigChanged(
           resolvedPluginConfig,
           resolvedViteConfig,
@@ -14865,6 +16088,8 @@ function cloudflare2(pluginConfig = {}) {
           return [];
         }
       },
+      // Vite `configureServer` Hook
+      // see https://vite.dev/guide/api-plugin.html#configureserver
       async configureServer(viteDevServer) {
         assertIsNotPreview(resolvedPluginConfig);
         const inputInspectorPort = await getInputInspectorPortOption(
@@ -14872,11 +16097,18 @@ function cloudflare2(pluginConfig = {}) {
           viteDevServer,
           miniflare
         );
-        const miniflareDevOptions = await getDevMiniflareOptions(
+        let containerBuildId;
+        const entryWorkerConfig = getEntryWorkerConfig(resolvedPluginConfig);
+        const hasDevContainers = entryWorkerConfig?.containers?.length && entryWorkerConfig.dev.enable_containers;
+        if (hasDevContainers) {
+          containerBuildId = generateContainerBuildId();
+        }
+        const miniflareDevOptions = await getDevMiniflareOptions({
           resolvedPluginConfig,
           viteDevServer,
-          inputInspectorPort
-        );
+          inspectorPort: inputInspectorPort,
+          containerBuildId
+        });
         if (!miniflare) {
           miniflare = new Miniflare(miniflareDevOptions);
         } else {
@@ -14884,11 +16116,8 @@ function cloudflare2(pluginConfig = {}) {
         }
         let preMiddleware;
         if (resolvedPluginConfig.type === "workers") {
-          await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
-          const entryWorkerConfig = getWorkerConfig2(
-            resolvedPluginConfig.entryWorkerEnvironmentName
-          );
           assert11(entryWorkerConfig, `No entry Worker config`);
+          await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
           const entryWorkerName = entryWorkerConfig.name;
           if (viteDevServer.httpServer) {
             handleWebSocket(viteDevServer.httpServer, async () => {
@@ -14905,26 +16134,61 @@ function cloudflare2(pluginConfig = {}) {
             const includeRulesMatcher = generateStaticRoutingRuleMatcher(
               staticRouting.user_worker
             );
-            const userWorkerHandler = createRequestHandler(async (request) => {
+            const userWorkerHandler = createRequestHandler(async (request2) => {
               assert11(miniflare, `Miniflare not defined`);
               const userWorker = await miniflare.getWorker(entryWorkerName);
-              return userWorker.fetch(request, { redirect: "manual" });
+              return userWorker.fetch(request2, { redirect: "manual" });
             });
             preMiddleware = async (req, res, next) => {
               assert11(req.url, `req.url not defined`);
-              const request = new Request(new URL(req.url, UNKNOWN_HOST));
+              const request2 = new Request(new URL(req.url, UNKNOWN_HOST));
               if (req[kRequestType] === "asset") {
                 next();
-              } else if (excludeRulesMatcher({ request })) {
+              } else if (excludeRulesMatcher({ request: request2 })) {
                 req[kRequestType] === "asset";
                 next();
-              } else if (includeRulesMatcher({ request })) {
+              } else if (includeRulesMatcher({ request: request2 })) {
                 userWorkerHandler(req, res, next);
               } else {
                 next();
               }
             };
           }
+          if (hasDevContainers) {
+            assert11(
+              containerBuildId,
+              "Build ID should be set if containers are enabled and defined"
+            );
+            const containerOptions = await getContainerOptions(
+              entryWorkerConfig,
+              containerBuildId
+            );
+            const dockerPath = getDockerPath();
+            if (containerOptions) {
+              for (const container of containerOptions) {
+                containerImageTagsSeen.add(container.imageTag);
+              }
+              await prepareContainerImagesForDev({
+                dockerPath,
+                configPath: entryWorkerConfig.configPath,
+                containerOptions,
+                onContainerImagePreparationStart: () => {
+                },
+                onContainerImagePreparationEnd: () => {
+                }
+              });
+            }
+            const dockerPollIntervalId = setInterval(async () => {
+              runningContainerIds = await getContainerIdsByImageTags(
+                dockerPath,
+                containerImageTagsSeen
+              );
+            }, 2e3);
+            process.on("exit", () => {
+              clearInterval(dockerPollIntervalId);
+              removeContainersByIds(dockerPath, runningContainerIds);
+            });
+          }
         }
         return () => {
           if (preMiddleware) {
@@ -14942,14 +16206,14 @@ function cloudflare2(pluginConfig = {}) {
             });
           }
           viteDevServer.middlewares.use(
-            createRequestHandler(async (request, req) => {
+            createRequestHandler(async (request2, req) => {
               assert11(miniflare, `Miniflare not defined`);
               if (req[kRequestType] === "asset") {
                 const assetWorker = await miniflare.getWorker(ASSET_WORKER_NAME);
-                return assetWorker.fetch(request, { redirect: "manual" });
+                return assetWorker.fetch(request2, { redirect: "manual" });
               } else {
                 const routerWorker = await miniflare.getWorker(ROUTER_WORKER_NAME);
-                return routerWorker.fetch(request, {
+                return routerWorker.fetch(request2, {
                   redirect: "manual"
                 });
               }
@@ -14957,6 +16221,8 @@ function cloudflare2(pluginConfig = {}) {
           );
         };
       },
+      // Vite `configurePreviewServer` Hook
+      // see https://vite.dev/guide/api-plugin.html#configurepreviewserver
       async configurePreviewServer(vitePreviewServer) {
         assertIsPreview(resolvedPluginConfig);
         const inputInspectorPort = await getInputInspectorPortOption(
@@ -14975,11 +16241,23 @@ function cloudflare2(pluginConfig = {}) {
           return miniflare.dispatchFetch;
         });
         vitePreviewServer.middlewares.use(
-          createRequestHandler((request) => {
+          createRequestHandler((request2) => {
             assert11(miniflare, `Miniflare not defined`);
-            return miniflare.dispatchFetch(request, { redirect: "manual" });
+            return miniflare.dispatchFetch(request2, { redirect: "manual" });
           })
         );
+      },
+      async buildEnd() {
+        if (resolvedViteConfig.command === "serve") {
+          const dockerPath = getDockerPath();
+          runningContainerIds = await getContainerIdsByImageTags(
+            dockerPath,
+            containerImageTagsSeen
+          );
+          await removeContainersByIds(dockerPath, runningContainerIds);
+          containerImageTagsSeen.clear();
+          runningContainerIds = [];
+        }
       }
     },
     // Plugin to provide a fallback entry file
@@ -15069,13 +16347,13 @@ function cloudflare2(pluginConfig = {}) {
           }
           const referenceId = this.emitFile({
             type: "asset",
-            name: path11.basename(modulePath),
+            name: path13.basename(modulePath),
             originalFileName: modulePath,
             source
           });
           const emittedFileName = this.getFileName(referenceId);
           const relativePath = vite6.normalizePath(
-            path11.relative(path11.dirname(chunk.fileName), emittedFileName)
+            path13.relative(path13.dirname(chunk.fileName), emittedFileName)
           );
           const importPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
           magicString.update(
@@ -15282,13 +16560,13 @@ function cloudflare2(pluginConfig = {}) {
                     setup(build) {
                       build.onResolve(
                         { filter: NODEJS_MODULES_RE },
-                        ({ path: path12, importer }) => {
-                          if (isNodeAls(workerConfig) && isNodeAlsModule(path12)) {
+                        ({ path: path14, importer }) => {
+                          if (isNodeAls(workerConfig) && isNodeAlsModule(path14)) {
                             return;
                           }
                           const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
-                          nodeJsCompatWarnings?.registerImport(path12, importer);
-                          return { path: path12, external: true };
+                          nodeJsCompatWarnings?.registerImport(path14, importer);
+                          return { path: path14, external: true };
                         }
                       );
                     }
@@ -15333,6 +16611,23 @@ function cloudflare2(pluginConfig = {}) {
   function getWorkerConfig2(environmentName) {
     return resolvedPluginConfig.type === "workers" ? resolvedPluginConfig.workers[environmentName] : void 0;
   }
+  async 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
+      };
+    });
+  }
 }
 export {
   cloudflare2 as cloudflare