@cloudflare/vitest-pool-workers 0.15.0 → 0.15.1

package/dist/pool/index.mjs

@@ -1,11 +1,13 @@
 import { createRequire } from "node:module";
 import assert from "node:assert";
-import crypto from "node:crypto";
-import fs, { existsSync, readFileSync, statSync } from "node:fs";
+import crypto, { createHash } from "node:crypto";
+import fs, { accessSync, chmodSync, constants, existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import path, { dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import util from "node:util";
-import os from "node:os";
+import os, { arch } from "node:os";
+import { execFileSync, spawn } from "node:child_process";
+import { fetch } from "undici";
 import net from "node:net";
 import { Log, LogLevel, Miniflare, ModuleRuleTypeSchema, PLUGINS, Response, compileModuleRules, formatZodError, getNodeCompat, getRootPath, kCurrentWorker, kUnsafeEphemeralUniqueKey, maybeApply, mergeWorkerOptions, parseWithRootPath, structuredSerializableReducers, structuredSerializableRevivers, testRegExps } from "miniflare";
 import { experimental_readRawConfig } from "wrangler";
@@ -3412,6 +3414,113 @@ var require_mod_cjs3 = __commonJS({ "../../node_modules/.pnpm/xdg-app-paths@8.3.
 	var node_js_1 = require_node3();
 	module$1.exports = XDGAppPaths_js_1.Adapt(node_js_1.adapter).XDGAppPaths;
 } });
+var require_command_exists = __commonJS({ "../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/lib/command-exists.js"(exports$1, module$1) {
+	var exec = __require("child_process").exec;
+	var execSync = __require("child_process").execSync;
+	var fs2 = __require("fs");
+	var path4 = __require("path");
+	var access = fs2.access;
+	var accessSync2 = fs2.accessSync;
+	var constants2 = fs2.constants || fs2;
+	var isUsingWindows = process.platform == "win32";
+	var fileNotExists = /* @__PURE__ */ __name(function(commandName, callback) {
+		access(commandName, constants2.F_OK, function(err) {
+			callback(!err);
+		});
+	}, "fileNotExists");
+	var fileNotExistsSync = /* @__PURE__ */ __name(function(commandName) {
+		try {
+			accessSync2(commandName, constants2.F_OK);
+			return false;
+		} catch (e2) {
+			return true;
+		}
+	}, "fileNotExistsSync");
+	var localExecutable = /* @__PURE__ */ __name(function(commandName, callback) {
+		access(commandName, constants2.F_OK | constants2.X_OK, function(err) {
+			callback(null, !err);
+		});
+	}, "localExecutable");
+	var localExecutableSync = /* @__PURE__ */ __name(function(commandName) {
+		try {
+			accessSync2(commandName, constants2.F_OK | constants2.X_OK);
+			return true;
+		} catch (e2) {
+			return false;
+		}
+	}, "localExecutableSync");
+	var commandExistsUnix = /* @__PURE__ */ __name(function(commandName, cleanedCommandName, callback) {
+		fileNotExists(commandName, function(isFile$1) {
+			if (!isFile$1) {
+				exec("command -v " + cleanedCommandName + " 2>/dev/null && { echo >&1 " + cleanedCommandName + "; exit 0; }", function(error, stdout, stderr) {
+					callback(null, !!stdout);
+				});
+				return;
+			}
+			localExecutable(commandName, callback);
+		});
+	}, "commandExistsUnix");
+	var commandExistsWindows = /* @__PURE__ */ __name(function(commandName, cleanedCommandName, callback) {
+		if (!/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-zA-Z]:)?(?:(?:[^<>:"\|\?\*\n])+(?:\/\/|\/|\\\\|\\)?)+$/m.test(commandName)) {
+			callback(null, false);
+			return;
+		}
+		exec("where " + cleanedCommandName, function(error) {
+			if (error !== null) callback(null, false);
+			else callback(null, true);
+		});
+	}, "commandExistsWindows");
+	var commandExistsUnixSync = /* @__PURE__ */ __name(function(commandName, cleanedCommandName) {
+		if (fileNotExistsSync(commandName)) try {
+			return !!execSync("command -v " + cleanedCommandName + " 2>/dev/null && { echo >&1 " + cleanedCommandName + "; exit 0; }");
+		} catch (error) {
+			return false;
+		}
+		return localExecutableSync(commandName);
+	}, "commandExistsUnixSync");
+	var commandExistsWindowsSync = /* @__PURE__ */ __name(function(commandName, cleanedCommandName, callback) {
+		if (!/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-zA-Z]:)?(?:(?:[^<>:"\|\?\*\n])+(?:\/\/|\/|\\\\|\\)?)+$/m.test(commandName)) return false;
+		try {
+			return !!execSync("where " + cleanedCommandName, { stdio: [] });
+		} catch (error) {
+			return false;
+		}
+	}, "commandExistsWindowsSync");
+	var cleanInput = /* @__PURE__ */ __name(function(s) {
+		if (/[^A-Za-z0-9_\/:=-]/.test(s)) {
+			s = "'" + s.replace(/'/g, "'\\''") + "'";
+			s = s.replace(/^(?:'')+/g, "").replace(/\\'''/g, "\\'");
+		}
+		return s;
+	}, "cleanInput");
+	if (isUsingWindows) cleanInput = /* @__PURE__ */ __name(function(s) {
+		if (/[\\]/.test(s)) {
+			var dirname2 = "\"" + path4.dirname(s) + "\"";
+			var basename = "\"" + path4.basename(s) + "\"";
+			return dirname2 + ":" + basename;
+		}
+		return "\"" + s + "\"";
+	}, "cleanInput");
+	module$1.exports = /* @__PURE__ */ __name(function commandExists(commandName, callback) {
+		var cleanedCommandName = cleanInput(commandName);
+		if (!callback && typeof Promise !== "undefined") return new Promise(function(resolve$2, reject) {
+			commandExists(commandName, function(error, output) {
+				if (output) resolve$2(commandName);
+				else reject(error);
+			});
+		});
+		if (isUsingWindows) commandExistsWindows(commandName, cleanedCommandName, callback);
+		else commandExistsUnix(commandName, cleanedCommandName, callback);
+	}, "commandExists");
+	module$1.exports.sync = function(commandName) {
+		var cleanedCommandName = cleanInput(commandName);
+		if (isUsingWindows) return commandExistsWindowsSync(commandName, cleanedCommandName);
+		else return commandExistsUnixSync(commandName, cleanedCommandName);
+	};
+} });
+var require_command_exists2 = __commonJS({ "../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/index.js"(exports$1, module$1) {
+	module$1.exports = require_command_exists();
+} });
 var defaultWranglerConfig = {
 	configPath: void 0,
 	userConfigPath: void 0,
@@ -9775,6 +9884,569 @@ Pages requires Durable Object bindings to specify the name of the Worker where t
 	}
 }
 __name(validateDurableObjectBinding2, "validateDurableObjectBinding");
+var import_command_exists = __toESM(require_command_exists2());
+var UPDATE_SERVICE_URL = "https://update.argotunnel.com";
+var CLOUDFLARED_VERSION_PATTERN = /^\d{4}\.\d+\.\d+$/;
+function sha256Hex(buffer) {
+	return createHash("sha256").update(buffer).digest("hex");
+}
+__name(sha256Hex, "sha256Hex");
+function getGoArch() {
+	const nodeArch = arch();
+	switch (nodeArch) {
+		case "x64": return "amd64";
+		case "arm64": return "arm64";
+		case "arm": return "arm";
+		default: throw new UserError(`Unsupported architecture for cloudflared: ${nodeArch}
+
+cloudflared supports: x64 (amd64), arm64, arm
+
+You can manually install cloudflared and set the CLOUDFLARED_PATH environment variable.
+Download instructions: https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/`);
+	}
+}
+__name(getGoArch, "getGoArch");
+function getGoOS() {
+	switch (process.platform) {
+		case "darwin": return "darwin";
+		case "linux": return "linux";
+		case "win32": return "windows";
+		default: throw new UserError(`Unsupported platform for cloudflared: ${process.platform}
+
+cloudflared supports: darwin (macOS), linux, win32 (Windows)
+
+You can manually install cloudflared and set the CLOUDFLARED_PATH environment variable.
+Download instructions: https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/`);
+	}
+}
+__name(getGoOS, "getGoOS");
+var GITHUB_RELEASE_BASE = "https://github.com/cloudflare/cloudflared/releases/download";
+function getAssetFilename(goOS, goArch) {
+	if (goOS === "windows") return `cloudflared-${goOS}-${goArch}.exe`;
+	if (goOS === "darwin") return `cloudflared-${goOS}-${goArch}.tgz`;
+	return `cloudflared-${goOS}-${goArch}`;
+}
+__name(getAssetFilename, "getAssetFilename");
+async function queryUpdateService(goOS, goArch, options) {
+	const { logger } = options ?? {};
+	const url = new URL(UPDATE_SERVICE_URL);
+	url.searchParams.set("os", goOS);
+	url.searchParams.set("arch", goArch);
+	logger?.debug(`Checking for latest cloudflared: ${url.toString()}`);
+	let response;
+	try {
+		response = await fetch(url.toString(), { headers: { "User-Agent": "wrangler" } });
+	} catch (e2) {
+		logger?.debug(`Failed to reach update service: ${e2 instanceof Error ? e2.message : String(e2)}`);
+		return null;
+	}
+	if (!response.ok) {
+		logger?.debug(`Update service returned ${response.status} for ${goOS}/${goArch}`);
+		return null;
+	}
+	let data;
+	try {
+		data = await response.json();
+	} catch (e2) {
+		logger?.debug(`Update service returned non-JSON response: ${e2 instanceof Error ? e2.message : String(e2)}`);
+		return null;
+	}
+	if (typeof data.version === "string" && !CLOUDFLARED_VERSION_PATTERN.test(data.version)) throw new Error(`[cloudflared] Invalid cloudflared version returned by update service: ${data.version}`);
+	if (data.error || !data.url || !data.version) return data.version ? data : null;
+	return data;
+}
+__name(queryUpdateService, "queryUpdateService");
+async function getLatestVersionInfo(options) {
+	const { logger } = options ?? {};
+	const goOS = getGoOS();
+	const goArch = getGoArch();
+	const primary = await queryUpdateService(goOS, goArch, { logger });
+	if (primary && primary.url && primary.version) return primary;
+	logger?.debug(`Update worker had no result for ${goOS}/${goArch}, falling back to GitHub release URL`);
+	const fallback = await queryUpdateService("linux", "amd64", { logger });
+	if (!fallback?.version) throw new UserError(`[cloudflared] Failed to determine the latest cloudflared version.
+
+The update service did not return results for ${goOS}/${goArch},
+and the fallback query also failed.
+
+You can manually install cloudflared from:
+https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/`);
+	const version = fallback.version;
+	const filename = getAssetFilename(goOS, goArch);
+	return {
+		url: `${GITHUB_RELEASE_BASE}/${version}/${filename}`,
+		version,
+		checksum: "",
+		compressed: filename.endsWith(".tgz"),
+		shouldUpdate: true,
+		userMessage: "",
+		error: ""
+	};
+}
+__name(getLatestVersionInfo, "getLatestVersionInfo");
+function getCacheDir(version) {
+	return join(getGlobalWranglerConfigPath(), "cloudflared", version);
+}
+__name(getCacheDir, "getCacheDir");
+function getCloudflaredBinPath(version) {
+	const binName = process.platform === "win32" ? "cloudflared.exe" : "cloudflared";
+	return join(getCacheDir(version), binName);
+}
+__name(getCloudflaredBinPath, "getCloudflaredBinPath");
+function isBinaryExecutable(binPath) {
+	try {
+		accessSync(binPath, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+__name(isBinaryExecutable, "isBinaryExecutable");
+function validateBinary(binPath, options) {
+	const { logger } = options ?? {};
+	try {
+		const output = execFileSync(binPath, ["--version"], {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			timeout: 1e4,
+			encoding: "utf8"
+		}).trim();
+		logger?.debug(`cloudflared version: ${output}`);
+	} catch {
+		let errorMessage = `[cloudflared] Failed to validate cloudflared binary at ${binPath}
+
+`;
+		errorMessage += `This usually means:
+`;
+		errorMessage += `  - The binary is corrupted or incomplete
+`;
+		errorMessage += `  - You're missing required system libraries
+`;
+		if (process.platform === "linux") {
+			errorMessage += `
+On Linux, make sure you have the required dependencies:
+`;
+			errorMessage += `  - glibc (GNU C Library)
+`;
+			errorMessage += `  - For Debian/Ubuntu: sudo apt-get install libc6
+`;
+		}
+		const cacheDir = join(getGlobalWranglerConfigPath(), "cloudflared");
+		errorMessage += `
+You can try:
+`;
+		errorMessage += `  1. Deleting the cache directory: rm -rf ${cacheDir}
+`;
+		errorMessage += `  2. Running the command again to re-download
+`;
+		errorMessage += `  3. Manually installing cloudflared: https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/
+`;
+		errorMessage += `  4. Setting CLOUDFLARED_PATH to point to your cloudflared binary`;
+		throw new UserError(errorMessage);
+	}
+}
+__name(validateBinary, "validateBinary");
+function redactCloudflaredArgsForLogging(args) {
+	const redacted = [...args];
+	for (let i = 0; i < redacted.length; i++) {
+		const arg = redacted[i];
+		if (arg === "--token" && i + 1 < redacted.length) redacted[i + 1] = "[REDACTED]";
+		if (arg.startsWith("--token=")) redacted[i] = "--token=[REDACTED]";
+	}
+	return redacted;
+}
+__name(redactCloudflaredArgsForLogging, "redactCloudflaredArgsForLogging");
+function tryGetCloudflaredFromPath(options) {
+	const { logger } = options ?? {};
+	if (!(0, import_command_exists.sync)("cloudflared")) return null;
+	try {
+		validateBinary("cloudflared", { logger });
+		return "cloudflared";
+	} catch (e2) {
+		logger?.debug("cloudflared found in PATH but failed validation", e2);
+		return null;
+	}
+}
+__name(tryGetCloudflaredFromPath, "tryGetCloudflaredFromPath");
+function getInstalledVersion(binPath) {
+	try {
+		const match = execFileSync(binPath, ["--version"], {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			timeout: 1e4,
+			encoding: "utf8"
+		}).match(/(\d+\.\d+\.\d+)/);
+		return match ? match[1] : null;
+	} catch {
+		return null;
+	}
+}
+__name(getInstalledVersion, "getInstalledVersion");
+function isVersionOutdated(installed, latest) {
+	const parse$2 = /* @__PURE__ */ __name((v) => v.split(".").map(Number), "parse");
+	const [iYear, iMonth, iPatch] = parse$2(installed);
+	const [lYear, lMonth, lPatch] = parse$2(latest);
+	if (iYear !== lYear) return iYear < lYear;
+	if (iMonth !== lMonth) return iMonth < lMonth;
+	return iPatch < lPatch;
+}
+__name(isVersionOutdated, "isVersionOutdated");
+async function warnIfOutdated(binPath, options) {
+	const { logger } = options ?? {};
+	try {
+		const installed = getInstalledVersion(binPath);
+		if (!installed) return;
+		const latestVersion = (await queryUpdateService(getGoOS(), getGoArch(), { logger }) ?? await queryUpdateService("linux", "amd64", { logger }))?.version;
+		if (!latestVersion) return;
+		if (isVersionOutdated(installed, latestVersion)) logger?.warn(`Your cloudflared (${installed}) is outdated. Latest version is ${latestVersion}.
+Update: https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/`);
+	} catch (e2) {
+		logger?.debug("Failed to check cloudflared version", e2);
+	}
+}
+__name(warnIfOutdated, "warnIfOutdated");
+function writeFileAtomic(filePath, contents) {
+	const tmpPath = join(dirname(filePath), `.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+	try {
+		writeFileSync(tmpPath, contents);
+		renameSync(tmpPath, filePath);
+	} finally {
+		try {
+			if (existsSync(tmpPath)) unlinkSync(tmpPath);
+		} catch {}
+	}
+}
+__name(writeFileAtomic, "writeFileAtomic");
+async function downloadCloudflared(versionInfo, binPath, options) {
+	const { logger } = options ?? {};
+	const { url, version, checksum, compressed } = versionInfo;
+	logger?.log(`Downloading cloudflared ${version}...`);
+	logger?.debug(`Download URL: ${url}`);
+	const cacheDir = dirname(binPath);
+	mkdirSync(cacheDir, { recursive: true });
+	let response;
+	try {
+		response = await fetch(url, { headers: { "User-Agent": "wrangler" } });
+	} catch (e2) {
+		throw new UserError(`[cloudflared] Failed to download cloudflared from ${url}
+
+Network error: ${e2 instanceof Error ? e2.message : String(e2)}
+
+Please check your internet connection and try again.
+If you're behind a proxy, make sure it's configured correctly.`);
+	}
+	if (!response.ok) throw new UserError(`[cloudflared] Failed to download cloudflared from ${url}
+
+HTTP ${response.status}: ${response.statusText}
+
+You can manually download cloudflared from:
+https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/`);
+	try {
+		if (compressed) await downloadAndExtractTarball(response, checksum, binPath, cacheDir);
+		else await downloadBinary(response, checksum, binPath);
+	} catch (e2) {
+		try {
+			if (existsSync(binPath)) unlinkSync(binPath);
+		} catch {}
+		if (e2 instanceof UserError) throw e2;
+		throw new UserError(`[cloudflared] Failed to save cloudflared binary
+
+Error: ${e2 instanceof Error ? e2.message : String(e2)}
+
+Please ensure you have write permissions to: ${cacheDir}`);
+	}
+	if (process.platform !== "win32") chmodSync(binPath, 493);
+	logger?.log(`cloudflared ${version} installed`);
+	logger?.debug(`Binary location: ${binPath}`);
+}
+__name(downloadCloudflared, "downloadCloudflared");
+async function downloadAndExtractTarball(response, expectedChecksum, binPath, cacheDir) {
+	const tempTarPath = join(cacheDir, "cloudflared.tgz");
+	const buffer = Buffer.from(await response.arrayBuffer());
+	if (expectedChecksum) {
+		const actualSha256 = sha256Hex(buffer);
+		if (actualSha256 !== expectedChecksum) throw new UserError(`[cloudflared] SHA256 mismatch for downloaded cloudflared tarball.
+
+Expected: ${expectedChecksum}
+Actual:   ${actualSha256}`);
+	}
+	writeFileSync(tempTarPath, buffer);
+	try {
+		execFileSync("tar", [
+			"-xzf",
+			tempTarPath,
+			"-C",
+			cacheDir
+		], { stdio: "ignore" });
+		const extractedPath = join(cacheDir, "cloudflared");
+		if (extractedPath !== binPath && existsSync(extractedPath)) renameSync(extractedPath, binPath);
+	} finally {
+		try {
+			if (existsSync(tempTarPath)) unlinkSync(tempTarPath);
+		} catch {}
+	}
+}
+__name(downloadAndExtractTarball, "downloadAndExtractTarball");
+async function downloadBinary(response, expectedChecksum, binPath) {
+	const buffer = Buffer.from(await response.arrayBuffer());
+	if (expectedChecksum) {
+		const actualSha256 = sha256Hex(buffer);
+		if (actualSha256 !== expectedChecksum) throw new UserError(`[cloudflared] SHA256 mismatch for downloaded cloudflared binary.
+
+Expected: ${expectedChecksum}
+Actual:   ${actualSha256}`);
+	}
+	writeFileAtomic(binPath, buffer);
+}
+__name(downloadBinary, "downloadBinary");
+async function getCloudflaredPath(options) {
+	const logger = options?.logger;
+	const envPath = getCloudflaredPathFromEnv();
+	if (envPath) {
+		if (!existsSync(envPath)) throw new UserError(`CLOUDFLARED_PATH is set to "${envPath}" but the file does not exist.
+
+Please ensure the path points to a valid cloudflared binary.`);
+		logger?.debug(`Using cloudflared from CLOUDFLARED_PATH: ${envPath}`);
+		return envPath;
+	}
+	const pathBin = tryGetCloudflaredFromPath({ logger });
+	if (pathBin) {
+		logger?.debug("Using cloudflared from PATH");
+		if (!options?.skipVersionCheck) await warnIfOutdated(pathBin, { logger });
+		return pathBin;
+	}
+	const versionInfo = await getLatestVersionInfo({ logger });
+	const binPath = getCloudflaredBinPath(versionInfo.version);
+	let needsDownload = !isBinaryExecutable(binPath);
+	if (!needsDownload) try {
+		validateBinary(binPath, { logger });
+		logger?.debug(`Using cached cloudflared ${versionInfo.version}: ${binPath}`);
+		return binPath;
+	} catch (e2) {
+		logger?.debug("Cached cloudflared failed validation; re-downloading", e2);
+		needsDownload = true;
+	}
+	if (!(await options?.confirmDownload?.(`cloudflared (${versionInfo.version}) is needed but not installed. Download to ${binPath}?`) ?? true)) throw new UserError(`cloudflared is required to run this command.
+
+You can install it manually from:
+https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/
+
+Then either add it to your PATH or set CLOUDFLARED_PATH.`);
+	if (existsSync(binPath)) {
+		const cacheDir = removeCloudflaredCache(versionInfo.version);
+		if (cacheDir) logger?.log(`Removed cloudflared cache: ${cacheDir}`);
+	}
+	await downloadCloudflared(versionInfo, binPath, { logger });
+	validateBinary(binPath, { logger });
+	return binPath;
+}
+__name(getCloudflaredPath, "getCloudflaredPath");
+async function spawnCloudflared(args, options) {
+	const logger = options?.logger;
+	const binPath = await getCloudflaredPath({
+		skipVersionCheck: options?.skipVersionCheck,
+		confirmDownload: options?.confirmDownload,
+		logger
+	});
+	logger?.debug(`Spawning cloudflared: ${binPath} ${redactCloudflaredArgsForLogging(args).join(" ")}`);
+	return spawn(binPath, args, {
+		stdio: options?.stdio ?? "inherit",
+		env: options?.env ? {
+			...process.env,
+			...options.env
+		} : void 0
+	});
+}
+__name(spawnCloudflared, "spawnCloudflared");
+function removeCloudflaredCache(version) {
+	const cacheDir = version ? getCacheDir(version) : join(getGlobalWranglerConfigPath(), "cloudflared");
+	if (existsSync(cacheDir)) {
+		removeDirSync(cacheDir);
+		return cacheDir;
+	}
+	return null;
+}
+__name(removeCloudflaredCache, "removeCloudflaredCache");
+var TUNNEL_STARTUP_TIMEOUT_MS = 3e4;
+var TUNNEL_FORCE_KILL_TIMEOUT_MS = 5e3;
+var DEFAULT_TUNNEL_EXPIRY_MS = 3600 * 1e3;
+var DEFAULT_TUNNEL_EXTENSION_MS = 3600 * 1e3;
+var DEFAULT_TUNNEL_MAX_REMAINING_MS = 10800 * 1e3;
+var DEFAULT_TUNNEL_REMINDER_INTERVAL_MS = 600 * 1e3;
+var QUICK_TUNNEL_URL_REGEX = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
+function startTunnel(options) {
+	let disposed = false;
+	let reminderInterval;
+	let expiryTimeout;
+	let expiresAt = 0;
+	let cloudflaredProcess;
+	const logger = options.logger;
+	const timeoutMs = options.timeoutMs ?? TUNNEL_STARTUP_TIMEOUT_MS;
+	const reminderIntervalMs = options.reminderIntervalMs ?? DEFAULT_TUNNEL_REMINDER_INTERVAL_MS;
+	const defaultExpiryMs = options.expiryMs ?? DEFAULT_TUNNEL_EXPIRY_MS;
+	const timeFormatter = new Intl.DateTimeFormat(void 0, { timeStyle: "short" });
+	const readyPromise = spawnCloudflared([
+		"tunnel",
+		"--no-autoupdate",
+		"--url",
+		options.origin.href
+	], {
+		stdio: "pipe",
+		skipVersionCheck: true,
+		logger
+	}).then((process2) => {
+		cloudflaredProcess = process2;
+		if (disposed) terminateCloudflared(process2);
+		return process2;
+	}).then((process2) => waitForQuickTunnelReady(process2, timeoutMs, {
+		logger,
+		origin: options.origin
+	})).then((result) => {
+		expiresAt = Date.now() + defaultExpiryMs;
+		scheduleExpiryTimeout();
+		scheduleReminder(result.publicUrl.origin);
+		return result;
+	});
+	function disposeTunnel() {
+		disposed = true;
+		clearTunnelTimers();
+		if (cloudflaredProcess) terminateCloudflared(cloudflaredProcess);
+	}
+	__name(disposeTunnel, "disposeTunnel");
+	function clearTunnelTimers() {
+		if (expiryTimeout) {
+			clearTimeout(expiryTimeout);
+			expiryTimeout = void 0;
+		}
+		if (reminderInterval) {
+			clearInterval(reminderInterval);
+			reminderInterval = void 0;
+		}
+	}
+	__name(clearTunnelTimers, "clearTunnelTimers");
+	function scheduleReminder(publicURL) {
+		if (reminderIntervalMs > 0) {
+			reminderInterval = setInterval(() => {
+				if (disposed) return;
+				const remainingMs = expiresAt - Date.now();
+				if (remainingMs <= 0) return;
+				logger?.log(`The tunnel is still open at ${publicURL}. It expires in ${formatTunnelDuration(remainingMs)}. ${options.extendHint ?? ""}`);
+			}, reminderIntervalMs);
+			reminderInterval.unref?.();
+		}
+	}
+	__name(scheduleReminder, "scheduleReminder");
+	function scheduleExpiryTimeout() {
+		if (disposed) return;
+		if (expiryTimeout) clearTimeout(expiryTimeout);
+		expiryTimeout = setTimeout(() => {
+			if (disposed) return;
+			logger?.log("Tunnel expired. Closing tunnel.");
+			disposeTunnel();
+		}, Math.max(0, expiresAt - Date.now()));
+		expiryTimeout.unref();
+	}
+	__name(scheduleExpiryTimeout, "scheduleExpiryTimeout");
+	function extendExpiry(ms = DEFAULT_TUNNEL_EXTENSION_MS) {
+		if (disposed || !expiryTimeout || ms <= 0) return;
+		const now = Date.now();
+		const previousExpiresAt = expiresAt;
+		expiresAt = Math.min(now + DEFAULT_TUNNEL_MAX_REMAINING_MS, Math.max(expiresAt, now) + ms);
+		const extendedByMs = expiresAt - previousExpiresAt;
+		if (extendedByMs < ms) {
+			logger?.log(`Tunnel expiry extended to the ${formatTunnelDuration(DEFAULT_TUNNEL_MAX_REMAINING_MS)} limit. It now expires at ${timeFormatter.format(new Date(expiresAt))}.`);
+			scheduleExpiryTimeout();
+			return;
+		}
+		logger?.log(`Tunnel expiry extended by ${formatTunnelDuration(extendedByMs)}. It now expires at ${timeFormatter.format(new Date(expiresAt))}.`);
+		scheduleExpiryTimeout();
+	}
+	__name(extendExpiry, "extendExpiry");
+	return {
+		ready: /* @__PURE__ */ __name(() => readyPromise, "ready"),
+		dispose: disposeTunnel,
+		extendExpiry
+	};
+}
+__name(startTunnel, "startTunnel");
+function formatTunnelDuration(durationMs) {
+	const totalMinutes = Math.max(1, Math.ceil(durationMs / 6e4));
+	const hours = Math.floor(totalMinutes / 60);
+	const minutes = totalMinutes % 60;
+	if (hours === 0) return `${minutes}m`;
+	if (minutes === 0) return `${hours}h`;
+	return `${hours}h ${minutes}m`;
+}
+__name(formatTunnelDuration, "formatTunnelDuration");
+function terminateCloudflared(cloudflared) {
+	if (cloudflared.killed) return;
+	cloudflared.unref();
+	cloudflared.kill("SIGTERM");
+	setTimeout(() => {
+		if (!cloudflared.killed) cloudflared.kill("SIGKILL");
+	}, TUNNEL_FORCE_KILL_TIMEOUT_MS).unref();
+}
+__name(terminateCloudflared, "terminateCloudflared");
+function waitForQuickTunnelReady(cloudflared, timeoutMs, options) {
+	return new Promise((resolve$2, reject) => {
+		let resolved = false;
+		let stderrOutput = "";
+		const logger = options?.logger;
+		const origin = options?.origin;
+		const timeoutId = setTimeout(() => {
+			if (!resolved) {
+				resolved = true;
+				terminateCloudflared(cloudflared);
+				reject(createTunnelStartupError(`Timed out waiting for cloudflared to start (${timeoutMs / 1e3}s).`, stderrOutput, origin));
+			}
+		}, timeoutMs);
+		timeoutId.unref();
+		if (cloudflared.stderr) cloudflared.stderr.on("data", (data) => {
+			const chunk = data.toString();
+			stderrOutput += chunk;
+			logger?.debug("[cloudflared]", chunk.trimEnd());
+			const match = QUICK_TUNNEL_URL_REGEX.exec(stderrOutput);
+			if (match && !resolved) {
+				resolved = true;
+				clearTimeout(timeoutId);
+				resolve$2({ publicUrl: new URL(match[0]) });
+			}
+		});
+		cloudflared.on("error", (error) => {
+			if (!resolved) {
+				resolved = true;
+				clearTimeout(timeoutId);
+				reject(/* @__PURE__ */ new Error(`Failed to start cloudflared: ${error.message}`));
+			}
+		});
+		cloudflared.on("exit", (code, signal) => {
+			if (!resolved) {
+				resolved = true;
+				clearTimeout(timeoutId);
+				reject(createTunnelStartupError(`cloudflared ${signal ? `terminated by signal ${signal}` : `exited with code ${code}`} before the tunnel was ready.`, stderrOutput, origin));
+			}
+		});
+	});
+}
+__name(waitForQuickTunnelReady, "waitForQuickTunnelReady");
+function createTunnelStartupError(message, stderrOutput, origin) {
+	const isQuickTunnelRateLimited = stderrOutput.includes("429 Too Many Requests");
+	const errorMessage = `${message}
+cloudflared output:
+${stderrOutput || "(no output)"}
+
+The local dev server started at ${origin.href}.
+` + (isQuickTunnelRateLimited ? "Cloudflare Quick Tunnel creation was rate limited. Try again in a few minutes, or use a named tunnel if you need more reliable access." : `Check the cloudflared output above for more details, and verify that ${origin.href} is reachable from this machine if this keeps happening.`);
+	if (isQuickTunnelRateLimited) return new UserError(errorMessage);
+	return new Error(errorMessage);
+}
+__name(createTunnelStartupError, "createTunnelStartupError");
 
 //#endregion
 //#region ../../node_modules/.pnpm/devalue@5.6.3/node_modules/devalue/src/utils.js