wrangler 3.28.4 → 3.30.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wrangler",
-  "version": "3.28.4",
+  "version": "3.30.0",
   "description": "Command-line interface for all things Cloudflare Workers",
   "keywords": [
     "wrangler",
@@ -96,7 +96,7 @@
     "source-map": "0.6.1",
     "xxhash-wasm": "^1.0.1",
     "@cloudflare/kv-asset-handler": "0.3.1",
-    "miniflare": "3.20240129.3"
+    "miniflare": "3.20240223.0"
   },
   "devDependencies": {
     "@cloudflare/ai": "^1.0.35",
@@ -186,9 +186,9 @@
     "xdg-app-paths": "^8.3.0",
     "yargs": "^17.7.2",
     "yoga-layout": "file:../../vendor/yoga-layout-2.0.0-beta.1.tgz",
-    "@cloudflare/pages-shared": "^0.11.13",
-    "@cloudflare/workers-tsconfig": "0.0.0",
-    "@cloudflare/cli": "1.1.1"
+    "@cloudflare/cli": "1.1.1",
+    "@cloudflare/pages-shared": "^0.11.15",
+    "@cloudflare/workers-tsconfig": "0.0.0"
   },
   "optionalDependencies": {
     "fsevents": "~2.3.2"

package/wrangler-dist/cli.d.ts

@@ -25,6 +25,7 @@ import { URL as URL_2 } from 'url';
 import { UrlObject } from 'url';
 import { URLSearchParams as URLSearchParams_2 } from 'url';
 import { WebSocket as WebSocket_3 } from 'miniflare';
+import type { WorkerOptions } from 'miniflare';
 import { Writable } from 'stream';
 
 declare type AbortSignal_2 = unknown;
@@ -1359,6 +1360,13 @@ declare interface EnvironmentInheritable {
      * @inheritable
      */
     find_additional_modules: boolean | undefined;
+    /**
+     * Determines whether Wrangler will preserve bundled file names.
+     * Defaults to false.
+     * If left unset, files will be named using the pattern ${fileHash}-${basename},
+     * for example, `34de60b44167af5c5a709e62a4e20c4f18c9e3b6-favicon.ico`.
+     */
+    preserve_file_names: boolean | undefined;
     /**
      * The directory in which module rules should be evaluated when including additional files into a worker deployment.
      * This defaults to the directory containing the `main` entry point of the worker if not specified.
@@ -23414,6 +23422,8 @@ declare function setGlobalOrigin(origin: string | URL | undefined): void;
 
 declare type SimpleRoute = string;
 
+export declare type SourcelessWorkerOptions = Omit<WorkerOptions, "script" | "scriptPath" | "modules" | "modulesRoot" | "modulesRule">;
+
 /**
  * Information about Wrangler's bundling process that needs passed through
  * for DevTools sourcemap transformation
@@ -23708,6 +23718,11 @@ export declare class unstable_DevEnv extends EventEmitter_2 {
     emitErrorEvent(ev: ErrorEvent_2): void;
 }
 
+export declare function unstable_getMiniflareWorkerOptions(configPath: string): {
+    workerOptions: SourcelessWorkerOptions;
+    main?: string;
+};
+
 export declare const unstable_pages: {
     deploy: typeof deploy;
 };

package/wrangler-dist/cli.js

@@ -105448,6 +105448,7 @@ async function generateHandler({
   xServerEnvHeader,
   xDeploymentIdHeader,
   logError,
+  setMetrics,
   findAssetEntryForPath,
   getAssetKey,
   negotiateContent,
@@ -105599,7 +105600,15 @@ async function generateHandler({
         const earlyHintsLinkHeader = earlyHintsResponse.headers.get("Link");
         if (earlyHintsLinkHeader) {
           headers.set("Link", earlyHintsLinkHeader);
+          if (setMetrics)
+            setMetrics({ earlyHintsResult: "used-hit" });
+        } else {
+          if (setMetrics)
+            setMetrics({ earlyHintsResult: "notused-hit" });
         }
+      } else {
+        if (setMetrics)
+          setMetrics({ earlyHintsResult: "notused-miss" });
       }
       const clonedResponse = response.clone();
       if (waitUntil) {
@@ -105644,6 +105653,9 @@ async function generateHandler({
           })()
         );
       }
+    } else {
+      if (setMetrics)
+        setMetrics({ earlyHintsResult: "disabled" });
     }
     const headersMatcher = generateRulesMatcher(
       headerRules,
@@ -105774,8 +105786,16 @@ async function generateHandler({
       );
       const preservedResponse = await assetPreservationCache.match(request3.url);
       if (preservedResponse) {
+        if (setMetrics)
+          setMetrics({ preservationCacheResult: "checked-hit" });
         return preservedResponse;
+      } else {
+        if (setMetrics)
+          setMetrics({ preservationCacheResult: "checked-miss" });
       }
+    } else {
+      if (setMetrics)
+        setMetrics({ preservationCacheResult: "disabled" });
     }
     let cwd2 = pathname;
     while (cwd2) {
@@ -116039,6 +116059,7 @@ __export(cli_exports, {
   getPlatformProxy: () => getPlatformProxy,
   unstable_DevEnv: () => DevEnv,
   unstable_dev: () => unstable_dev,
+  unstable_getMiniflareWorkerOptions: () => unstable_getMiniflareWorkerOptions,
   unstable_pages: () => unstable_pages
 });
 module.exports = __toCommonJS(cli_exports);
@@ -119622,7 +119643,7 @@ var import_node_assert2 = __toESM(require("node:assert"));
 var import_undici3 = __toESM(require_undici());
 
 // package.json
-var version = "3.28.4";
+var version = "3.30.0";
 var package_default = {
   name: "wrangler",
   version,
@@ -122536,6 +122557,14 @@ function normalizeAndValidateEnvironment(diagnostics, configPath, rawEnv, envNam
       isBoolean,
       void 0
     ),
+    preserve_file_names: inheritable(
+      diagnostics,
+      topLevelEnv,
+      rawEnv,
+      "preserve_file_names",
+      isBoolean,
+      void 0
+    ),
     base_dir: normalizeAndValidateBaseDirField(
       configPath,
       inheritable(
@@ -124970,7 +124999,7 @@ function createModuleCollector(props) {
               );
               const fileContent = await (0, import_promises2.readFile)(filePath);
               const fileHash = import_node_crypto3.default.createHash("sha1").update(fileContent).digest("hex");
-              const fileName = `./${fileHash}-${import_node_path9.default.basename(args.path)}`;
+              const fileName = props.preserveFileNames ? args.path : `./${fileHash}-${import_node_path9.default.basename(args.path)}`;
               const { rule } = rulesMatchers.find(({ regex: regex2 }) => regex2.test(fileName)) || {};
               if (rule) {
                 modules.push({
@@ -125051,7 +125080,7 @@ function createModuleCollector(props) {
                 }
                 const fileContent = await (0, import_promises2.readFile)(filePath);
                 const fileHash = import_node_crypto3.default.createHash("sha1").update(fileContent).digest("hex");
-                const fileName = props.preserveFileNames ? filePath : `./${fileHash}-${import_node_path9.default.basename(args.path)}`;
+                const fileName = props.preserveFileNames ? args.path : `./${fileHash}-${import_node_path9.default.basename(args.path)}`;
                 modules.push({
                   name: fileName,
                   filePath,
@@ -126759,7 +126788,7 @@ __name(generateAddScriptNameExamples, "generateAddScriptNameExamples");
 // src/dev/dev.tsx
 init_import_meta_url();
 var import_node_child_process6 = require("node:child_process");
-var path51 = __toESM(require("node:path"));
+var path52 = __toESM(require("node:path"));
 var util2 = __toESM(require("node:util"));
 var import_chokidar4 = require("chokidar");
 
@@ -128031,13 +128060,6 @@ function buildLog() {
   return new WranglerLog(level, { prefix: "wrangler-UserWorker" });
 }
 __name(buildLog, "buildLog");
-function stripPySuffix(modulePath, type) {
-  if (type === "python" && modulePath.endsWith(".py")) {
-    return modulePath.slice(0, -3);
-  }
-  return modulePath;
-}
-__name(stripPySuffix, "stripPySuffix");
 async function buildSourceOptions(config) {
   const scriptPath3 = (0, import_node_fs11.realpathSync)(config.bundle.path);
   if (config.format === "modules") {
@@ -128052,16 +128074,13 @@ async function buildSourceOptions(config) {
         // Entrypoint
         {
           type: ModuleTypeToRuleType[config.bundle.type],
-          path: stripPySuffix(scriptPath3, config.bundle.type),
+          path: scriptPath3,
           contents: entrypointSource
         },
         // Misc (WebAssembly, etc, ...)
         ...modules.map((module3) => ({
           type: ModuleTypeToRuleType[module3.type ?? "esm"],
-          path: stripPySuffix(
-            import_node_path19.default.resolve(modulesRoot, module3.name),
-            module3.type
-          ),
+          path: import_node_path19.default.resolve(modulesRoot, module3.name),
           contents: module3.content
         }))
       ]
@@ -128229,7 +128248,9 @@ function buildPersistOptions(localPersistencePath) {
   }
 }
 __name(buildPersistOptions, "buildPersistOptions");
-function buildSitesOptions({ assetPaths }) {
+function buildSitesOptions({
+  assetPaths
+}) {
   if (assetPaths !== void 0) {
     const { baseDirectory, assetDirectory, includePatterns, excludePatterns } = assetPaths;
     return {
@@ -145961,32 +145982,42 @@ function buildNotifierPlugin(onEnd) {
   };
 }
 __name(buildNotifierPlugin, "buildNotifierPlugin");
-async function checkRawWorker(scriptPath3, onEnd) {
+async function checkRawWorker(scriptPath3, nodejsCompat, onEnd) {
   await (0, import_esbuild3.build)({
     entryPoints: [scriptPath3],
     write: false,
     // we need it to be bundled so that any imports that are used are affected by the blocker plugin
     bundle: true,
-    plugins: [blockWorkerJsImports, buildNotifierPlugin(onEnd)]
+    plugins: [blockWorkerJsImports(nodejsCompat), buildNotifierPlugin(onEnd)],
+    logLevel: "silent"
   });
 }
 __name(checkRawWorker, "checkRawWorker");
-var blockWorkerJsImports = {
-  name: "block-worker-js-imports",
-  setup(build5) {
-    build5.onResolve({ filter: /.*/g }, (args) => {
-      if (args.kind === "entry-point") {
-        return {
-          path: args.path
-        };
-      }
-      throw new FatalError(
-        "_worker.js is not being bundled by Wrangler but it is importing from another file.\nThis will throw an error if deployed.\nYou should bundle the Worker in a pre-build step, remove the import if it is unused, or ask Wrangler to bundle it by setting `--bundle`.",
-        1
-      );
-    });
-  }
-};
+function blockWorkerJsImports(nodejsCompat) {
+  return {
+    name: "block-worker-js-imports",
+    setup(build5) {
+      build5.onResolve({ filter: /.*/g }, (args) => {
+        if (args.kind === "entry-point") {
+          return {
+            path: args.path
+          };
+        }
+        if (nodejsCompat && args.path.startsWith("node:") || args.path.startsWith("cloudflare:")) {
+          return {
+            path: args.path,
+            external: true
+          };
+        }
+        throw new FatalError(
+          "_worker.js is not being bundled by Wrangler but it is importing from another file.\nThis will throw an error if deployed.\nYou should bundle the Worker in a pre-build step, remove the import if it is unused, or ask Wrangler to bundle it by setting `--bundle`.",
+          1
+        );
+      });
+    }
+  };
+}
+__name(blockWorkerJsImports, "blockWorkerJsImports");
 
 // src/pages/functions/buildPlugin.ts
 function buildPluginFromFunctions({
@@ -147810,7 +147841,7 @@ async function deploy2({
     isProduction = project.production_branch === branch;
   }
   const deploymentConfig = project.deployment_configs[isProduction ? "production" : "preview"];
-  const nodejsCompat = deploymentConfig.compatibility_flags?.includes("nodejs_compat");
+  const nodejsCompat = deploymentConfig.compatibility_flags?.includes("nodejs_compat") ?? false;
   const defineNavigatorUserAgent = isNavigatorDefined(
     deploymentConfig.compatibility_date,
     deploymentConfig.compatibility_flags
@@ -147916,7 +147947,7 @@ async function deploy2({
         defineNavigatorUserAgent
       });
     } else {
-      await checkRawWorker(_workerPath, () => {
+      await checkRawWorker(_workerPath, nodejsCompat, () => {
       });
       workerBundle = {
         modules: [],
@@ -149383,7 +149414,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates/ for
   const functionsDirectory = "./functions";
   let usingFunctions = !usingWorkerScript && (0, import_node_fs28.existsSync)(functionsDirectory);
   let scriptPath3 = "";
-  const nodejsCompat = compatibilityFlags?.includes("nodejs_compat");
+  const nodejsCompat = compatibilityFlags?.includes("nodejs_compat") ?? false;
   const defineNavigatorUserAgent = isNavigatorDefined(
     compatibilityDate,
     compatibilityFlags
@@ -149418,7 +149449,11 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates/ for
   } else if (usingWorkerScript) {
     scriptPath3 = workerScriptPath;
     let runBuild = /* @__PURE__ */ __name(async () => {
-      await checkRawWorker(workerScriptPath, () => scriptReadyResolve());
+      await checkRawWorker(
+        workerScriptPath,
+        nodejsCompat,
+        () => scriptReadyResolve()
+      );
     }, "runBuild");
     if (enableBundling) {
       scriptPath3 = (0, import_node_path43.join)(
@@ -161494,10 +161529,110 @@ __name(tailHandler, "tailHandler");
 
 // src/type-generation.ts
 init_import_meta_url();
-var fs21 = __toESM(require("fs"));
-async function generateTypes(configToDTS, config) {
+var fs21 = __toESM(require("node:fs"));
+
+// src/dev/dev-vars.ts
+init_import_meta_url();
+var path45 = __toESM(require("node:path"));
+function getVarsForDev(config, env5, silent = false) {
+  const configDir = path45.resolve(path45.dirname(config.configPath ?? "."));
+  const devVarsPath = path45.resolve(configDir, ".dev.vars");
+  const loaded = loadDotEnv(devVarsPath, env5);
+  if (loaded !== void 0) {
+    const devVarsRelativePath = path45.relative(process.cwd(), loaded.path);
+    if (!silent) {
+      logger.log(`Using vars defined in ${devVarsRelativePath}`);
+    }
+    return {
+      ...config.vars,
+      ...loaded.parsed
+    };
+  } else {
+    return config.vars;
+  }
+}
+__name(getVarsForDev, "getVarsForDev");
+
+// src/type-generation.ts
+function typesOptions(yargs) {
+  return yargs.positional("path", {
+    describe: "The path to the declaration file to generate",
+    type: "string",
+    default: "worker-configuration.d.ts",
+    demandOption: false
+  }).option("env-interface", {
+    type: "string",
+    default: "Env",
+    describe: "The name of the generated environment interface",
+    requiresArg: true
+  });
+}
+__name(typesOptions, "typesOptions");
+async function typesHandler(args) {
+  const { envInterface, path: outputPath } = args;
+  const validInterfaceRegex = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+  if (!validInterfaceRegex.test(envInterface)) {
+    throw new CommandLineArgsError(
+      `The provided env-interface value ("${envInterface}") does not satisfy the validation regex: ${validInterfaceRegex}`
+    );
+  }
+  if (!outputPath.endsWith(".d.ts")) {
+    throw new CommandLineArgsError(
+      `The provided path value ("${outputPath}") does not point to a declaration file (please use the 'd.ts' extension)`
+    );
+  }
+  await printWranglerBanner();
+  const configPath = args.config ?? findWranglerToml(process.cwd(), args.experimentalJsonConfig);
+  if (!configPath || !fs21.existsSync(configPath) || fs21.statSync(configPath).isDirectory()) {
+    logger.warn(
+      `No config file detected${args.config ? ` (at ${args.config})` : ""}, aborting`
+    );
+    return;
+  }
+  const config = readConfig(configPath, args);
+  const secrets = getVarsForDev(
+    { configPath, vars: {} },
+    args.env,
+    true
+  );
+  const configBindingsWithSecrets = {
+    kv_namespaces: config.kv_namespaces ?? [],
+    vars: { ...config.vars },
+    wasm_modules: config.wasm_modules,
+    text_blobs: {
+      ...config.text_blobs
+    },
+    data_blobs: config.data_blobs,
+    durable_objects: config.durable_objects,
+    r2_buckets: config.r2_buckets,
+    d1_databases: config.d1_databases,
+    services: config.services,
+    analytics_engine_datasets: config.analytics_engine_datasets,
+    dispatch_namespaces: config.dispatch_namespaces,
+    logfwdr: config.logfwdr,
+    unsafe: config.unsafe,
+    rules: config.rules,
+    queues: config.queues,
+    constellation: config.constellation,
+    secrets
+  };
+  await generateTypes(
+    configBindingsWithSecrets,
+    config,
+    envInterface,
+    outputPath
+  );
+}
+__name(typesHandler, "typesHandler");
+async function generateTypes(configToDTS, config, envInterface, outputPath) {
   const configContainsEntryPoint = config.main !== void 0 || !!config.site?.["entry-point"];
   const entrypointFormat = configContainsEntryPoint ? (await getEntry({}, config, "types")).format : "modules";
+  const userProvidedEnvInterface = envInterface !== "Env";
+  if (userProvidedEnvInterface && entrypointFormat === "service-worker") {
+    throw new Error(
+      "An env-interface value has been provided but the worker uses the incompatible Service Worker syntax"
+    );
+  }
   const envTypeStructure = [];
   if (configToDTS.kv_namespaces) {
     for (const kvNamespace2 of configToDTS.kv_namespaces) {
@@ -161505,8 +161640,10 @@ async function generateTypes(configToDTS, config) {
     }
   }
   if (configToDTS.vars) {
-    for (const varName in configToDTS.vars) {
-      const varValue = configToDTS.vars[varName];
+    const vars = Object.entries(configToDTS.vars).filter(
+      ([key]) => !(key in configToDTS.secrets)
+    );
+    for (const [varName, varValue] of vars) {
       if (typeof varValue === "string" || typeof varValue === "number" || typeof varValue === "boolean") {
         envTypeStructure.push(`${varName}: "${varValue}";`);
       }
@@ -161515,6 +161652,9 @@ async function generateTypes(configToDTS, config) {
       }
     }
   }
+  for (const secretName in configToDTS.secrets) {
+    envTypeStructure.push(`${secretName}: string;`);
+  }
   if (configToDTS.durable_objects?.bindings) {
     for (const durableObject of configToDTS.durable_objects.bindings) {
       envTypeStructure.push(`${durableObject.name}: DurableObjectNamespace;`);
@@ -161599,20 +161739,24 @@ async function generateTypes(configToDTS, config) {
   writeDTSFile({
     envTypeStructure,
     modulesTypeStructure,
-    formatType: entrypointFormat
+    formatType: entrypointFormat,
+    envInterface,
+    path: outputPath
   });
 }
 __name(generateTypes, "generateTypes");
 function writeDTSFile({
   envTypeStructure,
   modulesTypeStructure,
-  formatType
+  formatType,
+  envInterface,
+  path: path58
 }) {
-  const wranglerOverrideDTSPath = findUpSync("worker-configuration.d.ts");
+  const wranglerOverrideDTSPath = findUpSync(path58);
   try {
     if (wranglerOverrideDTSPath !== void 0 && !fs21.readFileSync(wranglerOverrideDTSPath, "utf8").includes("Generated by Wrangler")) {
       throw new UserError(
-        "A non-wrangler worker-configuration.d.ts already exists, please rename and try again."
+        `A non-wrangler ${path58} already exists, please rename and try again.`
       );
     }
   } catch (error2) {
@@ -161622,7 +161766,7 @@ function writeDTSFile({
   }
   let combinedTypeStrings = "";
   if (formatType === "modules") {
-    combinedTypeStrings += `interface Env {
+    combinedTypeStrings += `interface ${envInterface} {
 ${envTypeStructure.map((value) => `	${value}`).join("\n")}
 }
 ${modulesTypeStructure.join("\n")}`;
@@ -161633,11 +161777,16 @@ ${envTypeStructure.map((value) => `	const ${value}`).join("\n")}
 }
 ${modulesTypeStructure.join("\n")}`;
   }
+  const wranglerCommandUsed = ["wrangler", ...process.argv.slice(2)].join(" ");
   if (envTypeStructure.length || modulesTypeStructure.length) {
     fs21.writeFileSync(
-      "worker-configuration.d.ts",
-      `// Generated by Wrangler on ${/* @__PURE__ */ new Date()}
-` + combinedTypeStrings
+      path58,
+      [
+        `// Generated by Wrangler on ${/* @__PURE__ */ new Date()}`,
+        `// by running \`${wranglerCommandUsed}\``,
+        "",
+        combinedTypeStrings
+      ].join("\n")
     );
     logger.log(combinedTypeStrings);
   }
@@ -163127,35 +163276,10 @@ function createCLIParser(argv) {
     }
   );
   wrangler.command(
-    "types",
+    "types [path]",
     "\u{1F4DD} Generate types from bindings & module rules in config",
-    () => {
-    },
-    async (args) => {
-      await printWranglerBanner();
-      const config = readConfig(void 0, args);
-      const configBindings = {
-        kv_namespaces: config.kv_namespaces ?? [],
-        vars: { ...config.vars },
-        wasm_modules: config.wasm_modules,
-        text_blobs: {
-          ...config.text_blobs
-        },
-        data_blobs: config.data_blobs,
-        durable_objects: config.durable_objects,
-        r2_buckets: config.r2_buckets,
-        d1_databases: config.d1_databases,
-        services: config.services,
-        analytics_engine_datasets: config.analytics_engine_datasets,
-        dispatch_namespaces: config.dispatch_namespaces,
-        logfwdr: config.logfwdr,
-        unsafe: config.unsafe,
-        rules: config.rules,
-        queues: config.queues,
-        constellation: config.constellation
-      };
-      await generateTypes(configBindings, config);
-    }
+    typesOptions,
+    typesHandler
   );
   const deploymentsWarning = "\u{1F6A7}`wrangler deployments` is a beta command. Please report any issues to https://github.com/cloudflare/workers-sdk/issues/new/choose";
   wrangler.command(
@@ -164867,7 +164991,8 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
       // `moduleCollector` doesn't get used when `props.noBundle` is set, so
       // `findAdditionalModules` always defaults to `false`
       findAdditionalModules: config.find_additional_modules ?? false,
-      rules: props.rules
+      rules: props.rules,
+      preserveFileNames: config.preserve_file_names ?? false
     });
     const { modules, dependencies, resolvedEntryPointPath, bundleType } = props.noBundle ? await noBundleWorker2(props.entry, props.rules, props.outDir) : await bundleWorker(
       props.entry,
@@ -164985,7 +165110,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     const worker = {
       name: scriptName,
       main: {
-        name: stripPySuffix2(entryPointName, bundleType),
+        name: entryPointName,
         filePath: resolvedEntryPointPath,
         content,
         type: bundleType
@@ -165381,13 +165506,6 @@ function updateQueueConsumers(config) {
   });
 }
 __name(updateQueueConsumers, "updateQueueConsumers");
-function stripPySuffix2(modulePath, type) {
-  if (type === "python" && modulePath.endsWith(".py")) {
-    return modulePath.slice(0, -3);
-  }
-  return modulePath;
-}
-__name(stripPySuffix2, "stripPySuffix");
 async function noBundleWorker2(entry, rules, outDir) {
   const modules = await findAdditionalModules(entry, rules);
   if (outDir) {
@@ -165395,10 +165513,7 @@ async function noBundleWorker2(entry, rules, outDir) {
   }
   const bundleType = getBundleType(entry.format, entry.file);
   return {
-    modules: modules.map((m2) => ({
-      ...m2,
-      name: stripPySuffix2(m2.name, m2.type)
-    })),
+    modules,
     dependencies: {},
     resolvedEntryPointPath: entry.file,
     bundleType
@@ -166999,7 +167114,7 @@ function useCustomBuild(expectedEntry, build5, onBundleStart) {
         persistent: true,
         ignoreInitial: true
       }).on("all", (_event, filePath) => {
-        const relativeFile = path51.relative(expectedEntry.directory, expectedEntry.file) || ".";
+        const relativeFile = path52.relative(expectedEntry.directory, expectedEntry.file) || ".";
         logger.log(`The file ${filePath} changed, restarting build...`);
         onBundleStart();
         runCustomBuild(expectedEntry.file, relativeFile, build5).catch((err) => {
@@ -167151,26 +167266,6 @@ var dev_default = withErrorBoundary(DevImplementation, {
   FallbackComponent: ErrorFallback
 });
 
-// src/dev/dev-vars.ts
-init_import_meta_url();
-var path52 = __toESM(require("node:path"));
-function getVarsForDev(config, env5) {
-  const configDir = path52.resolve(path52.dirname(config.configPath ?? "."));
-  const devVarsPath = path52.resolve(configDir, ".dev.vars");
-  const loaded = loadDotEnv(devVarsPath, env5);
-  if (loaded !== void 0) {
-    const devVarsRelativePath = path52.relative(process.cwd(), loaded.path);
-    logger.log(`Using vars defined in ${devVarsRelativePath}`);
-    return {
-      ...config.vars,
-      ...loaded.parsed
-    };
-  } else {
-    return config.vars;
-  }
-}
-__name(getVarsForDev, "getVarsForDev");
-
 // src/dev/start-server.ts
 init_import_meta_url();
 var path53 = __toESM(require("node:path"));
@@ -169426,6 +169521,43 @@ function deepFreeze(obj) {
   });
 }
 __name(deepFreeze, "deepFreeze");
+function unstable_getMiniflareWorkerOptions(configPath) {
+  const config = readConfig(configPath, { experimentalJsonConfig: true });
+  const env5 = void 0;
+  const bindings = getBindings(config, env5, true, {});
+  const { bindingOptions } = buildMiniflareBindingOptions({
+    name: void 0,
+    bindings,
+    workerDefinitions: void 0,
+    queueConsumers: config.queues.consumers,
+    serviceBindings: {}
+  });
+  if (bindings.services !== void 0) {
+    bindingOptions.serviceBindings = Object.fromEntries(
+      bindings.services.map((binding) => {
+        return [binding.binding, binding.service];
+      })
+    );
+  }
+  if (bindings.durable_objects !== void 0) {
+    bindingOptions.durableObjects = Object.fromEntries(
+      bindings.durable_objects.bindings.map((binding) => [
+        binding.name,
+        { className: binding.class_name, scriptName: binding.script_name }
+      ])
+    );
+  }
+  const assetPaths = config.assets ? getAssetPaths(config, void 0) : getSiteAssetPaths(config);
+  const sitesOptions = buildSitesOptions({ assetPaths });
+  const workerOptions = {
+    compatibilityDate: config.compatibility_date,
+    compatibilityFlags: config.compatibility_flags,
+    ...bindingOptions,
+    ...sitesOptions
+  };
+  return { workerOptions, main: config.main };
+}
+__name(unstable_getMiniflareWorkerOptions, "unstable_getMiniflareWorkerOptions");
 
 // src/api/integrations/deprecated/index.ts
 init_import_meta_url();
@@ -169454,6 +169586,7 @@ if (typeof jest === "undefined" && require.main === module) {
   getPlatformProxy,
   unstable_DevEnv,
   unstable_dev,
+  unstable_getMiniflareWorkerOptions,
   unstable_pages
 });
 /*!