env-runner 0.2.1 → 0.2.3

package/dist/_chunks/miniflare-runner.mjs

@@ -1,23 +1,27 @@
 import { expandVirtualInvalidation, stripVirtualTypeScript, virtualModuleFormat } from "./virtual-loader.mjs";
 import { BaseEnvRunner } from "./common-base-runner.mjs";
+import { isVirtualSpecifier } from "./common-worker-utils.mjs";
 import { resolveRuntimeDep } from "./common-runtime-deps.mjs";
 import { init, parse } from "./libs/cjs-module-lexer.mjs";
 import { init as init$1, parse as parse$1 } from "./libs/es-module-lexer.mjs";
-import { isVirtualSpecifier } from "./common-worker-utils.mjs";
 import { createRequire } from "node:module";
 import { proxyUpgrade } from "httpxy";
 import { fileURLToPath } from "node:url";
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { resolveModulePath } from "exsolve";
-import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
 import { tmpdir } from "node:os";
+import { parseEnv } from "node:util";
 const IPC_PATH = "/__env_runner_ipc";
 const IPC_BINDING = "__ENV_RUNNER_IPC";
+const UNSAFE_EVAL_BINDING = "__ENV_RUNNER_UNSAFE_EVAL__";
 function generateWrapper(entryPath, opts) {
+	const processShim = opts?.nodeCompat === false ? "" : `import __process from "node:process";
+if (!globalThis.process) { globalThis.process = __process; }`;
 	const staticReExport = opts?.dynamicOnly ? "" : `export * from ${JSON.stringify(entryPath)};`;
 	const explicitExports = opts?.dynamicOnly && opts.exports?.length ? opts.exports.map((name) => `export { ${name} } from ${JSON.stringify(entryPath)};`).join("\n") : "";
 	const fetchBody = opts?.captureErrors ?? true ? `try {
-      return await entryFetch(request, env, ctx);
+      return await __server.fetch(request, env, ctx);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
       const body = JSON.stringify({
@@ -29,20 +33,94 @@ function generateWrapper(entryPath, opts) {
         status: 500,
         headers: { "Content-Type": "application/json", "X-Env-Runner-Error": "1" },
       });
-    }` : `return entryFetch(request, env, ctx);`;
-	return `import __process from "node:process";
-if (!globalThis.process) { globalThis.process = __process; }
+    }` : `return __server.fetch(request, env, ctx);`;
+	return `${processShim}
 ${staticReExport}
 ${explicitExports}
 
 const __IPC_PATH = "${IPC_PATH}";
 const __IPC_BINDING = "${IPC_BINDING}";
+const __UNSAFE_EVAL_BINDING = "${UNSAFE_EVAL_BINDING}";
 const __entryPath = ${JSON.stringify(entryPath)};
 let __userEntry;
+let __server;
 let __ipcInitialized = false;
 let __serverWs;
 let __currentEnv;
 
+const __userEnvs = new WeakMap();
+
+// \`env\` without env-runner's internal bindings (cached per env object).
+function __userEnv(env) {
+  let userEnv = __userEnvs.get(env);
+  if (!userEnv) {
+    userEnv = { ...env };
+    delete userEnv[__IPC_BINDING];
+    delete userEnv[__UNSAFE_EVAL_BINDING];
+    __userEnvs.set(env, userEnv);
+  }
+  return userEnv;
+}
+
+// Mirrors srvx's CloudflareServer (srvx/cloudflare): plugins, then the
+// \`error\` handler as the outermost middleware, then the middleware chain.
+function __createServer(entry) {
+  const server = {
+    runtime: "cloudflare",
+    options: {
+      ...entry,
+      middleware: [...(entry.middleware || [])],
+      fetch: entry.fetch
+        ? (request) =>
+            entry.fetch(request, request.runtime?.cloudflare?.env, request.runtime?.cloudflare?.context)
+        : () => new Response("No fetch handler exported", { status: 500 }),
+    },
+    serve() {},
+    ready: () => Promise.resolve(server),
+    close: () => Promise.resolve(),
+  };
+  for (const plugin of entry.plugins || []) {
+    plugin(server);
+  }
+  const errorHandler = server.options.error;
+  if (errorHandler) {
+    server.options.middleware.unshift((_request, next) => {
+      try {
+        const res = next();
+        return typeof res?.then === "function" ? res.then(undefined, (error) => errorHandler(error)) : res;
+      } catch (error) {
+        return errorHandler(error);
+      }
+    });
+  }
+  let handler = server.options.fetch;
+  const middleware = server.options.middleware;
+  for (let i = middleware.length - 1; i >= 0; i--) {
+    const mw = middleware[i];
+    const next = handler;
+    handler = (request) => mw(request, () => next(request));
+  }
+  server.fetch = (request, env, context) => {
+    const userEnv = __userEnv(env);
+    Object.defineProperties(request, {
+      waitUntil: { value: context.waitUntil.bind(context) },
+      runtime: {
+        enumerable: true,
+        value: { name: "cloudflare", cloudflare: { env: userEnv, context } },
+      },
+      ip: {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return request.headers.get("cf-connecting-ip");
+        },
+      },
+    });
+    return handler(request);
+  };
+  return server;
+}
+
 async function __loadEntry(env, path) {
   globalThis.__ENV_RUNNER_UNSAFE_EVAL__ = env.__ENV_RUNNER_UNSAFE_EVAL__;
   const importFn = env.__ENV_RUNNER_UNSAFE_EVAL__.newAsyncFunction(
@@ -84,10 +162,12 @@ async function __handleWsMessage(env, data) {
     const version = msg.version || 0;
     try {
       const newEntry = await __loadEntry(env, __entryPath + "?t=" + version);
+      const newServer = __createServer(newEntry);
       if (__userEntry?.ipc?.onClose) {
         await __userEntry.ipc.onClose();
       }
       __userEntry = newEntry;
+      __server = newServer;
       __crosswsAdapter = undefined;
       __ipcInitialized = false;
       if (__userEntry.ipc?.onOpen) {
@@ -130,7 +210,9 @@ export default {
     if (url.pathname === __IPC_PATH && request.headers.get("upgrade") === "websocket") {
       try {
         if (!__userEntry) {
-          __userEntry = await __loadEntry(env, __entryPath);
+          const entry = await __loadEntry(env, __entryPath);
+          __server = __createServer(entry);
+          __userEntry = entry;
         }
       } catch (e) {
         return new Response("Failed to load entry: " + String(e), { status: 500 });
@@ -164,13 +246,9 @@ export default {
     // Handle WebSocket upgrade via crossws cloudflare adapter
     if (__userEntry.websocket && request.headers.get("upgrade") === "websocket") {
       const adapter = await __initCrossws(env, __userEntry.websocket);
-      return adapter.handleUpgrade(request, env, ctx);
+      return adapter.handleUpgrade(request, __userEnv(env), ctx);
     }
 
-    const entryFetch = __userEntry.fetch;
-    if (!entryFetch) {
-      return new Response("No fetch handler exported", { status: 500 });
-    }
     __currentEnv = env;
     try {
       ${fetchBody}
@@ -181,6 +259,67 @@ export default {
 };
 `;
 }
+function expandDotenv(parsed, processEnv) {
+	const running = {};
+	for (const [key, raw] of Object.entries(parsed)) running[key] = processEnv[key] = (processEnv[key] && processEnv[key] !== raw ? processEnv[key] : expandDotenvValue(raw, processEnv, running)).replace(/\\\$/g, "$");
+	return processEnv;
+}
+function expandDotenvValue(value, processEnv, running) {
+	const env = {
+		...running,
+		...processEnv
+	};
+	const regex = /(?<!\\)\$\{([^{}]+)\}|(?<!\\)\$([A-Za-z_][A-Za-z0-9_]*)/g;
+	const seen = /* @__PURE__ */ new Set();
+	let result = value;
+	let match;
+	while ((match = regex.exec(result)) !== null) {
+		seen.add(result);
+		const [template, braced, unbraced] = match;
+		const expression = braced || unbraced;
+		const splitter = expression.match(/(:\+|\+|:-|-)/)?.[0];
+		const parts = splitter ? expression.split(splitter) : [expression];
+		const key = parts.shift();
+		let replacement;
+		if (splitter === ":+" || splitter === "+") replacement = env[key] ? parts.join(splitter) : "";
+		else {
+			const found = env[key];
+			replacement = found && !seen.has(found) ? found : parts.join(splitter ?? "");
+		}
+		result = result.replace(template, replacement);
+		if (result === running[key]) break;
+		regex.lastIndex = 0;
+	}
+	return result;
+}
+function readDotenvFile(path) {
+	return existsSync(path) ? parseEnv(readFileSync(path, "utf8")) : void 0;
+}
+function booleanEnv(name, defaultValue) {
+	const value = process.env[name]?.toLowerCase();
+	return value === "true" ? true : value === "false" ? false : defaultValue;
+}
+function loadDevVars(opts) {
+	const { configDir, env, envFiles } = opts;
+	if (!envFiles?.length) {
+		const devVars = resolve(configDir, ".dev.vars");
+		const loaded = env !== void 0 && readDotenvFile(`${devVars}.${env}`) || readDotenvFile(devVars);
+		if (loaded) return loaded;
+	}
+	if (!booleanEnv("CLOUDFLARE_LOAD_DEV_VARS_FROM_DOT_ENV", true)) return;
+	const files = envFiles ?? [
+		".env",
+		".env.local",
+		...env ? [`.env.${env}`, `.env.${env}.local`] : []
+	];
+	const parsed = {};
+	for (const file of files) Object.assign(parsed, readDotenvFile(resolve(configDir, file)));
+	const processEnv = {};
+	if (opts.hasSecrets || booleanEnv("CLOUDFLARE_INCLUDE_PROCESS_ENV", false)) {
+		for (const [key, value] of Object.entries(process.env)) if (typeof value === "string") processEnv[key] = value;
+	}
+	return expandDotenv(parsed, processEnv);
+}
 const WRANGLER_CONFIG_FILENAMES = [
 	"wrangler.json",
 	"wrangler.jsonc",
@@ -198,45 +337,143 @@ const WRANGLER_OPTION_DENYLIST = /* @__PURE__ */ new Set([
 	"unsafeModuleFallbackService",
 	"unsafeUseModuleFallbackService"
 ]);
+const WRANGLER_OPTION_DROPLIST = /* @__PURE__ */ new Set([
+	"assets",
+	"serviceBindings",
+	"workflows",
+	"queueConsumers",
+	"tails",
+	"streamingTails"
+]);
+const WRANGLER_DROPPED_OPTION_NAMES = {
+	assets: "assets",
+	serviceBindings: "services",
+	workflows: "workflows",
+	queueConsumers: "queues.consumers",
+	tails: "tail_consumers",
+	streamingTails: "streaming_tail_consumers",
+	durableObjects: "durable_objects"
+};
+function addDropped(dropped, name, details) {
+	let set = dropped.get(name);
+	if (!set) {
+		set = /* @__PURE__ */ new Set();
+		dropped.set(name, set);
+	}
+	for (const detail of details) set.add(detail);
+}
+function warnDroppedWranglerOptions(dropped) {
+	if (dropped.size === 0) return;
+	const list = [...dropped].map(([name, details]) => details.size > 0 ? `${name} (${[...details].join(", ")})` : name).join(", ");
+	console.warn(`[env-runner] wrangler config options not supported by the miniflare dev runner were ignored: ${list}; pass them via miniflareOptions to opt in.`);
+}
 function isPlainObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isInlineWranglerConfig(opt) {
 	return isPlainObject(opt);
 }
-async function loadWranglerConfig(opt, env, entryPath, wranglerModule) {
-	if (!opt) return;
+async function loadWranglerConfig(opts) {
+	const { wrangler: opt, env, entryPath, wranglerModule, envFiles } = opts;
+	if (!opt) return {};
 	const inline = isInlineWranglerConfig(opt) ? opt : void 0;
 	let configPath;
-	if (typeof opt === "string") {
-		configPath = resolve(opt);
+	const explicitPath = typeof opt === "string" ? opt : opts.configPath;
+	if (explicitPath) {
+		configPath = resolve(explicitPath);
 		if (!existsSync(configPath)) {
 			console.warn(`[env-runner] wrangler config requested but not found at "${configPath}"`);
-			return;
+			if (!inline) return {};
+			configPath = void 0;
 		}
-	} else if (opt === true) {
+	} else {
 		configPath = findWranglerConfig(entryPath);
-		if (!configPath) {
-			console.warn("[env-runner] wrangler config requested but none found near the entry or cwd");
-			return;
+		if (!configPath && !inline) {
+			console.warn("[env-runner] wrangler config requested but none found (searched the entry's directory, then from the cwd up to the filesystem root)");
+			return {};
 		}
-	} else configPath = findWranglerConfig(entryPath);
+	}
 	const wrangler = await resolveRuntimeDep({
 		name: "wrangler",
 		option: "wranglerModule",
 		value: wranglerModule
 	});
-	if (!wrangler?.unstable_readConfig || !wrangler.unstable_getMiniflareWorkerOptions) return mergeWranglerMiniflareOptions(configPath ? readWranglerConfigMinimal(configPath, env) : void 0, inline ? mapWranglerConfigToMiniflare(applyWranglerEnv(inline, env)) : void 0);
-	try {
-		return mergeWranglerMiniflareOptions(configPath ? pickWranglerMiniflareOptions(wrangler.unstable_getMiniflareWorkerOptions(wrangler.unstable_readConfig({
+	const dropped = /* @__PURE__ */ new Map();
+	if (!wrangler?.unstable_readConfig || !wrangler.unstable_getMiniflareWorkerOptions) {
+		const unsupported = /* @__PURE__ */ new Map();
+		const file = configPath ? readWranglerConfigMinimal(configPath, env) : void 0;
+		const inlineConfig = inline ? applyWranglerEnv(inline, env) : void 0;
+		let options = mergeWranglerMiniflareOptions(file && (mapWranglerConfigToMiniflare(file.config, dropped, unsupported) ?? {}), inlineConfig && mapWranglerConfigToMiniflare(inlineConfig, dropped, unsupported));
+		if (file || inlineConfig) options = applyMinimalDevVars(options, [file?.config, inlineConfig], {
+			configDir: configPath ? dirname(configPath) : process.cwd(),
+			env,
+			envFiles
+		});
+		filterLocalDurableObjects(options, dropped, (inline && wranglerWorkerName(inline, env)) ?? file?.workerName);
+		warnDroppedWranglerOptions(dropped);
+		warnUnsupportedMinimalBindings(unsupported);
+		return {
+			options,
+			configFile: file ? configPath : void 0
+		};
+	}
+	let fileLoaded = false;
+	let fileOptions;
+	let fileSecrets;
+	let fileWorkerName;
+	if (configPath) try {
+		const config = wrangler.unstable_readConfig({
 			config: configPath,
 			env
-		}, { hideWarnings: true }), env).workerOptions) : void 0, inline ? pickWranglerMiniflareOptions(wrangler.unstable_getMiniflareWorkerOptions(readInlineWranglerConfig(wrangler, inline, env), env).workerOptions) : void 0);
+		}, { hideWarnings: !claimWranglerWarnings(configPath, env) });
+		fileOptions = pickWranglerMiniflareOptions(wrangler.unstable_getMiniflareWorkerOptions(config, env, { envFiles }).workerOptions, dropped);
+		fileWorkerName = config?.name;
+		fileSecrets = config?.secrets;
+		fileLoaded = true;
 	} catch (error) {
-		const desc = [configPath && `"${configPath}"`, inline && "(inline)"].filter(Boolean).join(" + ");
-		console.warn(`[env-runner] failed to load wrangler config ${desc}: ${error.message}`);
-		return;
+		warnWranglerLoadError(`"${configPath}"`, error);
 	}
+	let inlineOptions;
+	if (inline) try {
+		const inlineEnv = env && isPlainObject(inline.env) && inline.env[env] ? env : void 0;
+		const { env: _env, ...inlineTopLevel } = inline;
+		const inlineConfig = readInlineWranglerConfig(wrangler, inlineEnv ? inline : inlineTopLevel, inlineEnv);
+		inlineConfig.userConfigPath = configPath;
+		if (fileLoaded && inlineConfig.secrets === void 0) inlineConfig.secrets = fileSecrets;
+		inlineOptions = pickWranglerMiniflareOptions(wrangler.unstable_getMiniflareWorkerOptions(inlineConfig, env, { envFiles }).workerOptions, dropped);
+		if (inlineOptions) {
+			delete inlineOptions.rootPath;
+			if (fileLoaded) filterInlineDevVarBindings(inlineOptions, fileOptions, inlineConfig);
+		}
+	} catch (error) {
+		warnWranglerLoadError("(inline)", error);
+	}
+	const options = mergeWranglerMiniflareOptions(fileOptions, inlineOptions);
+	filterLocalDurableObjects(options, dropped, (inline && wranglerWorkerName(inline, env)) ?? fileWorkerName);
+	warnDroppedWranglerOptions(dropped);
+	return {
+		options,
+		configFile: fileLoaded ? configPath : void 0
+	};
+}
+const _shownWranglerWarnings = /* @__PURE__ */ new Set();
+function claimWranglerWarnings(configPath, env) {
+	let version = "";
+	try {
+		const stat = statSync(configPath);
+		version = `${stat.mtimeMs}:${stat.size}`;
+	} catch {}
+	const key = JSON.stringify([
+		resolve(configPath),
+		env ?? null,
+		version
+	]);
+	if (_shownWranglerWarnings.has(key)) return false;
+	_shownWranglerWarnings.add(key);
+	return true;
+}
+function warnWranglerLoadError(desc, error) {
+	console.warn(`[env-runner] failed to load wrangler config ${desc}: ${error.message}`);
 }
 function mergeWranglerMiniflareOptions(base, override) {
 	if (!base) return override;
@@ -253,6 +490,12 @@ function mergeWranglerMiniflareOptions(base, override) {
 	}
 	return out;
 }
+function filterInlineDevVarBindings(inlineOptions, fileOptions, inlineConfig) {
+	if (!isPlainObject(inlineOptions.bindings)) return;
+	const fileBindings = isPlainObject(fileOptions?.bindings) ? fileOptions.bindings : {};
+	const declared = /* @__PURE__ */ new Set([...Object.keys(inlineConfig.vars ?? {}), ...inlineConfig.secrets?.required ?? []]);
+	inlineOptions.bindings = Object.fromEntries(Object.entries(inlineOptions.bindings).filter(([key]) => declared.has(key) || Object.hasOwn(fileBindings, key)));
+}
 function readInlineWranglerConfig(wrangler, inline, env) {
 	const dir = mkdtempSync(join(tmpdir(), "env-runner-wrangler-"));
 	const file = join(dir, "wrangler.json");
@@ -269,29 +512,173 @@ function readInlineWranglerConfig(wrangler, inline, env) {
 		});
 	}
 }
+const _announcedWranglerConfigs = /* @__PURE__ */ new Set();
 function findWranglerConfig(entryPath) {
-	const dirs = [];
+	const cwd = process.cwd();
+	let start = cwd;
 	if (entryPath) {
-		const resolved = isAbsolute(entryPath) ? entryPath : resolve(entryPath);
-		dirs.push(dirname(resolved));
+		const entryDir = dirname(resolve(entryPath));
+		const rel = relative(cwd, entryDir);
+		if (rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel)) start = entryDir;
+		else {
+			const local = findWranglerConfigInDir(entryDir);
+			if (local) return local;
+		}
+	}
+	for (let dir = start;; dir = dirname(dir)) {
+		const found = findWranglerConfigInDir(dir);
+		if (found) {
+			if (dir !== cwd && dir !== start && !_announcedWranglerConfigs.has(found)) {
+				_announcedWranglerConfigs.add(found);
+				console.info(`[env-runner] using wrangler config from a parent directory: ${found}`);
+			}
+			return found;
+		}
+		if (dirname(dir) === dir) return;
 	}
-	dirs.push(process.cwd());
-	for (const dir of dirs) for (const name of WRANGLER_CONFIG_FILENAMES) {
+}
+function findWranglerConfigInDir(dir) {
+	for (const name of WRANGLER_CONFIG_FILENAMES) {
 		const candidate = join(dir, name);
 		if (existsSync(candidate)) return candidate;
 	}
 }
-function pickWranglerMiniflareOptions(workerOptions) {
+function pickWranglerMiniflareOptions(workerOptions, dropped) {
 	const out = {};
 	for (const [key, value] of Object.entries(workerOptions)) {
 		if (value === void 0 || WRANGLER_OPTION_DENYLIST.has(key)) continue;
+		if (WRANGLER_OPTION_DROPLIST.has(key)) {
+			if (!isEmptyOption(value)) addDropped(dropped, WRANGLER_DROPPED_OPTION_NAMES[key], describeDroppedOption(value));
+			continue;
+		}
+		if (isEmptyPickedOption(key, value)) continue;
 		out[key] = value;
 	}
 	return Object.keys(out).length > 0 ? out : void 0;
 }
+function isEmptyPickedOption(key, value) {
+	const isEmptyArray = (v) => Array.isArray(v) && v.length === 0;
+	if (isEmptyArray(value) || isPlainObject(value) && Object.keys(value).length === 0) return true;
+	return key !== "bindings" && isPlainObject(value) && Object.values(value).every(isEmptyArray);
+}
+function isEmptyOption(value) {
+	return !value || Array.isArray(value) && value.length === 0 || isPlainObject(value) && Object.keys(value).length === 0;
+}
+function describeDroppedOption(value) {
+	if (Array.isArray(value)) return value.map((entry) => entry?.name).filter((name) => typeof name === "string");
+	if (isPlainObject(value)) {
+		if ("directory" in value) return typeof value.binding === "string" ? [value.binding] : [];
+		return Object.keys(value);
+	}
+	return [];
+}
+function filterLocalDurableObjects(options, dropped, workerName) {
+	const value = options?.durableObjects;
+	if (!options || !isPlainObject(value)) return;
+	const out = {};
+	for (const [name, binding] of Object.entries(value)) if (typeof binding === "string" || isPlainObject(binding) && !binding.scriptName) out[name] = binding;
+	else if (isPlainObject(binding) && workerName && binding.scriptName === workerName) {
+		const { scriptName: _scriptName, ...local } = binding;
+		out[name] = local;
+	} else {
+		const scriptName = isPlainObject(binding) ? binding.scriptName : void 0;
+		addDropped(dropped, "durable_objects", [`${name} → script "${String(scriptName)}"`]);
+	}
+	if (Object.keys(out).length > 0) options.durableObjects = out;
+	else delete options.durableObjects;
+}
+const WRANGLER_NON_INHERITABLE_KEYS = /* @__PURE__ */ new Set([
+	"vars",
+	"secrets",
+	"define",
+	"durable_objects",
+	"workflows",
+	"kv_namespaces",
+	"cloudchamber",
+	"containers",
+	"send_email",
+	"queues",
+	"connect",
+	"r2_buckets",
+	"d1_databases",
+	"vectorize",
+	"ai_search_namespaces",
+	"ai_search",
+	"websearch",
+	"agent_memory",
+	"hyperdrive",
+	"services",
+	"analytics_engine_datasets",
+	"dispatch_namespaces",
+	"mtls_certificates",
+	"tail_consumers",
+	"streaming_tail_consumers",
+	"unsafe",
+	"browser",
+	"ai",
+	"images",
+	"stream",
+	"media",
+	"pipelines",
+	"secrets_store_secrets",
+	"artifacts",
+	"unsafe_hello_world",
+	"flagship",
+	"worker_loaders",
+	"ratelimits",
+	"vpc_services",
+	"vpc_networks",
+	"version_metadata"
+]);
+const MINIMAL_UNSUPPORTED_BINDING_KEYS = [
+	"hyperdrive",
+	"analytics_engine_datasets",
+	"ai",
+	"ai_search_namespaces",
+	"ai_search",
+	"websearch",
+	"agent_memory",
+	"version_metadata",
+	"ratelimits",
+	"send_email",
+	"secrets_store_secrets",
+	"vectorize",
+	"browser",
+	"images",
+	"stream",
+	"media",
+	"pipelines",
+	"dispatch_namespaces",
+	"mtls_certificates",
+	"worker_loaders",
+	"vpc_services",
+	"vpc_networks",
+	"artifacts",
+	"flagship",
+	"containers",
+	"unsafe",
+	"unsafe_hello_world",
+	"logfwdr",
+	"wasm_modules",
+	"text_blobs",
+	"data_blobs"
+];
+const MINIMAL_BINDING_OPTIONS = [
+	"kvNamespaces",
+	"r2Buckets",
+	"d1Databases",
+	"queueProducers",
+	"durableObjects"
+];
+function warnUnsupportedMinimalBindings(unsupported) {
+	if (unsupported.size === 0) return;
+	const list = [...unsupported].map(([name, details]) => details.size > 0 ? `${name} (${[...details].join(", ")})` : name).join(", ");
+	console.warn(`[env-runner] wrangler config bindings not supported by the built-in minimal wrangler config reader were ignored: ${list}; install 'wrangler' (or pass it as \`wranglerModule\`) to use them.`);
+}
 function readWranglerConfigMinimal(configPath, env) {
-	if (extname(configPath).toLowerCase() !== ".json") {
-		console.warn(`[env-runner] reading "${basename(configPath)}" requires the 'wrangler' package; the built-in reader supports plain JSON only (install 'wrangler' for JSONC/TOML).`);
+	const ext = extname(configPath).toLowerCase();
+	if (ext !== ".json" && ext !== ".jsonc") {
+		console.warn(`[env-runner] reading "${basename(configPath)}" requires the 'wrangler' package; the built-in reader supports JSON/JSONC only (install 'wrangler' for TOML).`);
 		return;
 	}
 	let raw;
@@ -302,45 +689,203 @@ function readWranglerConfigMinimal(configPath, env) {
 	}
 	let config;
 	try {
-		config = JSON.parse(raw);
+		config = parseJSONC(raw);
 	} catch (error) {
 		console.warn(`[env-runner] failed to parse wrangler config "${configPath}": ${error.message}`);
 		return;
 	}
-	return mapWranglerConfigToMiniflare(applyWranglerEnv(config, env));
+	if (!isPlainObject(config)) {
+		warnWranglerLoadError(`"${configPath}"`, /* @__PURE__ */ new Error("config must be an object"));
+		return;
+	}
+	let envConfig;
+	try {
+		envConfig = applyWranglerEnv(config, env, configPath);
+	} catch (error) {
+		warnWranglerLoadError(`"${configPath}"`, error);
+		return;
+	}
+	return {
+		config: envConfig,
+		workerName: wranglerWorkerName(config, env)
+	};
+}
+function applyWranglerEnv(config, env, configPath) {
+	const { env: envs, ...topLevel } = config;
+	if (!env) return topLevel;
+	const rawEnv = isPlainObject(envs) ? envs[env] : void 0;
+	const warnings = [];
+	let out;
+	if (isPlainObject(rawEnv)) {
+		out = {};
+		for (const [key, value] of Object.entries(topLevel)) if (!WRANGLER_NON_INHERITABLE_KEYS.has(key)) out[key] = value;
+		else if (rawEnv[key] === void 0) warnings.push(`"${key}" exists at the top level, but is not inherited by "env.${env}"`);
+		Object.assign(out, rawEnv);
+	} else {
+		if (configPath && isPlainObject(envs)) throw new Error(`No environment found in configuration with name "${env}". The available configured environment names are: ${JSON.stringify(Object.keys(envs))}`);
+		warnings.push(`No environment found in configuration with name "${env}"`);
+		out = topLevel;
+	}
+	if (configPath && warnings.length > 0 && claimWranglerWarnings(configPath, env)) console.warn(`[env-runner] wrangler config "${configPath}": ${warnings.join("; ")}.`);
+	return out;
 }
-function applyWranglerEnv(config, env) {
-	return env && config.env?.[env] ? {
-		...config,
-		...config.env[env]
-	} : config;
+function wranglerWorkerName(config, env) {
+	const envName = env ? config.env?.[env]?.name : void 0;
+	if (typeof envName === "string") return envName;
+	if (typeof config.name !== "string" || !config.name) return void 0;
+	return env ? `${config.name}-${env}` : config.name;
 }
-function mapWranglerConfigToMiniflare(config) {
+function mapWranglerConfigToMiniflare(config, dropped, unsupported) {
 	const out = {};
+	for (const [name, value, field] of [
+		[
+			"services",
+			config.services,
+			"binding"
+		],
+		[
+			"assets",
+			config.assets,
+			"binding"
+		],
+		[
+			"queues.consumers",
+			config.queues?.consumers,
+			"queue"
+		],
+		[
+			"workflows",
+			config.workflows,
+			"binding"
+		],
+		[
+			"tail_consumers",
+			config.tail_consumers,
+			"service"
+		],
+		[
+			"streaming_tail_consumers",
+			config.streaming_tail_consumers,
+			"service"
+		]
+	]) if (!isEmptyOption(value)) addDropped(dropped, name, (Array.isArray(value) ? value : [value]).map((e) => e?.[field]).filter((d) => typeof d === "string"));
+	for (const key of MINIMAL_UNSUPPORTED_BINDING_KEYS) {
+		const value = config[key];
+		const bindings = isPlainObject(value) && Array.isArray(value.bindings) ? value.bindings : value;
+		if (!isEmptyOption(bindings)) addDropped(unsupported, key, describeBindingNames(bindings));
+	}
 	if (typeof config.compatibility_date === "string") out.compatibilityDate = config.compatibility_date;
 	if (Array.isArray(config.compatibility_flags)) out.compatibilityFlags = config.compatibility_flags;
 	if (config.vars && typeof config.vars === "object") out.bindings = { ...config.vars };
-	const kv = mapBindingArray(config.kv_namespaces, "binding", (n) => n.id ?? n.binding);
+	const kv = mapBindingArray(config.kv_namespaces, "binding", (n) => firstString(n.preview_id, n.id, n.binding));
 	if (kv) out.kvNamespaces = kv;
-	const r2 = mapBindingArray(config.r2_buckets, "binding", (n) => n.bucket_name ?? n.binding);
+	const r2 = mapBindingArray(config.r2_buckets, "binding", (n) => firstString(n.preview_bucket_name, n.bucket_name, n.binding));
 	if (r2) out.r2Buckets = r2;
-	const d1 = mapBindingArray(config.d1_databases, "binding", (n) => n.database_id ?? n.preview_database_id ?? n.binding);
+	const d1 = mapBindingArray(config.d1_databases, "binding", (n) => firstString(n.preview_database_id, n.database_id, n.binding));
 	if (d1) out.d1Databases = d1;
 	const queues = mapBindingArray(config.queues?.producers, "binding", (n) => n.queue);
 	if (queues) out.queueProducers = queues;
-	if (Array.isArray(config.durable_objects?.bindings)) {
-		const dos = {};
-		for (const b of config.durable_objects.bindings) {
-			if (!b?.name || !b?.class_name) continue;
-			dos[b.name] = b.script_name ? {
-				className: b.class_name,
-				scriptName: b.script_name
-			} : b.class_name;
-		}
-		if (Object.keys(dos).length > 0) out.durableObjects = dos;
+	const useSQLite = durableObjectClassStorage(config);
+	const doBindings = Array.isArray(config.durable_objects?.bindings) ? config.durable_objects.bindings : [];
+	const dos = {};
+	for (const b of doBindings) {
+		if (!b?.name || !b?.class_name) continue;
+		dos[b.name] = {
+			className: b.class_name,
+			...b.script_name ? { scriptName: b.script_name } : {},
+			...useSQLite.has(b.class_name) ? { useSQLite: useSQLite.get(b.class_name) } : {}
+		};
 	}
+	if (Object.keys(dos).length > 0) out.durableObjects = dos;
+	const unbound = [...useSQLite].filter(([className]) => !doBindings.some((b) => b?.class_name === className)).map(([className, sqlite]) => ({
+		className,
+		useSQLite: sqlite
+	}));
+	if (unbound.length > 0) out.additionalUnboundDurableObjects = unbound;
 	return Object.keys(out).length > 0 ? out : void 0;
 }
+function durableObjectClassStorage(config) {
+	const classes = /* @__PURE__ */ new Map();
+	for (const migration of Array.isArray(config.migrations) ? config.migrations : []) {
+		for (const name of migration?.deleted_classes ?? []) classes.delete(name);
+		for (const { from, to } of migration?.renamed_classes ?? []) {
+			const sqlite = classes.get(from);
+			if (sqlite !== void 0) {
+				classes.delete(from);
+				classes.set(to, sqlite);
+			}
+		}
+		for (const name of migration?.new_classes ?? []) classes.set(name, false);
+		for (const name of migration?.new_sqlite_classes ?? []) classes.set(name, true);
+	}
+	if (isPlainObject(config.exports)) for (const [name, entry] of Object.entries(config.exports)) {
+		const state = entry?.state;
+		if (entry?.type === "durable-object" && (state === void 0 || state === "created" || state === "expecting-transfer")) classes.set(name, entry.storage === "sqlite");
+	}
+	return classes;
+}
+function describeBindingNames(value) {
+	if (isPlainObject(value) && typeof value.binding !== "string") return Object.keys(value);
+	return (Array.isArray(value) ? value : [value]).map((e) => e?.binding ?? e?.name ?? e?.class_name).filter((name) => typeof name === "string");
+}
+function applyMinimalDevVars(options, configs, opts) {
+	const secrets = configs.map((c) => c?.secrets).filter(isPlainObject);
+	const loaded = loadDevVars({
+		...opts,
+		hasSecrets: secrets.length > 0
+	});
+	if (!loaded) return options;
+	const out = { ...options };
+	const bindings = isPlainObject(out.bindings) ? { ...out.bindings } : {};
+	const taken = new Set(MINIMAL_BINDING_OPTIONS.flatMap((key) => isPlainObject(out[key]) ? Object.keys(out[key]) : []));
+	const required = new Set(secrets.flatMap((s) => Array.isArray(s.required) ? s.required : []));
+	let changed = false;
+	for (const [key, value] of Object.entries(loaded)) {
+		if (taken.has(key) || secrets.length > 0 && !Object.hasOwn(bindings, key) && !required.has(key)) continue;
+		bindings[key] = value;
+		changed = true;
+	}
+	const missing = [...required].filter((key) => !Object.hasOwn(loaded, key));
+	if (missing.length > 0) console.warn(`[env-runner] missing required wrangler secrets: ${missing.join(", ")}. Add them to .dev.vars, .env, or set as environment variables.`);
+	if (!changed) return options;
+	out.bindings = bindings;
+	return out;
+}
+function firstString(...values) {
+	return values.find((value) => typeof value === "string");
+}
+function parseJSONC(text) {
+	let out = "";
+	let comma = -1;
+	const src = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+	for (let i = 0; i < src.length; i++) {
+		const ch = src[i];
+		if (ch === "/" && (src[i + 1] === "/" || src[i + 1] === "*")) {
+			const line = src[i + 1] === "/";
+			let end = line ? src.indexOf("\n", i) : src.indexOf("*/", i + 2);
+			end = end === -1 ? src.length : line ? end : end + 2;
+			out += src.slice(i, end).replace(/[^\n]/g, " ");
+			i = end - 1;
+			continue;
+		}
+		if (/\s/.test(ch)) {
+			out += ch;
+			continue;
+		}
+		if ((ch === "}" || ch === "]") && comma !== -1) out = `${out.slice(0, comma)} ${out.slice(comma + 1)}`;
+		comma = -1;
+		if (ch === "\"") {
+			let end = i + 1;
+			while (end < src.length && src[end] !== "\"") end += src[end] === "\\" ? 2 : 1;
+			out += src.slice(i, end + 1);
+			i = end;
+			continue;
+		}
+		if (ch === ",") comma = out.length;
+		out += ch;
+	}
+	return JSON.parse(out);
+}
 function mapBindingArray(arr, keyField, value) {
 	if (!Array.isArray(arr)) return;
 	const out = {};
@@ -367,6 +912,9 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 	#exportConditions;
 	#wrangler;
 	#wranglerEnv;
+	#wranglerConfigPath;
+	#wranglerEnvFiles;
+	#compatibilityDate;
 	#wranglerModule;
 	#miniflareModule;
 	constructor(opts) {
@@ -384,6 +932,9 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 		this.#wrangler = opts.wrangler ?? false;
 		this.#wranglerEnv = opts.wranglerEnv ?? process.env.CLOUDFLARE_ENV;
 		this.#wranglerModule = opts.wranglerModule;
+		this.#wranglerConfigPath = opts.wranglerConfigPath;
+		this.#wranglerEnvFiles = opts.wranglerEnvFiles;
+		this.#compatibilityDate = opts.compatibilityDate;
 		this._initWithVirtualData(() => this.#init());
 	}
 	static async disposeAll() {
@@ -408,8 +959,12 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 		for (let i = 0; i < 5 && !this._address && !this.closed; i++) await new Promise((r) => setTimeout(r, 100 * Math.pow(2, i)));
 		if (!this.#miniflare || this.closed) return new Response("miniflare env runner is unavailable", { status: 503 });
 		const resolved = this._resolveFetchInput(input);
-		const url = typeof resolved === "string" ? resolved : resolved instanceof URL ? resolved.href : resolved.url;
-		const res = await this.#miniflare.dispatchFetch(url, init);
+		const request = typeof resolved === "string" || resolved instanceof URL ? new Request(resolved, init) : new Request(new Request(resolved.url, resolved), {
+			...init,
+			referrer: init?.referrer ?? resolved.referrer,
+			referrerPolicy: init?.referrerPolicy ?? resolved.referrerPolicy
+		});
+		const res = await this.#miniflare.dispatchFetch(request.url, request);
 		if (res instanceof Response) return res;
 		return new Response(res.body, {
 			status: res.status,
@@ -529,20 +1084,28 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 		const entryPath = this._data?.entry;
 		const virtual = await this.#prepareVirtualModules();
 		this.#virtual = virtual;
-		const wranglerOptions = await loadWranglerConfig(this.#wrangler, this.#wranglerEnv, entryPath, this.#wranglerModule);
+		const { options: wranglerOptions, configFile: wranglerConfigFile } = await loadWranglerConfig({
+			wrangler: this.#wrangler,
+			env: this.#wranglerEnv,
+			entryPath,
+			configPath: this.#wranglerConfigPath,
+			wranglerModule: this.#wranglerModule,
+			envFiles: this.#wranglerEnvFiles
+		});
 		const userFlags = this.#miniflareOptions.compatibilityFlags || [];
 		const wranglerFlags = wranglerOptions?.compatibilityFlags || [];
 		const userDirectSockets = this.#miniflareOptions.unsafeDirectSockets || [];
 		const options = {
-			compatibilityDate: supportedCompatibilityDate,
 			modules: true,
+			...this.#wrangler && !hasUserPersistOptions(this.#miniflareOptions) ? { defaultPersistRoot: wranglerPersistRoot(wranglerConfigFile, typeof this.#wrangler === "string" ? this.#wrangler : this.#wranglerConfigPath) } : void 0,
 			...wranglerOptions,
 			...this.#miniflareOptions,
-			compatibilityFlags: [.../* @__PURE__ */ new Set([
-				"nodejs_compat",
-				...wranglerFlags,
-				...userFlags
-			])],
+			compatibilityDate: resolveCompatibilityDate([
+				this.#miniflareOptions.compatibilityDate,
+				this.#compatibilityDate === "latest" ? supportedCompatibilityDate : this.#compatibilityDate,
+				wranglerOptions?.compatibilityDate
+			], supportedCompatibilityDate),
+			compatibilityFlags: resolveCompatibilityFlags(wranglerFlags, userFlags),
 			unsafeDirectSockets: [{
 				host: "127.0.0.1",
 				port: 0
@@ -563,22 +1126,25 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 			const entrySource = entryIsVirtual ? virtual[entryPath] : _tryReadFile(resolvedEntry);
 			const detectedExports = this.#exports === false || this.#exports === void 0 ? [] : detectExportedClasses(entrySource, typeof this.#exports === "object" ? this.#exports : {});
 			if (entryIsVirtual && detectedExports.length > 0) throw new Error(`[env-runner] named exports (${detectedExports.join(", ")}) are not supported with a virtual entry on the miniflare runner; pass \`exports: false\` or use a real entry file.`);
-			if (detectedExports.length > 0 && !options.durableObjects) {
-				const autoDOs = { ...this.#miniflareOptions.durableObjects || {} };
+			if (detectedExports.length > 0) {
+				const existingDOs = isPlainObject(options.durableObjects) ? options.durableObjects : {};
+				const boundClasses = new Set(Object.values(existingDOs).map((b) => typeof b === "string" ? b : isPlainObject(b) && !b.scriptName ? b.className : void 0));
+				const autoDOs = { ...existingDOs };
 				for (const name of detectedExports) {
 					const bindingName = toScreamingSnakeCase(name);
-					if (!autoDOs[bindingName]) autoDOs[bindingName] = name;
+					if (!autoDOs[bindingName] && !boundClasses.has(name)) autoDOs[bindingName] = name;
 				}
 				options.durableObjects = autoDOs;
 			}
 			options.script = generateWrapper(resolvedEntry, {
 				dynamicOnly: true,
 				captureErrors: this.#captureErrors,
-				exports: detectedExports
+				exports: detectedExports,
+				nodeCompat: !options.compatibilityFlags.includes("no_nodejs_compat")
 			});
 			options.scriptPath = entryDir + "/__env_runner_wrapper.mjs";
 			if (!options.modulesRoot) options.modulesRoot = "/";
-			options.unsafeEvalBinding = "__ENV_RUNNER_UNSAFE_EVAL__";
+			options.unsafeEvalBinding = UNSAFE_EVAL_BINDING;
 			options.serviceBindings = {
 				...options.serviceBindings || {},
 				[IPC_BINDING]: async (request) => {
@@ -773,6 +1339,30 @@ function detectExportedClasses(entrySource, explicit) {
 	}
 	return [...names];
 }
+function resolveCompatibilityDate(candidates, supported) {
+	const date = candidates.find((d) => typeof d === "string" && d) ?? supported;
+	if (date && supported && _isDateString(date) && _isDateString(supported) && date > supported) {
+		console.warn(`[env-runner] compatibility date "${date}" is newer than the installed workerd supports; falling back to "${supported}".`);
+		return supported;
+	}
+	return date;
+}
+function resolveCompatibilityFlags(wranglerFlags, userFlags) {
+	const opposite = (flag) => flag === "nodejs_compat" ? "no_nodejs_compat" : flag === "no_nodejs_compat" ? "nodejs_compat" : void 0;
+	const flags = [...wranglerFlags.filter((flag) => !userFlags.includes(opposite(flag))), ...userFlags];
+	const defaults = flags.includes("no_nodejs_compat") ? [] : ["nodejs_compat"];
+	return [.../* @__PURE__ */ new Set([...defaults, ...flags])];
+}
+function _isDateString(value) {
+	return /^\d{4}-\d{2}-\d{2}$/.test(value);
+}
+function hasUserPersistOptions(options) {
+	return Object.keys(options).some((key) => key === "defaultPersistRoot" || key.endsWith("Persist"));
+}
+function wranglerPersistRoot(configFile, explicitPath) {
+	const file = configFile ?? (explicitPath ? resolve(explicitPath) : void 0);
+	return join(file ? dirname(file) : process.cwd(), ".wrangler/state/v3");
+}
 function _tryReadFile(path) {
 	try {
 		return readFileSync(path, "utf8");
@@ -799,16 +1389,15 @@ function applyVirtualVersions(code, versions) {
 	let out = "";
 	let last = 0;
 	for (const imp of imports) {
-		let specifier = imp.n;
-		if (specifier === void 0 && imp.d > -1) {
-			const expr = code.slice(imp.s, imp.e);
-			if (expr.length > 1 && expr[0] === "`" && expr.endsWith("`") && !expr.includes("${")) specifier = expr.slice(1, -1);
-		}
+		if (imp.type === "import-meta") continue;
+		const dynamic = imp.type === "dynamic";
+		if (dynamic && imp.glob) continue;
+		const specifier = imp.specifier;
 		const version = specifier === void 0 ? void 0 : versions.get(specifier);
 		if (!version) continue;
 		const versioned = `${specifier}?v=${version}`;
-		out += code.slice(last, imp.s) + (imp.d > -1 ? JSON.stringify(versioned) : versioned);
-		last = imp.e;
+		out += code.slice(last, imp.start) + (dynamic ? JSON.stringify(versioned) : versioned);
+		last = imp.end;
 	}
 	return out + code.slice(last);
 }