wrangler 4.28.0 → 4.28.1

package/wrangler-dist/cli.js

@@ -33117,6 +33117,38 @@ var require_signal_exit = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/ansi-regex@6.0.1/node_modules/ansi-regex/index.js
+function ansiRegex({ onlyFirst = false } = {}) {
+  const pattern = [
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"
+  ].join("|");
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+var init_ansi_regex = __esm({
+  "../../node_modules/.pnpm/ansi-regex@6.0.1/node_modules/ansi-regex/index.js"() {
+    init_import_meta_url();
+    __name(ansiRegex, "ansiRegex");
+  }
+});
+
+// ../../node_modules/.pnpm/strip-ansi@7.1.0/node_modules/strip-ansi/index.js
+function stripAnsi2(string) {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  return string.replace(regex, "");
+}
+var regex;
+var init_strip_ansi = __esm({
+  "../../node_modules/.pnpm/strip-ansi@7.1.0/node_modules/strip-ansi/index.js"() {
+    init_import_meta_url();
+    init_ansi_regex();
+    regex = ansiRegex();
+    __name(stripAnsi2, "stripAnsi");
+  }
+});
+
 // src/utils/filesystem.ts
 async function ensureDirectoryExists(filepath) {
   const dirpath = import_path6.default.dirname(filepath);
@@ -33148,7 +33180,7 @@ function getDebugFilepath() {
 async function appendToDebugLogFile(messageLevel, message) {
   const entry = `
 --- ${(/* @__PURE__ */ new Date()).toISOString()} ${messageLevel}
-${message}
+${stripAnsi2(message)}
 ---
 `;
   if (!hasLoggedLocation) {
@@ -33187,6 +33219,7 @@ var init_log_file = __esm({
     import_node_path3 = __toESM(require("path"));
     import_miniflare = require("miniflare");
     import_signal_exit = __toESM(require_signal_exit());
+    init_strip_ansi();
     init_factory();
     init_global_wrangler_config_path();
     init_logger();
@@ -33752,7 +33785,7 @@ var name, version;
 var init_package = __esm({
   "package.json"() {
     name = "wrangler";
-    version = "4.28.0";
+    version = "4.28.1";
   }
 });
 
@@ -35501,38 +35534,6 @@ var init_helpers = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/ansi-regex@6.0.1/node_modules/ansi-regex/index.js
-function ansiRegex({ onlyFirst = false } = {}) {
-  const pattern = [
-    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
-    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"
-  ].join("|");
-  return new RegExp(pattern, onlyFirst ? void 0 : "g");
-}
-var init_ansi_regex = __esm({
-  "../../node_modules/.pnpm/ansi-regex@6.0.1/node_modules/ansi-regex/index.js"() {
-    init_import_meta_url();
-    __name(ansiRegex, "ansiRegex");
-  }
-});
-
-// ../../node_modules/.pnpm/strip-ansi@7.1.0/node_modules/strip-ansi/index.js
-function stripAnsi2(string) {
-  if (typeof string !== "string") {
-    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
-  }
-  return string.replace(regex, "");
-}
-var regex;
-var init_strip_ansi = __esm({
-  "../../node_modules/.pnpm/strip-ansi@7.1.0/node_modules/strip-ansi/index.js"() {
-    init_import_meta_url();
-    init_ansi_regex();
-    regex = ansiRegex();
-    __name(stripAnsi2, "stripAnsi");
-  }
-});
-
 // src/utils/print-bindings.ts
 function printBindings(bindings, tailConsumers = [], context2 = {}) {
   let hasConnectionStatus = false;
@@ -49451,14 +49452,14 @@ var init_user2 = __esm({
 });
 
 // src/cfetch/internal.ts
-async function performApiFetch(complianceConfig, resource, init3 = {}, queryParams, abortSignal) {
+async function performApiFetch(complianceConfig, resource, init3 = {}, queryParams, abortSignal, apiToken) {
   const method = init3.method ?? "GET";
   (0, import_node_assert3.default)(
     resource.startsWith("/"),
     `CF API fetch - resource path must start with a "/" but got "${resource}"`
   );
   await requireLoggedIn(complianceConfig);
-  const apiToken = requireApiToken();
+  apiToken ??= requireApiToken();
   const headers = cloneHeaders(new import_undici3.Headers(init3.headers));
   addAuthorizationHeaderIfUnspecified(headers, apiToken);
   addUserAgent(headers);
@@ -49490,14 +49491,15 @@ async function performApiFetch(complianceConfig, resource, init3 = {}, queryPara
     }
   );
 }
-async function fetchInternal(complianceConfig, resource, init3 = {}, queryParams, abortSignal) {
+async function fetchInternal(complianceConfig, resource, init3 = {}, queryParams, abortSignal, apiToken) {
   const method = init3.method ?? "GET";
   const response = await performApiFetch(
     complianceConfig,
     resource,
     init3,
     queryParams,
-    abortSignal
+    abortSignal,
+    apiToken
   );
   const jsonText = await response.text();
   logger.debug(
@@ -49668,13 +49670,14 @@ var init_internal = __esm({
 });
 
 // src/cfetch/index.ts
-async function fetchResult(complianceConfig, resource, init3 = {}, queryParams, abortSignal) {
+async function fetchResult(complianceConfig, resource, init3 = {}, queryParams, abortSignal, apiToken) {
   const json = await fetchInternal(
     complianceConfig,
     resource,
     init3,
     queryParams,
-    abortSignal
+    abortSignal,
+    apiToken
   );
   if (json.success) {
     return json.result;
@@ -58912,11 +58915,11 @@ function buildMiniflareBindingOptions(config, remoteProxyConnectionString, remot
           {
             className,
             useSQLite: classNameToUseSQLite.get(className),
-            container: getImageNameFromDOClassName({
+            container: config.containerDOClassNames?.size && config.enableContainers ? getImageNameFromDOClassName({
               doClassName: className,
               containerDOClassNames: config.containerDOClassNames,
               containerBuildId: config.containerBuildId
-            })
+            }) : void 0
           }
         ];
       }),
@@ -59093,9 +59096,6 @@ async function buildMiniflareOptions(log2, config, proxyToUserWorkerAuthenticati
   return { options, internalObjects, entrypointNames };
 }
 function getImageNameFromDOClassName(options) {
-  if (!options.containerDOClassNames || !options.containerDOClassNames.size) {
-    return void 0;
-  }
   (0, import_node_assert5.default)(
     options.containerBuildId,
     "Build ID should be set if containers are defined and enabled"
@@ -65731,6 +65731,199 @@ var init_dist2 = __esm({
   }
 });
 
+// src/cloudchamber/instance-type/instance-type.ts
+async function promptForInstanceType(allowSkipping) {
+  let options = [
+    { label: "dev: 1/16 vCPU, 256 MiB memory, 2 GB disk", value: "dev" },
+    { label: "basic: 1/4 vCPU, 1 GiB memory, 4 GB disk", value: "basic" },
+    { label: "standard: 1/2 vCPU, 4 GiB memory, 4 GB disk", value: "standard" }
+  ];
+  if (allowSkipping) {
+    options = [{ label: "Do not set", value: "skip" }].concat(options);
+  }
+  const action = await inputPrompt({
+    question: "Which instance type should we use for your container?",
+    label: "",
+    defaultValue: false,
+    helpText: "",
+    type: "select",
+    options
+  });
+  switch (action) {
+    case "dev":
+    case "basic":
+    case "standard":
+      return action;
+    default:
+      return void 0;
+  }
+}
+function checkInstanceType(args, config) {
+  const instance_type = args.instanceType ?? config.instance_type;
+  if (instance_type === void 0) {
+    return;
+  }
+  if (args.memory !== void 0 || args.vcpu !== void 0) {
+    throw new UserError(
+      `Field "instance_type" is mutually exclusive with "memory" and "vcpu". These fields cannot be set together.`
+    );
+  }
+  switch (instance_type) {
+    case "dev":
+    case "basic":
+    case "standard":
+      return instance_type;
+    default:
+      throw new UserError(
+        `"instance_type" field value is expected to be one of "dev", "basic", or "standard", but got "${instance_type}"`
+      );
+  }
+}
+function getInstanceTypeUsage(instanceType) {
+  return instanceTypes[instanceType];
+}
+function inferInstanceType(config) {
+  for (const [instanceType, configuration] of Object.entries(instanceTypes)) {
+    if (config.vcpu === configuration.vcpu && config.memory_mib === configuration.memory_mib && config.disk?.size_mb === configuration.disk_mb) {
+      return instanceType;
+    }
+  }
+}
+function cleanForInstanceType(app) {
+  if (!("configuration" in app)) {
+    return app;
+  }
+  const instance_type = inferInstanceType(app.configuration);
+  if (instance_type !== void 0) {
+    app.configuration.instance_type = instance_type;
+  }
+  delete app.configuration.disk;
+  delete app.configuration.memory;
+  delete app.configuration.memory_mib;
+  delete app.configuration.vcpu;
+  return app;
+}
+var instanceTypes;
+var init_instance_type = __esm({
+  "src/cloudchamber/instance-type/instance-type.ts"() {
+    init_import_meta_url();
+    init_interactive();
+    init_errors();
+    instanceTypes = {
+      // dev is the default instance type when REQUIRE_INSTANCE_TYPE is set
+      dev: {
+        vcpu: 0.0625,
+        memory_mib: 256,
+        disk_mb: 2e3
+      },
+      basic: {
+        vcpu: 0.25,
+        memory_mib: 1024,
+        disk_mb: 4e3
+      },
+      standard: {
+        vcpu: 0.5,
+        memory_mib: 4096,
+        disk_mb: 4e3
+      }
+    };
+    __name(promptForInstanceType, "promptForInstanceType");
+    __name(checkInstanceType, "checkInstanceType");
+    __name(getInstanceTypeUsage, "getInstanceTypeUsage");
+    __name(inferInstanceType, "inferInstanceType");
+    __name(cleanForInstanceType, "cleanForInstanceType");
+  }
+});
+
+// src/cloudchamber/limits.ts
+function configToUsage(containerConfig) {
+  if ("instance_type" in containerConfig) {
+    return getInstanceTypeUsage(containerConfig.instance_type);
+  }
+  return {
+    vcpu: containerConfig.vcpu,
+    memory_mib: containerConfig.memory_mib,
+    disk_mb: containerConfig.disk_bytes / MB
+  };
+}
+function accountToLimits(account) {
+  return {
+    vcpu: account.limits.vcpu_per_deployment,
+    memory_mib: account.limits.memory_mib_per_deployment,
+    disk_mb: account.limits.disk_mb_per_deployment
+  };
+}
+async function ensureContainerLimits(options) {
+  const limits = accountToLimits(options.account);
+  if (!options.containerConfig) {
+    await ensureImageFitsLimits({
+      availableSizeInBytes: limits.disk_mb * MB,
+      pathToDocker: options.pathToDocker,
+      imageTag: options.imageTag
+    });
+    return;
+  }
+  const usage2 = configToUsage(options.containerConfig);
+  const errors = [];
+  if (usage2.vcpu > limits.vcpu) {
+    errors.push(
+      `Your container configuration uses ${usage2.vcpu} vCPU which exceeds the account limit of ${limits.vcpu} vCPU.`
+    );
+  }
+  if (usage2.memory_mib > limits.memory_mib) {
+    errors.push(
+      `Your container configuration uses ${usage2.memory_mib} MiB of memory which exceeds the account limit of ${limits.memory_mib} MiB.`
+    );
+  }
+  if (usage2.disk_mb > limits.disk_mb) {
+    errors.push(
+      `Your container configuration uses ${usage2.disk_mb} MB of disk which exceeds the account limit of ${limits.disk_mb} MB.`
+    );
+  }
+  if (errors.length > 0) {
+    throw new UserError(`Exceeded account limits: ${errors.join(" ")}`);
+  }
+  await ensureImageFitsLimits({
+    availableSizeInBytes: usage2.disk_mb * MB,
+    pathToDocker: options.pathToDocker,
+    imageTag: options.imageTag
+  });
+}
+async function ensureImageFitsLimits(options) {
+  const inspectOutput = await dockerImageInspect(options.pathToDocker, {
+    imageTag: options.imageTag,
+    formatString: "{{ .Size }} {{ len .RootFS.Layers }}"
+  });
+  const [sizeStr, layerStr] = inspectOutput.split(" ");
+  const size = parseInt(sizeStr, 10);
+  const layers = parseInt(layerStr, 10);
+  const requiredSizeInBytes = Math.ceil(size * 1.1 + layers * 16 * MiB);
+  logger.debug(
+    `Disk size limits when building container image: availableSize=${Math.ceil(options.availableSizeInBytes / MB)}MB, requiredSize=${Math.ceil(requiredSizeInBytes / MB)}MB`
+  );
+  if (options.availableSizeInBytes < requiredSizeInBytes) {
+    throw new UserError(
+      `Image too large: needs ${Math.ceil(requiredSizeInBytes / MB)}MB, but your app is limited to images with size ${options.availableSizeInBytes / MB}MB. Your need more disk for this image.`
+    );
+  }
+}
+var MB, MiB;
+var init_limits = __esm({
+  "src/cloudchamber/limits.ts"() {
+    init_import_meta_url();
+    init_containers_shared();
+    init_errors();
+    init_logger();
+    init_instance_type();
+    MB = 1e3 * 1e3;
+    MiB = 1024 * 1024;
+    __name(configToUsage, "configToUsage");
+    __name(accountToLimits, "accountToLimits");
+    __name(ensureContainerLimits, "ensureContainerLimits");
+    __name(ensureImageFitsLimits, "ensureImageFitsLimits");
+  }
+});
+
 // src/cloudchamber/locations.ts
 async function loadAccount() {
   if (cachedAccount !== void 0) {
@@ -65804,7 +65997,7 @@ function pushYargs(yargs) {
     demandOption: false
   }).positional("TAG", { type: "string", demandOption: true });
 }
-async function buildAndMaybePush(args, pathToDocker, push, configDiskInBytes) {
+async function buildAndMaybePush(args, pathToDocker, push, containerConfig) {
   try {
     const imageTag = `${getCloudflareContainerRegistry()}/${args.tag}`;
     const { buildCmd, dockerfile } = await constructBuildCommand(
@@ -65822,22 +66015,18 @@ async function buildAndMaybePush(args, pathToDocker, push, configDiskInBytes) {
       buildCmd,
       dockerfile
     }).ready;
-    const inspectOutput = await dockerImageInspect(pathToDocker, {
+    const repoDigests = await dockerImageInspect(pathToDocker, {
       imageTag,
-      formatString: "{{ .Size }} {{ len .RootFS.Layers }} {{json .RepoDigests}}"
+      formatString: "{{json .RepoDigests}}"
     });
-    const [sizeStr, layerStr, repoDigests] = inspectOutput.split(" ");
     let pushed = false;
     if (push) {
       const account = await loadAccount();
-      const size = parseInt(sizeStr, 10);
-      const layers = parseInt(layerStr, 10);
-      const MiB = 1024 * 1024;
-      const requiredSizeInBytes = Math.ceil(size * 1.1 + layers * 16 * MiB);
-      await ensureDiskLimits({
-        requiredSizeInBytes,
+      await ensureContainerLimits({
+        pathToDocker,
+        imageTag,
         account,
-        configDiskInBytes
+        containerConfig
       });
       await dockerLoginManagedRegistry(pathToDocker);
       try {
@@ -65922,8 +66111,8 @@ async function buildCommand(args) {
     },
     getDockerPath() ?? args.pathToDocker,
     args.push,
-    // this means we won't be able to read the disk size from the config, but that option is deprecated anyway at least for containers.
-    // and this never actually worked for cloudchamber as this command was previously reading it from config.containers not config.cloudchamber
+    // this means we aren't validating defined limits for a container when building an image
+    // we will, however, still validate the image size against account level disk limits
     void 0
   );
 }
@@ -65958,24 +66147,6 @@ async function checkImagePlatform(pathToDocker, imageTag, expectedPlatform = "li
     );
   }
 }
-async function ensureDiskLimits(options) {
-  const MB = 1e3 * 1e3;
-  const accountDiskSizeInBytes = (options.account.limits.disk_mb_per_deployment ?? 2e3) * MB;
-  if (options.configDiskInBytes && options.configDiskInBytes > accountDiskSizeInBytes) {
-    throw new UserError(
-      `Exceeded account limits: Your container is configured to use a disk size of ${Math.ceil(options.configDiskInBytes / MB)}MB. However, that exceeds the account limit of ${accountDiskSizeInBytes / MB}MB`
-    );
-  }
-  const maxAllowedImageSizeBytes = options.configDiskInBytes ?? accountDiskSizeInBytes;
-  logger.debug(
-    `Disk size limits when building the container: appDiskSize: ${options.configDiskInBytes ? Math.ceil(options.configDiskInBytes / MB) : "n/a"}MB, accountDiskSize:${accountDiskSizeInBytes / MB}MB, maxAllowedImageSizeBytes=${maxAllowedImageSizeBytes}(${maxAllowedImageSizeBytes / MB}MB), requiredSize=${options.requiredSizeInBytes}(${Math.ceil(options.requiredSizeInBytes / MB)}MB)`
-  );
-  if (maxAllowedImageSizeBytes < options.requiredSizeInBytes) {
-    throw new UserError(
-      `Image too large: needs ${Math.ceil(options.requiredSizeInBytes / MB)}MB, but your app is limited to images with size ${maxAllowedImageSizeBytes / MB}MB. Your account needs more disk size per instance to run this container. The default disk size is 2GB.`
-    );
-  }
-}
 var import_fs13, import_path10;
 var init_build2 = __esm({
   "src/cloudchamber/build.ts"() {
@@ -65987,6 +66158,7 @@ var init_build2 = __esm({
     init_errors();
     init_logger();
     init_user2();
+    init_limits();
     init_locations();
     __name(buildYargs, "buildYargs");
     __name(pushYargs, "pushYargs");
@@ -65994,7 +66166,6 @@ var init_build2 = __esm({
     __name(buildCommand, "buildCommand");
     __name(pushCommand, "pushCommand");
     __name(checkImagePlatform, "checkImagePlatform");
-    __name(ensureDiskLimits, "ensureDiskLimits");
   }
 });
 
@@ -66995,90 +67166,14 @@ async function promptForLabels(labels, initiallySelected, allowSkipping) {
   }
   return [];
 }
-async function promptForInstanceType(allowSkipping) {
-  let options = [
-    { label: "dev: 1/16 vCPU, 256 MiB memory, 2 GB disk", value: "dev" },
-    { label: "basic: 1/4 vCPU, 1 GiB memory, 4 GB disk", value: "basic" },
-    { label: "standard: 1/2 vCPU, 4 GiB memory, 4 GB disk", value: "standard" }
-  ];
-  if (allowSkipping) {
-    options = [{ label: "Do not set", value: "skip" }].concat(options);
-  }
-  const action = await inputPrompt({
-    question: "Which instance type should we use for your container?",
-    label: "",
-    defaultValue: false,
-    helpText: "",
-    type: "select",
-    options
-  });
-  switch (action) {
-    case "dev":
-      return "dev" /* DEV */;
-    case "basic":
-      return "basic" /* BASIC */;
-    case "standard":
-      return "standard" /* STANDARD */;
-    default:
-      return void 0;
-  }
-}
 function resolveMemory(args, config) {
-  const MiB = 1024 * 1024;
+  const MiB2 = 1024 * 1024;
   const memory = args.memory ?? config.memory;
   if (memory !== void 0) {
-    return Math.round(parseByteSize(memory, 1024) / MiB);
+    return Math.round(parseByteSize(memory, 1024) / MiB2);
   }
   return void 0;
 }
-function checkInstanceType(args, config) {
-  const instance_type = args.instanceType ?? config.instance_type;
-  if (instance_type === void 0) {
-    return;
-  }
-  if (args.memory !== void 0 || args.vcpu !== void 0) {
-    throw new UserError(
-      `Field "instance_type" is mutually exclusive with "memory" and "vcpu". These fields cannot be set together.`
-    );
-  }
-  switch (instance_type) {
-    case "dev":
-      return "dev" /* DEV */;
-    case "basic":
-      return "basic" /* BASIC */;
-    case "standard":
-      return "standard" /* STANDARD */;
-    default:
-      throw new UserError(
-        `"instance_type" field value is expected to be one of "dev", "basic", or "standard", but got "${instance_type}"`
-      );
-  }
-}
-function inferInstanceType(configuration) {
-  if (configuration?.disk?.size_mb !== void 0 && configuration?.memory_mib !== void 0 && configuration?.vcpu !== void 0) {
-    if (configuration.disk.size_mb === 2e3 && configuration.memory_mib === 256 && configuration.vcpu === 0.0625) {
-      return "dev" /* DEV */;
-    } else if (configuration.disk.size_mb === 4e3 && configuration.memory_mib === 1024 && configuration.vcpu === 0.25) {
-      return "basic" /* BASIC */;
-    } else if (configuration.disk.size_mb === 4e3 && configuration.memory_mib === 4096 && configuration.vcpu === 0.5) {
-      return "standard" /* STANDARD */;
-    }
-  }
-}
-function cleanForInstanceType(app) {
-  if (!("configuration" in app)) {
-    return app;
-  }
-  const instance_type = inferInstanceType(app.configuration);
-  if (instance_type !== void 0) {
-    app.configuration.instance_type = instance_type;
-  }
-  delete app.configuration.disk;
-  delete app.configuration.memory;
-  delete app.configuration.memory_mib;
-  delete app.configuration.vcpu;
-  return app;
-}
 var cloudchamberScope, imageRe;
 var init_common = __esm({
   "src/cloudchamber/common.ts"() {
@@ -67125,11 +67220,7 @@ var init_common = __esm({
     __name(sortLabels, "sortLabels");
     __name(collectLabels, "collectLabels");
     __name(promptForLabels, "promptForLabels");
-    __name(promptForInstanceType, "promptForInstanceType");
     __name(resolveMemory, "resolveMemory");
-    __name(checkInstanceType, "checkInstanceType");
-    __name(inferInstanceType, "inferInstanceType");
-    __name(cleanForInstanceType, "cleanForInstanceType");
   }
 });
 
@@ -68158,6 +68249,7 @@ var init_deploy = __esm({
     init_containers_shared();
     init_common();
     init_diff();
+    init_instance_type();
     init_config2();
     init_errors();
     init_user2();
@@ -68411,7 +68503,7 @@ async function maybeBuildContainer(containerConfig, imageTag, dryRun, pathToDock
     },
     pathToDocker,
     !dryRun,
-    "disk_bytes" in containerConfig ? containerConfig.disk_bytes : void 0
+    containerConfig
   );
   if (buildResult.pushed) {
     return { newImageLink: buildResult.image };
@@ -68524,10 +68616,10 @@ var init_config3 = __esm({
           }
         };
         let instanceTypeOrLimits;
-        const MB = 1e3 * 1e3;
+        const MB2 = 1e3 * 1e3;
         if (container.configuration?.disk !== void 0 || container.configuration?.vcpu !== void 0 || container.configuration?.memory_mib !== void 0) {
           instanceTypeOrLimits = {
-            disk_bytes: (container.configuration?.disk?.size_mb ?? 2e3) * MB,
+            disk_bytes: (container.configuration?.disk?.size_mb ?? 2e3) * MB2,
             // defaults to 2GB in bytes
             vcpu: container.configuration?.vcpu ?? 0.0625,
             memory_mib: container.configuration?.memory_mib ?? 256
@@ -68538,7 +68630,7 @@ var init_config3 = __esm({
           };
         } else {
           instanceTypeOrLimits = {
-            disk_bytes: (container.instance_type.disk_mb ?? 2e3) * MB,
+            disk_bytes: (container.instance_type.disk_mb ?? 2e3) * MB2,
             vcpu: container.instance_type.vcpu ?? 0.0625,
             memory_mib: container.instance_type.memory_mib ?? 256
           };
@@ -80112,6 +80204,7 @@ var init_apply = __esm({
     init_sortObjectRecursive();
     init_common();
     init_diff();
+    init_instance_type();
     __name(mergeDeep3, "mergeDeep");
     __name(isObject2, "isObject");
     __name(applyCommandOptionalYargs, "applyCommandOptionalYargs");
@@ -81202,6 +81295,7 @@ var init_create2 = __esm({
     init_locations2();
     init_common();
     init_wrap();
+    init_instance_type();
     init_locations();
     init_network();
     init_ssh();
@@ -82204,6 +82298,7 @@ var init_modify = __esm({
     init_locations2();
     init_common();
     init_wrap();
+    init_instance_type();
     init_locations();
     init_ssh();
     __name(modifyCommandOptionalYargs, "modifyCommandOptionalYargs");
@@ -178607,14 +178702,15 @@ function switchHost(originalUrl, host, zonePreview) {
   return url4;
 }
 async function createPreviewSession(complianceConfig, account, ctx, abortSignal) {
-  const { accountId } = account;
+  const { accountId, apiToken } = account;
   const initUrl = ctx.zone ? `/zones/${ctx.zone}/workers/edge-preview` : `/accounts/${accountId}/workers/subdomain/edge-preview`;
   const { exchange_url } = await fetchResult(
     complianceConfig,
     initUrl,
     void 0,
     void 0,
-    abortSignal
+    abortSignal,
+    apiToken
   );
   const switchedExchangeUrl = switchHost(
     exchange_url,
@@ -178881,7 +178977,7 @@ async function createRemoteWorkerInit(props) {
 async function getWorkerAccountAndContext(props) {
   const workerAccount = {
     accountId: props.accountId,
-    apiToken: requireApiToken()
+    apiToken: props.apiToken ?? requireApiToken()
   };
   const zoneId = await getZoneIdForPreview(props.complianceConfig, {
     host: props.host,
@@ -179113,6 +179209,7 @@ var init_RemoteRuntimeController = __esm({
           this.#session ??= await this.#previewSession({
             complianceConfig: { compliance_region: config.complianceRegion },
             accountId: auth.accountId,
+            apiToken: auth.apiToken,
             env: config.env,
             // deprecated service environments -- just pass it through for now
             legacyEnv: !config.legacy?.enableServiceEnvironments,
@@ -179503,34 +179600,53 @@ function pickRemoteBindings(bindings) {
     })
   );
 }
-async function maybeStartOrUpdateRemoteProxySession(configPathOrWorkerConfig, preExistingRemoteProxySessionData) {
-  if (typeof configPathOrWorkerConfig === "string") {
-    const configPath = configPathOrWorkerConfig;
-    const config = readConfig({ config: configPath });
+async function maybeStartOrUpdateRemoteProxySession(wranglerOrWorkerConfigObject, preExistingRemoteProxySessionData, auth) {
+  if ("path" in wranglerOrWorkerConfigObject) {
+    const wranglerConfigObject = wranglerOrWorkerConfigObject;
+    const config = readConfig({
+      config: wranglerConfigObject.path,
+      env: wranglerConfigObject.environment
+    });
     (0, import_node_assert33.default)(config.name);
-    configPathOrWorkerConfig = {
+    wranglerOrWorkerConfigObject = {
       name: config.name,
       complianceRegion: getCloudflareComplianceRegion(config),
       bindings: convertConfigBindingsToStartWorkerBindings(config) ?? {}
     };
   }
-  const workerConfigs = configPathOrWorkerConfig;
-  const remoteBindings = pickRemoteBindings(workerConfigs.bindings);
-  let remoteProxySession = preExistingRemoteProxySessionData?.session;
-  const remoteBindingsAreSameAsBefore = deepStrictEqual(
-    remoteBindings,
-    preExistingRemoteProxySessionData?.remoteBindings
+  const workerConfigObject = wranglerOrWorkerConfigObject;
+  const remoteBindings = pickRemoteBindings(workerConfigObject.bindings);
+  const authSameAsBefore = deepStrictEqual(
+    auth,
+    preExistingRemoteProxySessionData?.auth
   );
-  if (!remoteBindingsAreSameAsBefore) {
-    if (!remoteProxySession) {
-      if (Object.keys(remoteBindings).length > 0) {
-        remoteProxySession = await startRemoteProxySession(remoteBindings, {
-          workerName: configPathOrWorkerConfig.name,
-          complianceRegion: configPathOrWorkerConfig.complianceRegion
-        });
+  let remoteProxySession = preExistingRemoteProxySessionData?.session;
+  if (!authSameAsBefore) {
+    if (preExistingRemoteProxySessionData?.session) {
+      await preExistingRemoteProxySessionData.session.dispose();
+    }
+    remoteProxySession = await startRemoteProxySession(remoteBindings, {
+      workerName: workerConfigObject.name,
+      complianceRegion: workerConfigObject.complianceRegion,
+      auth
+    });
+  } else {
+    const remoteBindingsAreSameAsBefore = deepStrictEqual(
+      remoteBindings,
+      preExistingRemoteProxySessionData?.remoteBindings
+    );
+    if (!remoteBindingsAreSameAsBefore) {
+      if (!remoteProxySession) {
+        if (Object.keys(remoteBindings).length > 0) {
+          remoteProxySession = await startRemoteProxySession(remoteBindings, {
+            workerName: workerConfigObject.name,
+            complianceRegion: workerConfigObject.complianceRegion,
+            auth
+          });
+        }
+      } else {
+        await remoteProxySession.updateBindings(remoteBindings);
       }
-    } else {
-      await remoteProxySession.updateBindings(remoteBindings);
     }
   }
   await remoteProxySession?.ready;
@@ -179674,7 +179790,8 @@ async function convertToConfigBundle(event) {
       event.config.containers?.map((c6) => c6.class_name)
     ),
     containerBuildId: event.config.dev?.containerBuildId,
-    containerEngine: event.config.dev.containerEngine
+    containerEngine: event.config.dev.containerEngine,
+    enableContainers: event.config.dev.enableContainers ?? true
   };
 }
 async function getContainerDevOptions(containersConfig, containerBuildId) {
@@ -179764,14 +179881,22 @@ var init_LocalRuntimeController = __esm({
           const configBundle = await convertToConfigBundle(data);
           const experimentalRemoteBindings = data.config.dev.experimentalRemoteBindings ?? false;
           if (experimentalRemoteBindings && !data.config.dev?.remote) {
-            const { maybeStartOrUpdateRemoteProxySession: maybeStartOrUpdateRemoteProxySession2 } = await Promise.resolve().then(() => (init_remoteBindings(), remoteBindings_exports));
+            const { maybeStartOrUpdateRemoteProxySession: maybeStartOrUpdateRemoteProxySession2, pickRemoteBindings: pickRemoteBindings2 } = await Promise.resolve().then(() => (init_remoteBindings(), remoteBindings_exports));
+            const remoteBindings = pickRemoteBindings2(
+              convertCfWorkerInitBindingsToBindings(configBundle.bindings) ?? {}
+            );
+            const auth = Object.keys(remoteBindings).length === 0 ? (
+              // If there are no remote bindings (this is a local only session) there's no need to get auth data
+              void 0
+            ) : await unwrapHook(data.config.dev.auth);
             this.#remoteProxySessionData = await maybeStartOrUpdateRemoteProxySession2(
               {
                 name: configBundle.name,
                 complianceRegion: configBundle.complianceRegion,
-                bindings: convertCfWorkerInitBindingsToBindings(configBundle.bindings) ?? {}
+                bindings: remoteBindings
               },
-              this.#remoteProxySessionData ?? null
+              this.#remoteProxySessionData ?? null,
+              auth
             );
           }
           if (data.config.containers?.length && data.config.dev.enableContainers && this.#currentContainerBuildId !== data.config.dev.containerBuildId) {
@@ -184156,7 +184281,10 @@ async function getPlatformProxy(options = {}) {
   });
   let remoteProxySession = void 0;
   if (experimentalRemoteBindings && config.configPath) {
-    remoteProxySession = (await maybeStartOrUpdateRemoteProxySession(config.configPath) ?? {}).session;
+    remoteProxySession = (await maybeStartOrUpdateRemoteProxySession({
+      path: config.configPath,
+      environment: env6
+    }) ?? {}).session;
   }
   const miniflareOptions = await getMiniflareOptionsFromConfig({
     config,
@@ -184228,7 +184356,8 @@ async function getMiniflareOptionsFromConfig(args) {
       containerDOClassNames: new Set(
         config.containers?.map((c6) => c6.class_name)
       ),
-      containerBuildId: void 0
+      containerBuildId: void 0,
+      enableContainers: config.dev.enable_containers
     },
     remoteProxyConnectionString,
     remoteBindingsEnabled
@@ -184295,6 +184424,7 @@ function unstable_getMiniflareWorkerOptions(configOrConfigPath, env6, options) {
     config.containers?.map((c6) => c6.class_name)
   );
   const bindings = getBindings2(config, env6, options?.envFiles, true, {}, true);
+  const enableContainers = options?.overrides?.enableContainers !== void 0 ? options?.overrides?.enableContainers : config.dev.enable_containers;
   const { bindingOptions, externalWorkers } = buildMiniflareBindingOptions(
     {
       name: config.name,
@@ -184308,7 +184438,8 @@ function unstable_getMiniflareWorkerOptions(configOrConfigPath, env6, options) {
       imagesLocalMode: !!options?.imagesLocalMode,
       tails: config.tail_consumers,
       containerDOClassNames,
-      containerBuildId: options?.containerBuildId
+      containerBuildId: options?.containerBuildId,
+      enableContainers
     },
     options?.remoteProxyConnectionString,
     options?.remoteBindingsEnabled ?? false
@@ -184342,11 +184473,11 @@ function unstable_getMiniflareWorkerOptions(configOrConfigPath, env6, options) {
             className: binding.class_name,
             scriptName: binding.script_name,
             useSQLite,
-            container: getImageNameFromDOClassName({
+            container: enableContainers && config.containers?.length ? getImageNameFromDOClassName({
               doClassName: binding.class_name,
               containerDOClassNames,
               containerBuildId: options?.containerBuildId
-            })
+            }) : void 0
           }
         ];
       })