unplugin-cloudflare-tunnel 0.1.0 → 0.1.2

package/dist/src-D0eR3kCb.mjs

@@ -0,0 +1,1949 @@
+import * as NodeModule from "node:module";
+import { bin, install } from "cloudflared";
+import * as NodeUtil from "node:util";
+import * as NodeChildProcess from "node:child_process";
+import { createUnplugin } from "unplugin";
+import NodeFS from "node:fs/promises";
+Object.freeze({ status: "aborted" });
+function $constructor(name, initializer, params) {
+	function init(inst, def) {
+		if (!inst._zod) Object.defineProperty(inst, "_zod", {
+			value: {
+				def,
+				constr: _,
+				traits: /* @__PURE__ */ new Set()
+			},
+			enumerable: false
+		});
+		if (inst._zod.traits.has(name)) return;
+		inst._zod.traits.add(name);
+		initializer(inst, def);
+		const proto = _.prototype;
+		const keys = Object.keys(proto);
+		for (let i = 0; i < keys.length; i++) {
+			const k = keys[i];
+			if (!(k in inst)) inst[k] = proto[k].bind(inst);
+		}
+	}
+	const Parent = params?.Parent ?? Object;
+	class Definition extends Parent {}
+	Object.defineProperty(Definition, "name", { value: name });
+	function _(def) {
+		var _a;
+		const inst = params?.Parent ? new Definition() : this;
+		init(inst, def);
+		(_a = inst._zod).deferred ?? (_a.deferred = []);
+		for (const fn of inst._zod.deferred) fn();
+		return inst;
+	}
+	Object.defineProperty(_, "init", { value: init });
+	Object.defineProperty(_, Symbol.hasInstance, { value: (inst) => {
+		if (params?.Parent && inst instanceof params.Parent) return true;
+		return inst?._zod?.traits?.has(name);
+	} });
+	Object.defineProperty(_, "name", { value: name });
+	return _;
+}
+var $ZodAsyncError = class extends Error {
+	constructor() {
+		super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+	}
+};
+const globalConfig = {};
+function config(newConfig) {
+	if (newConfig) Object.assign(globalConfig, newConfig);
+	return globalConfig;
+}
+//#endregion
+//#region node_modules/zod/v4/core/util.js
+function jsonStringifyReplacer(_, value) {
+	if (typeof value === "bigint") return value.toString();
+	return value;
+}
+function cached(getter) {
+	return { get value() {
+		{
+			const value = getter();
+			Object.defineProperty(this, "value", { value });
+			return value;
+		}
+		throw new Error("cached value already set");
+	} };
+}
+function cleanRegex(source) {
+	const start = source.startsWith("^") ? 1 : 0;
+	const end = source.endsWith("$") ? source.length - 1 : source.length;
+	return source.slice(start, end);
+}
+const EVALUATING = Symbol("evaluating");
+function defineLazy(object, key, getter) {
+	let value = void 0;
+	Object.defineProperty(object, key, {
+		get() {
+			if (value === EVALUATING) return;
+			if (value === void 0) {
+				value = EVALUATING;
+				value = getter();
+			}
+			return value;
+		},
+		set(v) {
+			Object.defineProperty(object, key, { value: v });
+		},
+		configurable: true
+	});
+}
+const captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
+function isObject(data) {
+	return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+cached(() => {
+	if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) return false;
+	try {
+		new Function("");
+		return true;
+	} catch (_) {
+		return false;
+	}
+});
+function clone(inst, def, params) {
+	const cl = new inst._zod.constr(def ?? inst._zod.def);
+	if (!def || params?.parent) cl._zod.parent = inst;
+	return cl;
+}
+function normalizeParams(_params) {
+	const params = _params;
+	if (!params) return {};
+	if (typeof params === "string") return { error: () => params };
+	if (params?.message !== void 0) {
+		if (params?.error !== void 0) throw new Error("Cannot specify both `message` and `error` params");
+		params.error = params.message;
+	}
+	delete params.message;
+	if (typeof params.error === "string") return {
+		...params,
+		error: () => params.error
+	};
+	return params;
+}
+function optionalKeys(shape) {
+	return Object.keys(shape).filter((k) => {
+		return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
+	});
+}
+Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER, -Number.MAX_VALUE, Number.MAX_VALUE;
+function aborted(x, startIndex = 0) {
+	if (x.aborted === true) return true;
+	for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue !== true) return true;
+	return false;
+}
+function prefixIssues(path, issues) {
+	return issues.map((iss) => {
+		var _a;
+		(_a = iss).path ?? (_a.path = []);
+		iss.path.unshift(path);
+		return iss;
+	});
+}
+function unwrapMessage(message) {
+	return typeof message === "string" ? message : message?.message;
+}
+function finalizeIssue(iss, ctx, config) {
+	const full = {
+		...iss,
+		path: iss.path ?? []
+	};
+	if (!iss.message) full.message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input";
+	delete full.inst;
+	delete full.continue;
+	if (!ctx?.reportInput) delete full.input;
+	return full;
+}
+//#endregion
+//#region node_modules/zod/v4/core/errors.js
+const initializer = (inst, def) => {
+	inst.name = "$ZodError";
+	Object.defineProperty(inst, "_zod", {
+		value: inst._zod,
+		enumerable: false
+	});
+	Object.defineProperty(inst, "issues", {
+		value: def,
+		enumerable: false
+	});
+	inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
+	Object.defineProperty(inst, "toString", {
+		value: () => inst.message,
+		enumerable: false
+	});
+};
+const $ZodError = $constructor("$ZodError", initializer);
+const $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
+//#endregion
+//#region node_modules/zod/v4/core/parse.js
+const _parse = (_Err) => (schema, value, _ctx, _params) => {
+	const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
+	const result = schema._zod.run({
+		value,
+		issues: []
+	}, ctx);
+	if (result instanceof Promise) throw new $ZodAsyncError();
+	if (result.issues.length) {
+		const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+		captureStackTrace(e, _params?.callee);
+		throw e;
+	}
+	return result.value;
+};
+const parse = /* @__PURE__ */ _parse($ZodRealError);
+const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
+	const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+	let result = schema._zod.run({
+		value,
+		issues: []
+	}, ctx);
+	if (result instanceof Promise) result = await result;
+	if (result.issues.length) {
+		const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+		captureStackTrace(e, params?.callee);
+		throw e;
+	}
+	return result.value;
+};
+const parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
+const _safeParse = (_Err) => (schema, value, _ctx) => {
+	const ctx = _ctx ? {
+		..._ctx,
+		async: false
+	} : { async: false };
+	const result = schema._zod.run({
+		value,
+		issues: []
+	}, ctx);
+	if (result instanceof Promise) throw new $ZodAsyncError();
+	return result.issues.length ? {
+		success: false,
+		error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+	} : {
+		success: true,
+		data: result.value
+	};
+};
+const safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
+const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+	const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+	let result = schema._zod.run({
+		value,
+		issues: []
+	}, ctx);
+	if (result instanceof Promise) result = await result;
+	return result.issues.length ? {
+		success: false,
+		error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+	} : {
+		success: true,
+		data: result.value
+	};
+};
+const safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
+const string$1 = (params) => {
+	const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+	return new RegExp(`^${regex}$`);
+};
+const number$1 = /^-?\d+(?:\.\d+)?$/;
+const boolean$1 = /^(?:true|false)$/i;
+//#endregion
+//#region node_modules/zod/v4/core/versions.js
+const version = {
+	major: 4,
+	minor: 3,
+	patch: 6
+};
+//#endregion
+//#region node_modules/zod/v4/core/schemas.js
+const $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
+	var _a;
+	inst ?? (inst = {});
+	inst._zod.def = def;
+	inst._zod.bag = inst._zod.bag || {};
+	inst._zod.version = version;
+	const checks = [...inst._zod.def.checks ?? []];
+	if (inst._zod.traits.has("$ZodCheck")) checks.unshift(inst);
+	for (const ch of checks) for (const fn of ch._zod.onattach) fn(inst);
+	if (checks.length === 0) {
+		(_a = inst._zod).deferred ?? (_a.deferred = []);
+		inst._zod.deferred?.push(() => {
+			inst._zod.run = inst._zod.parse;
+		});
+	} else {
+		const runChecks = (payload, checks, ctx) => {
+			let isAborted = aborted(payload);
+			let asyncResult;
+			for (const ch of checks) {
+				if (ch._zod.def.when) {
+					if (!ch._zod.def.when(payload)) continue;
+				} else if (isAborted) continue;
+				const currLen = payload.issues.length;
+				const _ = ch._zod.check(payload);
+				if (_ instanceof Promise && ctx?.async === false) throw new $ZodAsyncError();
+				if (asyncResult || _ instanceof Promise) asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
+					await _;
+					if (payload.issues.length === currLen) return;
+					if (!isAborted) isAborted = aborted(payload, currLen);
+				});
+				else {
+					if (payload.issues.length === currLen) continue;
+					if (!isAborted) isAborted = aborted(payload, currLen);
+				}
+			}
+			if (asyncResult) return asyncResult.then(() => {
+				return payload;
+			});
+			return payload;
+		};
+		const handleCanaryResult = (canary, payload, ctx) => {
+			if (aborted(canary)) {
+				canary.aborted = true;
+				return canary;
+			}
+			const checkResult = runChecks(payload, checks, ctx);
+			if (checkResult instanceof Promise) {
+				if (ctx.async === false) throw new $ZodAsyncError();
+				return checkResult.then((checkResult) => inst._zod.parse(checkResult, ctx));
+			}
+			return inst._zod.parse(checkResult, ctx);
+		};
+		inst._zod.run = (payload, ctx) => {
+			if (ctx.skipChecks) return inst._zod.parse(payload, ctx);
+			if (ctx.direction === "backward") {
+				const canary = inst._zod.parse({
+					value: payload.value,
+					issues: []
+				}, {
+					...ctx,
+					skipChecks: true
+				});
+				if (canary instanceof Promise) return canary.then((canary) => {
+					return handleCanaryResult(canary, payload, ctx);
+				});
+				return handleCanaryResult(canary, payload, ctx);
+			}
+			const result = inst._zod.parse(payload, ctx);
+			if (result instanceof Promise) {
+				if (ctx.async === false) throw new $ZodAsyncError();
+				return result.then((result) => runChecks(result, checks, ctx));
+			}
+			return runChecks(result, checks, ctx);
+		};
+	}
+	defineLazy(inst, "~standard", () => ({
+		validate: (value) => {
+			try {
+				const r = safeParse(inst, value);
+				return r.success ? { value: r.data } : { issues: r.error?.issues };
+			} catch (_) {
+				return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
+			}
+		},
+		vendor: "zod",
+		version: 1
+	}));
+});
+const $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string$1(inst._zod.bag);
+	inst._zod.parse = (payload, _) => {
+		if (def.coerce) try {
+			payload.value = String(payload.value);
+		} catch (_) {}
+		if (typeof payload.value === "string") return payload;
+		payload.issues.push({
+			expected: "string",
+			code: "invalid_type",
+			input: payload.value,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = inst._zod.bag.pattern ?? number$1;
+	inst._zod.parse = (payload, _ctx) => {
+		if (def.coerce) try {
+			payload.value = Number(payload.value);
+		} catch (_) {}
+		const input = payload.value;
+		if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) return payload;
+		const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
+		payload.issues.push({
+			expected: "number",
+			code: "invalid_type",
+			input,
+			inst,
+			...received ? { received } : {}
+		});
+		return payload;
+	};
+});
+const $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = boolean$1;
+	inst._zod.parse = (payload, _ctx) => {
+		if (def.coerce) try {
+			payload.value = Boolean(payload.value);
+		} catch (_) {}
+		const input = payload.value;
+		if (typeof input === "boolean") return payload;
+		payload.issues.push({
+			expected: "boolean",
+			code: "invalid_type",
+			input,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload) => payload;
+});
+const $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload) => payload;
+});
+function handleArrayResult(result, final, index) {
+	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
+	final.value[index] = result.value;
+}
+const $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!Array.isArray(input)) {
+			payload.issues.push({
+				expected: "array",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		payload.value = Array(input.length);
+		const proms = [];
+		for (let i = 0; i < input.length; i++) {
+			const item = input[i];
+			const result = def.element._zod.run({
+				value: item,
+				issues: []
+			}, ctx);
+			if (result instanceof Promise) proms.push(result.then((result) => handleArrayResult(result, payload, i)));
+			else handleArrayResult(result, payload, i);
+		}
+		if (proms.length) return Promise.all(proms).then(() => payload);
+		return payload;
+	};
+});
+function handlePropertyResult(result, final, key, input, isOptionalOut) {
+	if (result.issues.length) {
+		if (isOptionalOut && !(key in input)) return;
+		final.issues.push(...prefixIssues(key, result.issues));
+	}
+	if (result.value === void 0) {
+		if (key in input) final.value[key] = void 0;
+	} else final.value[key] = result.value;
+}
+function normalizeDef(def) {
+	const keys = Object.keys(def.shape);
+	for (const k of keys) if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
+	const okeys = optionalKeys(def.shape);
+	return {
+		...def,
+		keys,
+		keySet: new Set(keys),
+		numKeys: keys.length,
+		optionalKeys: new Set(okeys)
+	};
+}
+function handleCatchall(proms, input, payload, ctx, def, inst) {
+	const unrecognized = [];
+	const keySet = def.keySet;
+	const _catchall = def.catchall._zod;
+	const t = _catchall.def.type;
+	const isOptionalOut = _catchall.optout === "optional";
+	for (const key in input) {
+		if (keySet.has(key)) continue;
+		if (t === "never") {
+			unrecognized.push(key);
+			continue;
+		}
+		const r = _catchall.run({
+			value: input[key],
+			issues: []
+		}, ctx);
+		if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalOut)));
+		else handlePropertyResult(r, payload, key, input, isOptionalOut);
+	}
+	if (unrecognized.length) payload.issues.push({
+		code: "unrecognized_keys",
+		keys: unrecognized,
+		input,
+		inst
+	});
+	if (!proms.length) return payload;
+	return Promise.all(proms).then(() => {
+		return payload;
+	});
+}
+const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
+	$ZodType.init(inst, def);
+	if (!Object.getOwnPropertyDescriptor(def, "shape")?.get) {
+		const sh = def.shape;
+		Object.defineProperty(def, "shape", { get: () => {
+			const newSh = { ...sh };
+			Object.defineProperty(def, "shape", { value: newSh });
+			return newSh;
+		} });
+	}
+	const _normalized = cached(() => normalizeDef(def));
+	defineLazy(inst._zod, "propValues", () => {
+		const shape = def.shape;
+		const propValues = {};
+		for (const key in shape) {
+			const field = shape[key]._zod;
+			if (field.values) {
+				propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
+				for (const v of field.values) propValues[key].add(v);
+			}
+		}
+		return propValues;
+	});
+	const isObject$2 = isObject;
+	const catchall = def.catchall;
+	let value;
+	inst._zod.parse = (payload, ctx) => {
+		value ?? (value = _normalized.value);
+		const input = payload.value;
+		if (!isObject$2(input)) {
+			payload.issues.push({
+				expected: "object",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		payload.value = {};
+		const proms = [];
+		const shape = value.shape;
+		for (const key of value.keys) {
+			const el = shape[key];
+			const isOptionalOut = el._zod.optout === "optional";
+			const r = el._zod.run({
+				value: input[key],
+				issues: []
+			}, ctx);
+			if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalOut)));
+			else handlePropertyResult(r, payload, key, input, isOptionalOut);
+		}
+		if (!catchall) return proms.length ? Promise.all(proms).then(() => payload) : payload;
+		return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
+	};
+});
+function handleOptionalResult(result, input) {
+	if (result.issues.length && input === void 0) return {
+		issues: [],
+		value: void 0
+	};
+	return result;
+}
+const $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.optin = "optional";
+	inst._zod.optout = "optional";
+	defineLazy(inst._zod, "values", () => {
+		return def.innerType._zod.values ? new Set([...def.innerType._zod.values, void 0]) : void 0;
+	});
+	defineLazy(inst._zod, "pattern", () => {
+		const pattern = def.innerType._zod.pattern;
+		return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
+	});
+	inst._zod.parse = (payload, ctx) => {
+		if (def.innerType._zod.optin === "optional") {
+			const result = def.innerType._zod.run(payload, ctx);
+			if (result instanceof Promise) return result.then((r) => handleOptionalResult(r, payload.value));
+			return handleOptionalResult(result, payload.value);
+		}
+		if (payload.value === void 0) return payload;
+		return def.innerType._zod.run(payload, ctx);
+	};
+});
+const $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+	defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
+	defineLazy(inst._zod, "pattern", () => {
+		const pattern = def.innerType._zod.pattern;
+		return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
+	});
+	defineLazy(inst._zod, "values", () => {
+		return def.innerType._zod.values ? new Set([...def.innerType._zod.values, null]) : void 0;
+	});
+	inst._zod.parse = (payload, ctx) => {
+		if (payload.value === null) return payload;
+		return def.innerType._zod.run(payload, ctx);
+	};
+});
+//#endregion
+//#region node_modules/zod/v4/core/registries.js
+var _a;
+var $ZodRegistry = class {
+	constructor() {
+		this._map = /* @__PURE__ */ new WeakMap();
+		this._idmap = /* @__PURE__ */ new Map();
+	}
+	add(schema, ..._meta) {
+		const meta = _meta[0];
+		this._map.set(schema, meta);
+		if (meta && typeof meta === "object" && "id" in meta) this._idmap.set(meta.id, schema);
+		return this;
+	}
+	clear() {
+		this._map = /* @__PURE__ */ new WeakMap();
+		this._idmap = /* @__PURE__ */ new Map();
+		return this;
+	}
+	remove(schema) {
+		const meta = this._map.get(schema);
+		if (meta && typeof meta === "object" && "id" in meta) this._idmap.delete(meta.id);
+		this._map.delete(schema);
+		return this;
+	}
+	get(schema) {
+		const p = schema._zod.parent;
+		if (p) {
+			const pm = { ...this.get(p) ?? {} };
+			delete pm.id;
+			const f = {
+				...pm,
+				...this._map.get(schema)
+			};
+			return Object.keys(f).length ? f : void 0;
+		}
+		return this._map.get(schema);
+	}
+	has(schema) {
+		return this._map.has(schema);
+	}
+};
+function registry() {
+	return new $ZodRegistry();
+}
+(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
+globalThis.__zod_globalRegistry;
+//#endregion
+//#region node_modules/zod/v4/core/api.js
+/* @__NO_SIDE_EFFECTS__ */
+function _string(Class, params) {
+	return new Class({
+		type: "string",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _number(Class, params) {
+	return new Class({
+		type: "number",
+		checks: [],
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _boolean(Class, params) {
+	return new Class({
+		type: "boolean",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _any(Class) {
+	return new Class({ type: "any" });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _unknown(Class) {
+	return new Class({ type: "unknown" });
+}
+//#endregion
+//#region node_modules/zod/v4/mini/schemas.js
+const ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
+	if (!inst._zod) throw new Error("Uninitialized schema in ZodMiniType.");
+	$ZodType.init(inst, def);
+	inst.def = def;
+	inst.type = def.type;
+	inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
+	inst.safeParse = (data, params) => safeParse(inst, data, params);
+	inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
+	inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
+	inst.check = (...checks) => {
+		return inst.clone({
+			...def,
+			checks: [...def.checks ?? [], ...checks.map((ch) => typeof ch === "function" ? { _zod: {
+				check: ch,
+				def: { check: "custom" },
+				onattach: []
+			} } : ch)]
+		}, { parent: true });
+	};
+	inst.with = inst.check;
+	inst.clone = (_def, params) => clone(inst, _def, params);
+	inst.brand = () => inst;
+	inst.register = ((reg, meta) => {
+		reg.add(inst, meta);
+		return inst;
+	});
+	inst.apply = (fn) => fn(inst);
+});
+const ZodMiniString = /* @__PURE__ */ $constructor("ZodMiniString", (inst, def) => {
+	$ZodString.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function string(params) {
+	return /* @__PURE__ */ _string(ZodMiniString, params);
+}
+const ZodMiniNumber = /* @__PURE__ */ $constructor("ZodMiniNumber", (inst, def) => {
+	$ZodNumber.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function number(params) {
+	return /* @__PURE__ */ _number(ZodMiniNumber, params);
+}
+const ZodMiniBoolean = /* @__PURE__ */ $constructor("ZodMiniBoolean", (inst, def) => {
+	$ZodBoolean.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function boolean(params) {
+	return /* @__PURE__ */ _boolean(ZodMiniBoolean, params);
+}
+const ZodMiniAny = /* @__PURE__ */ $constructor("ZodMiniAny", (inst, def) => {
+	$ZodAny.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function any() {
+	return /* @__PURE__ */ _any(ZodMiniAny);
+}
+const ZodMiniUnknown = /* @__PURE__ */ $constructor("ZodMiniUnknown", (inst, def) => {
+	$ZodUnknown.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function unknown() {
+	return /* @__PURE__ */ _unknown(ZodMiniUnknown);
+}
+const ZodMiniArray = /* @__PURE__ */ $constructor("ZodMiniArray", (inst, def) => {
+	$ZodArray.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function array(element, params) {
+	return new ZodMiniArray({
+		type: "array",
+		element,
+		...normalizeParams(params)
+	});
+}
+const ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
+	$ZodObject.init(inst, def);
+	ZodMiniType.init(inst, def);
+	defineLazy(inst, "shape", () => def.shape);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function object(shape, params) {
+	return new ZodMiniObject({
+		type: "object",
+		shape: shape ?? {},
+		...normalizeParams(params)
+	});
+}
+const ZodMiniOptional = /* @__PURE__ */ $constructor("ZodMiniOptional", (inst, def) => {
+	$ZodOptional.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function optional(innerType) {
+	return new ZodMiniOptional({
+		type: "optional",
+		innerType
+	});
+}
+const ZodMiniNullable = /* @__PURE__ */ $constructor("ZodMiniNullable", (inst, def) => {
+	$ZodNullable.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function nullable(innerType) {
+	return new ZodMiniNullable({
+		type: "nullable",
+		innerType
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function nullish(innerType) {
+	return /* @__PURE__ */ optional(/* @__PURE__ */ nullable(innerType));
+}
+const CloudflareApiResponseSchema = /* @__PURE__ */ object({
+	success: /* @__PURE__ */ boolean(),
+	errors: /* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ object({
+		code: /* @__PURE__ */ number(),
+		message: /* @__PURE__ */ string()
+	}))),
+	messages: /* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
+	result: /* @__PURE__ */ unknown()
+});
+const AccountSchema = /* @__PURE__ */ object({
+	id: /* @__PURE__ */ string(),
+	name: /* @__PURE__ */ string()
+});
+const ZoneSchema = /* @__PURE__ */ object({
+	id: /* @__PURE__ */ string(),
+	name: /* @__PURE__ */ string(),
+	account: /* @__PURE__ */ optional(/* @__PURE__ */ object({ id: /* @__PURE__ */ string() }))
+});
+const TunnelSchema = /* @__PURE__ */ object({
+	id: /* @__PURE__ */ string(),
+	name: /* @__PURE__ */ string(),
+	account_tag: /* @__PURE__ */ string(),
+	created_at: /* @__PURE__ */ string(),
+	connections: /* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ unknown()))
+});
+const DNSRecordSchema = /* @__PURE__ */ object({
+	id: /* @__PURE__ */ string(),
+	type: /* @__PURE__ */ string(),
+	name: /* @__PURE__ */ string(),
+	content: /* @__PURE__ */ string(),
+	proxied: /* @__PURE__ */ boolean(),
+	comment: /* @__PURE__ */ nullish(/* @__PURE__ */ string())
+});
+function normalizeHost(host) {
+	if (!host || host === "0.0.0.0" || host === "::" || host === "::0") return "localhost";
+	return host;
+}
+function normalizeAddress(address) {
+	if (address && typeof address === "object") return {
+		host: normalizeHost("address" in address && address.address ? address.address : void 0),
+		port: "port" in address && typeof address.port === "number" ? address.port : void 0
+	};
+	return { host: "localhost" };
+}
+async function ensureCloudflaredBinary(binPath) {
+	try {
+		await NodeFS.access(binPath);
+	} catch {
+		console.log("[unplugin-cloudflare-tunnel] Installing cloudflared binary...");
+		await install(binPath);
+	}
+}
+function getLocalTarget(host, port) {
+	return `http://${host.includes(":") ? `[${host}]` : host}:${port}`;
+}
+//#endregion
+//#region src/core/process.ts
+function createKillCloudflared(params) {
+	const { getChild, clearTunnelUrl, markShuttingDown, debugLog = () => {}, platform = process.platform, exec = NodeChildProcess.exec, setTimeoutFn = setTimeout, clearTimeoutFn = clearTimeout } = params;
+	return (signal = "SIGTERM") => {
+		const child = getChild();
+		if (!child || child.killed) return Promise.resolve();
+		markShuttingDown();
+		clearTunnelUrl();
+		const activeChild = child;
+		return new Promise((resolve) => {
+			let settled = false;
+			let forceKillTimer;
+			const settle = () => {
+				if (settled) return;
+				settled = true;
+				if (forceKillTimer) clearTimeoutFn(forceKillTimer);
+				resolve();
+			};
+			activeChild.once("exit", () => {
+				settle();
+			});
+			try {
+				debugLog(`[unplugin-cloudflare-tunnel] Terminating cloudflared process (PID: ${activeChild.pid}) with ${signal}...`);
+				if (!activeChild.kill(signal)) {
+					if (platform === "win32") exec(`taskkill /pid ${activeChild.pid} /T /F`, () => settle());
+					else settle();
+					return;
+				}
+				if (signal === "SIGTERM") forceKillTimer = setTimeoutFn(() => {
+					if (settled) return;
+					debugLog("[unplugin-cloudflare-tunnel] Force killing cloudflared process...");
+					if (platform === "win32") exec(`taskkill /pid ${activeChild.pid} /T /F`, () => settle());
+					else try {
+						if (!activeChild.kill("SIGKILL")) settle();
+					} catch {
+						settle();
+					}
+				}, 2e3);
+			} catch (error) {
+				debugLog(`[unplugin-cloudflare-tunnel] Note: Error killing cloudflared: ${error instanceof Error ? error.message : String(error)}`);
+				settle();
+			}
+		});
+	};
+}
+//#endregion
+//#region src/index.ts
+/**
+* @fileoverview Cloudflare Tunnel Unplugin
+*
+* A cross-bundler plugin that automatically creates and manages
+* Cloudflare tunnels for local development, providing instant HTTPS access
+* to your local dev server from anywhere on the internet.
+*
+* @author Cloudflare Tunnel Plugin Contributors
+* @version 1.0.0
+* @license MIT
+*/
+const PLUGIN_NAME = "unplugin-cloudflare-tunnel";
+const INFO_LOG_REGEX = /^.*Z INF .*/;
+const LOG_LEVEL_RANK = {
+	debug: 10,
+	info: 20,
+	warn: 30,
+	error: 40,
+	fatal: 50
+};
+function shouldLog(threshold, level) {
+	return LOG_LEVEL_RANK[level] >= LOG_LEVEL_RANK[threshold];
+}
+function supportsColor() {
+	if (!process.stdout.isTTY) return false;
+	if (process.env.NO_COLOR !== void 0) return false;
+	if (process.env.TERM === "dumb") return false;
+	if (process.env.FORCE_COLOR === "0") return false;
+	return true;
+}
+const ANSI = {
+	reset: "\x1B[0m",
+	dim: "\x1B[2m",
+	bold: "\x1B[1m",
+	blue: "\x1B[34m",
+	yellow: "\x1B[33m"
+};
+const ANSI_STYLE_SEQUENCE_REGEX = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+function stripAnsi(text) {
+	return text.replace(ANSI_STYLE_SEQUENCE_REGEX, "");
+}
+function colorize(text, ansi) {
+	if (!supportsColor()) return text;
+	return `${ansi}${text}${ANSI.reset}`;
+}
+const unpluginFactory = (options = {}) => {
+	const { enabled = true } = options;
+	if (enabled === false) {
+		const VIRTUAL_MODULE_ID_STUB = "virtual:unplugin-cloudflare-tunnel";
+		return {
+			name: PLUGIN_NAME,
+			enforce: "pre",
+			resolveId(id) {
+				if (id === VIRTUAL_MODULE_ID_STUB) return id;
+			},
+			loadInclude(id) {
+				return id === VIRTUAL_MODULE_ID_STUB;
+			},
+			load(id) {
+				if (id === VIRTUAL_MODULE_ID_STUB) return "export function getTunnelUrl() { return \"\"; }";
+			}
+		};
+	}
+	const GLOBAL_STATE = Symbol.for("unplugin-cloudflare-tunnel.state");
+	const globalState = globalThis[GLOBAL_STATE] ?? {};
+	globalThis[GLOBAL_STATE] = globalState;
+	let child = globalState.child;
+	const VIRTUAL_MODULE_ID = "virtual:unplugin-cloudflare-tunnel";
+	const requestedMode = options.mode;
+	if (requestedMode && !["quick", "named"].includes(requestedMode)) throw new Error("[unplugin-cloudflare-tunnel] mode must be one of: 'quick', 'named'");
+	const hasHostname = "hostname" in options && typeof options.hostname === "string";
+	const isQuickMode = requestedMode ? requestedMode === "quick" : !hasHostname;
+	if (requestedMode === "named" && !hasHostname) throw new Error("[unplugin-cloudflare-tunnel] hostname is required when mode is set to named");
+	if (isQuickMode) {
+		const invalidOptions = [
+			"apiToken",
+			"accountId",
+			"zoneId",
+			"tunnelName",
+			"dns",
+			"ssl",
+			"cleanup"
+		].filter((opt) => opt in options);
+		if (invalidOptions.length > 0) throw new Error(`[unplugin-cloudflare-tunnel] The following options are only supported in named tunnel mode: ${invalidOptions.join(", ")}. Set mode to 'named' and provide a hostname, or remove these options for quick tunnel mode.`);
+	}
+	let providedApiToken;
+	let hostname;
+	let tunnelName;
+	let forcedAccount;
+	let forcedZone;
+	let dnsOption;
+	let sslOption;
+	let cleanupConfig;
+	if (isQuickMode) {
+		tunnelName = "quick-tunnel";
+		cleanupConfig = {};
+	} else {
+		const namedOptions = options;
+		providedApiToken = namedOptions.apiToken;
+		hostname = namedOptions.hostname;
+		forcedAccount = namedOptions.accountId;
+		forcedZone = namedOptions.zoneId;
+		tunnelName = namedOptions.tunnelName || "dev-tunnel";
+		dnsOption = namedOptions.dns;
+		sslOption = namedOptions.ssl;
+		cleanupConfig = namedOptions.cleanup || {};
+	}
+	const { port: userProvidedPort, logFile, logLevel, protocol = "http2", debug = false } = options;
+	const effectivePluginLogLevel = logLevel ?? (debug ? "debug" : "info");
+	const redactForDebug = (value) => {
+		if (typeof value === "string") {
+			if (value.startsWith("eyJ") && value.length > 40) return "[REDACTED_TOKEN]";
+			return value;
+		}
+		if (Array.isArray(value)) return value.map((item) => redactForDebug(item));
+		if (value && typeof value === "object") {
+			const entries = Object.entries(value).map(([key, nestedValue]) => {
+				if (/token|authorization|secret|password/i.test(key)) return [key, "[REDACTED]"];
+				return [key, redactForDebug(nestedValue)];
+			});
+			return Object.fromEntries(entries);
+		}
+		return value;
+	};
+	const formatDebugValue = (value) => {
+		const redactedValue = redactForDebug(value);
+		if (typeof redactedValue === "string") return redactedValue;
+		return NodeUtil.inspect(redactedValue, {
+			depth: null,
+			colors: supportsColor(),
+			compact: false,
+			breakLength: 120,
+			sorted: true
+		});
+	};
+	const pluginLog = {
+		debug: (...args) => {
+			if (debug || effectivePluginLogLevel === "debug") console.log("[cloudflare-tunnel:debug]", ...args.map((arg) => formatDebugValue(arg)));
+		},
+		info: (message) => {
+			if (shouldLog(effectivePluginLogLevel, "info")) console.log(`[unplugin-cloudflare-tunnel] ${message}`);
+		},
+		warn: (message) => {
+			if (shouldLog(effectivePluginLogLevel, "warn")) console.warn(`[unplugin-cloudflare-tunnel] ${message}`);
+		},
+		error: (message) => {
+			if (shouldLog(effectivePluginLogLevel, "error")) console.error(`[unplugin-cloudflare-tunnel] ${message}`);
+		}
+	};
+	const debugLog = pluginLog.debug;
+	const makeLocalDisplay = (localTarget) => {
+		if (!localTarget) return localTarget;
+		return localTarget.replace("http://[::1]:", "http://localhost:").replace("http://127.0.0.1:", "http://localhost:");
+	};
+	const announceConnecting = () => {
+		if (globalState.__tunnelConnectingAnnounced) return;
+		globalState.__tunnelConnectingAnnounced = true;
+		const message = isQuickMode ? "cf tunnel connecting…" : hostname ? `cf tunnel connecting… (${hostname})` : "cf tunnel connecting…";
+		console.log("");
+		console.log(colorize(message, ANSI.bold));
+	};
+	const announceTunnel = (params) => {
+		if (!params.url) return;
+		if (globalState.__lastAnnouncedTunnelKey === params.key) return;
+		globalState.__lastAnnouncedTunnelKey = params.key;
+		const cols = process.stdout.columns ?? 80;
+		const maxWidth = Math.max(10, cols - 2);
+		const header = `${colorize("[", ANSI.yellow)}unplugin-cloudflare-tunnel${colorize("]", ANSI.yellow)}`;
+		const urlLine = colorize(params.url, ANSI.blue + ANSI.bold);
+		const localLine = params.localTarget ? makeLocalDisplay(params.localTarget) : "";
+		const headerPlainLen = stripAnsi(header).length;
+		const contentPlainLen = Math.max(stripAnsi(urlLine).length, localLine.length, 10, 5);
+		const width = Math.min(90, maxWidth, Math.max(44, headerPlainLen, contentPlainLen + 4));
+		const rule = "─".repeat(width);
+		const center = (text) => {
+			const plainLen = stripAnsi(text).length;
+			const pad = Math.max(0, Math.floor((width - plainLen) / 2));
+			return `${" ".repeat(pad)}${text}`;
+		};
+		if (cols < 70) {
+			const out = [];
+			out.push("");
+			out.push(`${header} ${colorize("Tunnel URL", ANSI.bold)} ${urlLine}`);
+			if (localLine) out.push(`${header} ${colorize("Local", ANSI.dim + ANSI.bold)} ${localLine}`);
+			out.push("");
+			console.log(out.join("\n"));
+			return;
+		}
+		const out = [];
+		out.push("");
+		out.push(center(header));
+		out.push(rule);
+		out.push(center(colorize("Tunnel URL", ANSI.bold)));
+		out.push(center(urlLine));
+		if (localLine) {
+			out.push("");
+			out.push(center(colorize("Local", ANSI.dim + ANSI.bold)));
+			out.push(center(localLine));
+		}
+		out.push(rule);
+		out.push("");
+		console.log(out.join("\n"));
+	};
+	if (!isQuickMode && (!hostname || typeof hostname !== "string")) throw new Error("[unplugin-cloudflare-tunnel] hostname is required and must be a valid string in named tunnel mode");
+	let tunnelUrl = hostname ? `https://${hostname}` : "";
+	if (tunnelName && !/^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(tunnelName)) throw new Error("[unplugin-cloudflare-tunnel] tunnelName must contain only letters, numbers, and hyphens. It cannot start or end with a hyphen.");
+	if (userProvidedPort && (typeof userProvidedPort !== "number" || userProvidedPort < 1 || userProvidedPort > 65535)) throw new Error("[unplugin-cloudflare-tunnel] port must be a valid number between 1 and 65535");
+	if (logLevel && ![
+		"debug",
+		"info",
+		"warn",
+		"error",
+		"fatal"
+	].includes(logLevel)) throw new Error("[unplugin-cloudflare-tunnel] logLevel must be one of: debug, info, warn, error, fatal");
+	const effectiveLogLevel = logLevel ?? (debug ? "info" : "warn");
+	const cloudflaredProcessLogLevel = effectiveLogLevel === "debug" ? "debug" : "info";
+	debugLog("Effective cloudflared log level filter:", effectiveLogLevel);
+	debugLog("Effective cloudflared process log level:", cloudflaredProcessLogLevel);
+	debugLog("Effective cloudflared protocol:", protocol);
+	if (dnsOption) {
+		if (!dnsOption.startsWith("*.") && dnsOption !== hostname) throw new Error("[unplugin-cloudflare-tunnel] dns option must either be a wildcard (e.g., '*.example.com') or exactly match the hostname");
+	}
+	if (sslOption) {
+		if (!sslOption.startsWith("*.") && sslOption !== hostname) throw new Error("[unplugin-cloudflare-tunnel] ssl option must either be a wildcard (e.g., '*.example.com') or exactly match the hostname");
+	}
+	if (!["http2", "quic"].includes(protocol)) throw new Error("[unplugin-cloudflare-tunnel] protocol must be one of: 'http2', 'quic'");
+	const trackSslCertificate = (certificateId, hosts, tunnelName, timestamp = (/* @__PURE__ */ new Date()).toISOString()) => {
+		const trackingKey = `ssl-cert-${certificateId}`;
+		globalState[trackingKey] = {
+			id: certificateId,
+			hosts,
+			tunnelName,
+			timestamp,
+			pluginVersion: "1.0.0"
+		};
+		debugLog(`Tracking SSL certificate: ${certificateId} for hosts: ${hosts.join(", ")}`);
+	};
+	const cleanupMismatchedDnsRecords = async (apiToken, zoneId, dnsComment, currentHostname, tunnelId) => {
+		try {
+			const pluginDnsRecords = await cf(apiToken, "GET", `/zones/${zoneId}/dns_records?comment=${dnsComment}&match=all`, void 0, /* @__PURE__ */ array(DNSRecordSchema));
+			debugLog(`Found ${pluginDnsRecords.length} DNS records for current tunnel: ${dnsComment}`);
+			const expectedCnameContent = `${tunnelId}.cfargotunnel.com`;
+			const mismatchedRecords = pluginDnsRecords.filter((record) => {
+				if (record.name === currentHostname && record.content === expectedCnameContent) return false;
+				if (dnsOption && record.name === dnsOption && record.content === expectedCnameContent) return false;
+				return true;
+			});
+			debugLog(`Found ${mismatchedRecords.length} mismatched DNS records`, mismatchedRecords.map((r) => ({
+				name: r.name,
+				content: r.content,
+				expected: expectedCnameContent,
+				comment: r.comment
+			})));
+			const deletedRecords = [];
+			if (mismatchedRecords.length > 0) {
+				console.log(`[unplugin-cloudflare-tunnel] 🧹 Cleaning up ${mismatchedRecords.length} mismatched DNS records from tunnel '${dnsComment}'...`);
+				for (const record of mismatchedRecords) try {
+					await cf(apiToken, "DELETE", `/zones/${zoneId}/dns_records/${record.id}`);
+					deletedRecords.push(record);
+					console.log(`[unplugin-cloudflare-tunnel] ✅ Deleted mismatched DNS record: ${record.name} → ${record.content}`);
+				} catch (error) {
+					console.error(`[unplugin-cloudflare-tunnel] ❌ Failed to delete DNS record ${record.name}: ${error.message}`);
+				}
+			}
+			return {
+				found: mismatchedRecords,
+				deleted: deletedRecords
+			};
+		} catch (error) {
+			console.error(`[unplugin-cloudflare-tunnel] ❌ DNS cleanup failed: ${error.message}`);
+			return {
+				found: [],
+				deleted: []
+			};
+		}
+	};
+	const cf = async (apiToken, method, url, body, resultSchema) => {
+		try {
+			debugLog("→ CF API", method, url, body ? { body } : "");
+			const response = await fetch(`https://api.cloudflare.com/client/v4${url}`, {
+				method,
+				headers: {
+					Authorization: `Bearer ${apiToken}`,
+					"Content-Type": "application/json",
+					"User-Agent": "unplugin-cloudflare-tunnel/1.0.0"
+				},
+				...body ? { body: JSON.stringify(body) } : {}
+			});
+			if (!response.ok) {
+				const errorText = await response.text().catch(() => "Unknown error");
+				throw new Error(`[unplugin-cloudflare-tunnel] API request failed: ${response.status} ${response.statusText}. Response: ${errorText}`);
+			}
+			const rawData = await response.json();
+			debugLog("← CF API response", rawData);
+			const apiResponse = CloudflareApiResponseSchema.parse(rawData);
+			if (!apiResponse.success) {
+				const errorMsg = apiResponse.errors?.map((e) => e.message || `Error ${e.code}`).join(", ") || "Unknown API error";
+				throw new Error(`[unplugin-cloudflare-tunnel] Cloudflare API error: ${errorMsg}`);
+			}
+			if (resultSchema) {
+				const parsed = resultSchema.parse(apiResponse.result);
+				debugLog("← Parsed result", parsed);
+				return parsed;
+			}
+			debugLog("← Result (untyped)", apiResponse.result);
+			return apiResponse.result;
+		} catch (error) {
+			if (error instanceof Error) {
+				if (error.message.includes("[unplugin-cloudflare-tunnel]")) throw error;
+				throw new Error(`[unplugin-cloudflare-tunnel] API request failed: ${error.message}`);
+			}
+			throw new Error("[unplugin-cloudflare-tunnel] Unknown API error occurred");
+		}
+	};
+	const retryWithBackoff = async (fn, maxRetries = 5, initialDelayMs = 1e3) => {
+		let attempt = 0;
+		while (true) try {
+			return await fn();
+		} catch (error) {
+			attempt += 1;
+			const message = error instanceof Error ? error.message : String(error);
+			if (attempt > maxRetries) {
+				console.error(`[unplugin-cloudflare-tunnel] ❌ Edge certificate request failed after ${maxRetries} retries: ${message}`);
+				throw error;
+			}
+			const delay = initialDelayMs * 2 ** (attempt - 1);
+			console.error(`[unplugin-cloudflare-tunnel] ⚠️  Edge certificate request failed (attempt ${attempt}/${maxRetries}): ${message}`);
+			console.error(`[unplugin-cloudflare-tunnel] ⏳ Retrying in ${delay}ms...`);
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		}
+	};
+	const spawnQuickTunnel = async (localTarget, protocol) => {
+		const cloudflaredArgs = ["tunnel"];
+		cloudflaredArgs.push("--loglevel", "info");
+		if (logFile) cloudflaredArgs.push("--logfile", logFile);
+		cloudflaredArgs.push("--protocol", protocol);
+		cloudflaredArgs.push("--url", localTarget);
+		debugLog("Spawning quick tunnel:", bin, cloudflaredArgs);
+		const child = NodeChildProcess.spawn(bin, cloudflaredArgs, {
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			detached: false,
+			windowsHide: true,
+			shell: process.platform === "win32"
+		});
+		debugLog(`[unplugin-cloudflare-tunnel] Quick tunnel process spawned with PID: ${child.pid}`);
+		return new Promise((resolve, reject) => {
+			let urlFound = false;
+			let settled = false;
+			const rejectOnce = (error) => {
+				if (settled) return;
+				settled = true;
+				reject(error);
+			};
+			const resolveOnce = (result) => {
+				if (settled) return;
+				settled = true;
+				resolve(result);
+			};
+			const timeout = setTimeout(() => {
+				if (!urlFound) {
+					try {
+						child.kill("SIGTERM");
+					} catch {}
+					rejectOnce(/* @__PURE__ */ new Error("Quick tunnel URL not found in output within 30 seconds"));
+				}
+			}, 3e4);
+			child.stdout?.on("data", (data) => {
+				const output = data.toString();
+				if (!globalState.shuttingDown || debug) {
+					if (effectiveLogLevel === "debug" || effectiveLogLevel === "info") console.log(`[cloudflared stdout] ${output.trim()}`);
+					else for (const line of output.split("\n")) if (!INFO_LOG_REGEX.test(line)) console.log(`[cloudflared stdout] ${line.trim()}`);
+				}
+			});
+			child.stderr?.on("data", (data) => {
+				const error = data.toString().trim();
+				const urlMatch = error.match(/https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/);
+				if (urlMatch && !urlFound) {
+					urlFound = true;
+					clearTimeout(timeout);
+					resolveOnce({
+						child,
+						url: urlMatch[0]
+					});
+				}
+				if (error.includes("Failed to parse ICMP reply") || error.includes("unknow ip version 0")) {
+					if (logLevel === "debug") console.log(`[cloudflared debug] ${error}`);
+					return;
+				}
+				if (!globalState.shuttingDown || debug) {
+					if (effectiveLogLevel === "debug" || effectiveLogLevel === "info") console.error(`[cloudflared stderr] ${error}`);
+					else for (const line of error.split("\n")) if (!INFO_LOG_REGEX.test(line)) console.error(`[cloudflared stderr] ${line.trim()}`);
+				}
+			});
+			child.on("error", (error) => {
+				clearTimeout(timeout);
+				rejectOnce(/* @__PURE__ */ new Error(`Failed to start quick tunnel process: ${error.message}`));
+			});
+			child.on("exit", (code, signal) => {
+				clearTimeout(timeout);
+				if (!urlFound) rejectOnce(/* @__PURE__ */ new Error(`Quick tunnel process exited before URL was found (code: ${code}, signal: ${signal})`));
+			});
+		});
+	};
+	const killCloudflared = createKillCloudflared({
+		getChild: () => child,
+		clearTunnelUrl: () => {
+			globalState.tunnelUrl = void 0;
+		},
+		markShuttingDown: () => {
+			globalState.shuttingDown = true;
+		},
+		debugLog
+	});
+	let exitHandlersRegistered = globalState.exitHandlersRegistered ?? false;
+	const registerExitHandler = () => {
+		if (exitHandlersRegistered) return;
+		exitHandlersRegistered = true;
+		globalState.exitHandlersRegistered = true;
+		const cleanup = () => killCloudflared("SIGTERM");
+		process.once("exit", cleanup);
+		process.once("beforeExit", cleanup);
+		[
+			"SIGINT",
+			"SIGTERM",
+			"SIGQUIT",
+			"SIGHUP"
+		].forEach((signal) => {
+			process.once(signal, () => {
+				killCloudflared(signal);
+				try {
+					process.kill(process.pid, signal);
+				} catch {
+					process.exit(0);
+				}
+			});
+		});
+		process.once("uncaughtExceptionMonitor", (error) => {
+			console.error("[unplugin-cloudflare-tunnel] Uncaught exception, cleaning up cloudflared...", error);
+			killCloudflared("SIGTERM");
+		});
+	};
+	const configureServer = async (server) => {
+		const generateDnsComment = () => {
+			return `unplugin-cloudflare-tunnel:${tunnelName}`;
+		};
+		const registerListeningHandler = (handler) => {
+			const httpServer = server.httpServer;
+			const invokeHandler = () => {
+				try {
+					const maybePromise = handler();
+					if (maybePromise && typeof maybePromise.then === "function") maybePromise.catch((error) => {
+						console.error(`[unplugin-cloudflare-tunnel] ❌ Dev server listening hook failed: ${error.message}`);
+					});
+				} catch (error) {
+					console.error(`[unplugin-cloudflare-tunnel] ❌ Dev server listening hook failed: ${error.message}`);
+				}
+			};
+			if (!httpServer) {
+				invokeHandler();
+				return;
+			}
+			httpServer.on("listening", invokeHandler);
+			if (httpServer.listening) invokeHandler();
+		};
+		try {
+			const { host: serverHost, port: detectedPort } = normalizeAddress(server.httpServer?.address());
+			const configPortValue = server.config?.server?.port;
+			const resolvedConfigPort = typeof configPortValue === "string" ? Number.parseInt(configPortValue, 10) : configPortValue;
+			const port = userProvidedPort || detectedPort || (typeof resolvedConfigPort === "number" && !Number.isNaN(resolvedConfigPort) ? resolvedConfigPort : void 0) || 5173;
+			const originRequest = server.httpServer ? void 0 : { httpHostHeader: `${serverHost}:${port}` };
+			const newConfigHash = JSON.stringify({
+				isQuickMode,
+				hostname,
+				port,
+				tunnelName,
+				dnsOption,
+				sslOption,
+				originRequest
+			});
+			if (globalState.child && !globalState.child.killed && globalState.configHash === newConfigHash) {
+				tunnelUrl = await globalState.tunnelUrl ?? "";
+				debugLog("[unplugin-cloudflare-tunnel] Config unchanged – re-using existing tunnel");
+				globalState.shuttingDown = false;
+				registerExitHandler();
+				return;
+			}
+			if (globalState.child && !globalState.child.killed) {
+				debugLog("[unplugin-cloudflare-tunnel] Config changed – terminating previous tunnel...");
+				try {
+					globalState.child.kill("SIGTERM");
+				} catch {}
+			}
+			delete globalState.child;
+			delete globalState.configHash;
+			globalState.shuttingDown = false;
+			if (isQuickMode) {
+				debugLog("[unplugin-cloudflare-tunnel] Starting quick tunnel mode...");
+				debugLog("Quick tunnel mode - no API token or hostname required");
+				await ensureCloudflaredBinary(bin);
+				const localTarget = getLocalTarget(serverHost, port);
+				debugLog("← Quick tunnel connecting to local target", localTarget);
+				try {
+					const { child: quickChild, url } = await spawnQuickTunnel(localTarget, protocol);
+					tunnelUrl = url;
+					child = quickChild;
+					globalState.child = child;
+					globalState.configHash = newConfigHash;
+					globalState.tunnelUrl = Promise.resolve(url);
+					registerExitHandler();
+					registerListeningHandler(() => {
+						const { host: actualServerHost, port: actualPort } = normalizeAddress(server.httpServer?.address());
+						const actualLocalTarget = getLocalTarget(actualServerHost, actualPort ?? port);
+						announceTunnel({
+							key: `quick:${url}:${actualPort ?? port}`,
+							url,
+							localTarget: actualLocalTarget
+						});
+					});
+					registerListeningHandler(async () => {
+						try {
+							const { host: actualServerHost, port: actualPort } = normalizeAddress(server.httpServer?.address());
+							if (server.httpServer && actualPort !== void 0 && actualPort !== port) {
+								pluginLog.warn(`Port conflict detected - server is using port ${actualPort} instead of ${port}`);
+								pluginLog.info("Restarting quick tunnel for the new port...");
+								killCloudflared("SIGTERM");
+								await new Promise((resolve) => setTimeout(resolve, 1e3));
+								const newLocalTarget = getLocalTarget(actualServerHost, actualPort ?? port);
+								const { child: newChild, url: newUrl } = await spawnQuickTunnel(newLocalTarget, protocol);
+								tunnelUrl = newUrl;
+								child = newChild;
+								globalState.child = child;
+								globalState.tunnelUrl = Promise.resolve(newUrl);
+								announceTunnel({
+									key: `quick:${newUrl}:${actualPort ?? port}`,
+									url: newUrl,
+									localTarget: newLocalTarget
+								});
+								globalState.configHash = JSON.stringify({
+									isQuickMode,
+									hostname,
+									port: actualPort,
+									tunnelName,
+									dnsOption,
+									sslOption
+								});
+							}
+						} catch (error) {
+							console.error(`[unplugin-cloudflare-tunnel] ❌ Failed to update quick tunnel for port change: ${error.message}`);
+						}
+					});
+					server.httpServer?.once("close", () => {
+						killCloudflared("SIGTERM");
+					});
+					return;
+				} catch (error) {
+					console.error(`[unplugin-cloudflare-tunnel] ❌ Quick tunnel setup failed: ${error.message}`);
+					throw error;
+				}
+			}
+			debugLog("[unplugin-cloudflare-tunnel] Starting named tunnel mode...");
+			const apiToken = providedApiToken || process.env.CLOUDFLARE_API_TOKEN;
+			if (!apiToken) throw new Error("[unplugin-cloudflare-tunnel] API token is required. Provide it via 'apiToken' option or set the CLOUDFLARE_API_TOKEN environment variable. Get your token at: https://dash.cloudflare.com/profile/api-tokens");
+			debugLog(`[unplugin-cloudflare-tunnel] Using port ${port}${userProvidedPort === port ? " (user-provided)" : " (from bundler config)"}`);
+			await ensureCloudflaredBinary(bin);
+			const apexDomain = hostname.split(".").slice(-2).join(".");
+			const parentDomain = hostname.split(".").slice(1).join(".");
+			debugLog("← Apex domain", apexDomain);
+			debugLog("← Parent domain", parentDomain);
+			let resolvedZone;
+			let zoneId = forcedZone;
+			if (!zoneId) {
+				let zones = [];
+				try {
+					zones = await cf(apiToken, "GET", `/zones?name=${parentDomain}`, void 0, /* @__PURE__ */ array(ZoneSchema));
+				} catch (error) {
+					debugLog("← Error fetching zone for parent domain", error);
+				}
+				if (zones.length === 0) zones = await cf(apiToken, "GET", `/zones?name=${apexDomain}`, void 0, /* @__PURE__ */ array(ZoneSchema));
+				resolvedZone = zones[0];
+				zoneId = resolvedZone?.id;
+			}
+			let accountId = forcedAccount || resolvedZone?.account?.id;
+			if (!accountId) accountId = (await cf(apiToken, "GET", "/accounts", void 0, /* @__PURE__ */ array(AccountSchema)))[0]?.id;
+			if (!accountId) throw new Error("Unable to determine Cloudflare account ID");
+			if (!zoneId) throw new Error(`Zone ${apexDomain} not found in account ${accountId}`);
+			const { autoCleanup = true } = cleanupConfig;
+			let [tunnel] = await cf(apiToken, "GET", `/accounts/${accountId}/cfd_tunnel?name=${tunnelName}`, void 0, /* @__PURE__ */ array(TunnelSchema));
+			if (!tunnel) {
+				pluginLog.info(`Creating tunnel '${tunnelName}'...`);
+				tunnel = await cf(apiToken, "POST", `/accounts/${accountId}/cfd_tunnel`, {
+					name: tunnelName,
+					config_src: "cloudflare"
+				}, TunnelSchema);
+			}
+			const tunnelId = tunnel.id;
+			const localTarget = getLocalTarget(serverHost, port);
+			debugLog("← Connecting to local target", localTarget);
+			await cf(apiToken, "PUT", `/accounts/${accountId}/cfd_tunnel/${tunnelId}/configurations`, { config: { ingress: [{
+				hostname,
+				service: localTarget,
+				...originRequest ? { originRequest } : {}
+			}, { service: "http_status:404" }] } });
+			const token = await cf(apiToken, "GET", `/accounts/${accountId}/cfd_tunnel/${tunnelId}/token`, void 0, /* @__PURE__ */ string());
+			const generateSslTagHostname = () => {
+				return `cf-tunnel-plugin-${tunnelName}--${parentDomain}`;
+			};
+			const finalizeNamedTunnelSetup = async () => {
+				if (autoCleanup) {
+					debugLog(`[unplugin-cloudflare-tunnel] Running resource cleanup for tunnel '${tunnelName}'...`);
+					const dnsCleanup = await cleanupMismatchedDnsRecords(apiToken, zoneId, generateDnsComment(), hostname, tunnelId);
+					if (dnsCleanup.found.length > 0) pluginLog.warn(`DNS cleanup: ${dnsCleanup.found.length} mismatched, ${dnsCleanup.deleted.length} deleted`);
+				} else debugLog("← Cleanup skipped", cleanupConfig);
+				if (dnsOption) {
+					const ensureDnsRecord = async (type, content) => {
+						if ((await cf(apiToken, "GET", `/zones/${zoneId}/dns_records?type=${type}&name=${encodeURIComponent(dnsOption)}`, void 0, /* @__PURE__ */ array(DNSRecordSchema))).length === 0) {
+							console.log(`[unplugin-cloudflare-tunnel] Creating ${type} record for ${dnsOption}...`);
+							await cf(apiToken, "POST", `/zones/${zoneId}/dns_records`, {
+								type,
+								name: dnsOption,
+								content,
+								proxied: true,
+								comment: generateDnsComment()
+							}, DNSRecordSchema);
+						}
+					};
+					await ensureDnsRecord("CNAME", `${tunnelId}.cfargotunnel.com`);
+				} else {
+					const wildcardDns = `*.${parentDomain}`;
+					if ((await cf(apiToken, "GET", `/zones/${zoneId}/dns_records?type=CNAME&name=${wildcardDns}`, void 0, /* @__PURE__ */ array(DNSRecordSchema))).length === 0) {
+						const existingRecord = (await cf(apiToken, "GET", `/zones/${zoneId}/dns_records?type=CNAME&name=${hostname}`, void 0, /* @__PURE__ */ array(DNSRecordSchema)))[0];
+						const expectedContent = `${tunnelId}.cfargotunnel.com`;
+						if (!existingRecord) {
+							console.log(`[unplugin-cloudflare-tunnel] Creating DNS record for ${hostname}...`);
+							await cf(apiToken, "POST", `/zones/${zoneId}/dns_records`, {
+								type: "CNAME",
+								name: hostname,
+								content: expectedContent,
+								proxied: true,
+								comment: generateDnsComment()
+							}, DNSRecordSchema);
+						} else if (existingRecord.content !== expectedContent) {
+							debugLog(`← DNS record for ${hostname} points to different tunnel, updating...`);
+							pluginLog.info(`Updating DNS record for ${hostname} to point to tunnel '${tunnelName}'...`);
+							await cf(apiToken, "PUT", `/zones/${zoneId}/dns_records/${existingRecord.id}`, {
+								type: "CNAME",
+								name: hostname,
+								content: expectedContent,
+								proxied: true,
+								comment: generateDnsComment()
+							}, DNSRecordSchema);
+						}
+					}
+				}
+				const certListRaw = await cf(apiToken, "GET", `/zones/${zoneId}/ssl/certificate_packs?status=all`, void 0, /* @__PURE__ */ any());
+				const certPacks = Array.isArray(certListRaw) ? certListRaw : certListRaw.result || [];
+				if (autoCleanup) {
+					const mismatchedSslCerts = certPacks.filter((cert) => {
+						return (cert.hostnames || cert.hosts || []).some((host) => host.startsWith(`cf-tunnel-plugin-${tunnelName}--`));
+					}).filter((cert) => {
+						return !(cert.hostnames || cert.hosts || []).some((host) => {
+							if (host.startsWith("cf-tunnel-plugin-")) return false;
+							return host === hostname || host.startsWith("*.") && hostname.endsWith(host.slice(1));
+						});
+					});
+					if (mismatchedSslCerts.length > 0) {
+						for (const cert of mismatchedSslCerts) await cf(apiToken, "DELETE", `/zones/${zoneId}/ssl/certificate_packs/${cert.id}`);
+						pluginLog.warn(`SSL cleanup: ${mismatchedSslCerts.length} deleted`);
+					}
+				}
+				const certContainingHost = (host) => certPacks.filter((c) => (c.hostnames || c.hosts || []).includes(host))?.[0];
+				if (sslOption) {
+					const isWildcard = sslOption.startsWith("*.");
+					const certNeededHost = sslOption;
+					const matchingCert = certContainingHost(certNeededHost);
+					if (!matchingCert) {
+						console.log(`[unplugin-cloudflare-tunnel] Requesting ${isWildcard ? "wildcard " : ""}certificate for ${certNeededHost}...`);
+						const tagHostname = generateSslTagHostname();
+						const certificateHosts = [certNeededHost, tagHostname];
+						debugLog(`Adding tag hostname to certificate: ${tagHostname}`);
+						const newCert = await retryWithBackoff(() => cf(apiToken, "POST", `/zones/${zoneId}/ssl/certificate_packs/order`, {
+							hosts: certificateHosts,
+							certificate_authority: "lets_encrypt",
+							type: "advanced",
+							validation_method: isWildcard ? "txt" : "http",
+							validity_days: 90,
+							cloudflare_branding: false
+						}));
+						if (newCert?.id) trackSslCertificate(newCert.id, certificateHosts, tunnelName);
+					} else debugLog("← Edge certificate already exists", matchingCert);
+				} else {
+					const wildcardDomain = `*.${parentDomain}`;
+					const wildcardExists = certContainingHost(wildcardDomain);
+					if (!wildcardExists) {
+						const totalTls = await cf(apiToken, "GET", `/zones/${zoneId}/acm/total_tls`, void 0, /* @__PURE__ */ object({ status: /* @__PURE__ */ string() }));
+						debugLog("← Total TLS", totalTls);
+						const existingHostnameCert = certContainingHost(hostname);
+						if (totalTls.status !== "on" && !existingHostnameCert) {
+							pluginLog.info(`Requesting edge certificate for ${hostname}...`);
+							const tagHostname = generateSslTagHostname();
+							const certificateHosts = [hostname, tagHostname];
+							debugLog(`Adding tag hostname to certificate: ${tagHostname}`);
+							const newCert = await retryWithBackoff(() => cf(apiToken, "POST", `/zones/${zoneId}/ssl/certificate_packs/order`, {
+								hosts: certificateHosts,
+								certificate_authority: "lets_encrypt",
+								type: "advanced",
+								validation_method: "txt",
+								validity_days: 90,
+								cloudflare_branding: false
+							}));
+							if (newCert?.id) trackSslCertificate(newCert.id, certificateHosts, tunnelName);
+						} else debugLog("← Edge certificate already exists", existingHostnameCert);
+					} else debugLog("← Edge certificate (wildcard) already exists", wildcardExists, wildcardDomain);
+				}
+			};
+			let tunnelReady = false;
+			let localTargetForAnnouncement = localTarget;
+			let activeTunnelProtocol;
+			const announceNamedTunnelIfReady = () => {
+				if (!tunnelReady) return;
+				announceTunnel({
+					key: `named:${hostname}:${localTargetForAnnouncement}`,
+					url: `https://${hostname}`,
+					localTarget: localTargetForAnnouncement
+				});
+			};
+			const logCloudflaredLines = (kind, text) => {
+				if (globalState.shuttingDown && !debug) return;
+				const isVerbose = effectiveLogLevel === "debug" || effectiveLogLevel === "info";
+				const lines = text.split("\n").map((l) => l.trim()).filter(Boolean);
+				if (isVerbose) {
+					for (const line of lines) {
+						const prefix = kind === "stdout" ? "[cloudflared stdout]" : "[cloudflared stderr]";
+						if (kind === "stdout") console.log(`${prefix} ${line}`);
+						else console.error(`${prefix} ${line}`);
+					}
+					return;
+				}
+				for (const line of lines) {
+					if (INFO_LOG_REGEX.test(line)) continue;
+					const prefix = kind === "stdout" ? "[cloudflared stdout]" : "[cloudflared stderr]";
+					if (kind === "stdout") console.log(`${prefix} ${line}`);
+					else console.error(`${prefix} ${line}`);
+				}
+			};
+			const spawnNamedTunnelProcess = (protocol) => {
+				const cloudflaredArgs = ["tunnel"];
+				cloudflaredArgs.push("--loglevel", cloudflaredProcessLogLevel);
+				if (logFile) cloudflaredArgs.push("--logfile", logFile);
+				cloudflaredArgs.push("--protocol", protocol);
+				debugLog("Spawning cloudflared", bin, cloudflaredArgs);
+				const spawnedChild = NodeChildProcess.spawn(bin, [
+					...cloudflaredArgs,
+					"run",
+					"--token",
+					token
+				], {
+					stdio: [
+						"ignore",
+						"pipe",
+						"pipe"
+					],
+					detached: false,
+					windowsHide: true,
+					shell: process.platform === "win32"
+				});
+				child = spawnedChild;
+				globalState.child = spawnedChild;
+				globalState.configHash = newConfigHash;
+				debugLog(`[unplugin-cloudflare-tunnel] Process spawned with PID: ${spawnedChild.pid}`);
+				const handleCloudflaredOutput = (kind, text) => {
+					if (text.includes("Failed to parse ICMP reply") || text.includes("unknow ip version 0")) {
+						if (logLevel === "debug") console.log(`[cloudflared debug] ${text.trim()}`);
+						return;
+					}
+					logCloudflaredLines(kind, text);
+					if (/registered tunnel connection|connection.*registered/i.test(text)) {
+						activeTunnelProtocol = protocol;
+						if (!tunnelReady) {
+							tunnelReady = true;
+							pluginLog.info(`Tunnel connected for https://${hostname} via ${protocol.toUpperCase()}`);
+						}
+						announceNamedTunnelIfReady();
+					}
+				};
+				spawnedChild.stdout?.on("data", (data) => {
+					handleCloudflaredOutput("stdout", data.toString());
+				});
+				spawnedChild.stderr?.on("data", (data) => {
+					handleCloudflaredOutput("stderr", data.toString());
+				});
+				spawnedChild.on("error", (error) => {
+					console.error(`[unplugin-cloudflare-tunnel] ❌ Failed to start tunnel process: ${error.message}`);
+					if (error.message.includes("ENOENT")) console.error(`[unplugin-cloudflare-tunnel] Hint: cloudflared binary may not be installed correctly`);
+				});
+				spawnedChild.on("exit", (code, signal) => {
+					if (globalState.child !== spawnedChild) return;
+					if (code !== 0 && code !== null) {
+						console.error(`[unplugin-cloudflare-tunnel] ❌ Tunnel process exited with code ${code}`);
+						if (signal) console.error(`[unplugin-cloudflare-tunnel] Process terminated by signal: ${signal}`);
+					} else if (code === 0) console.log(`[unplugin-cloudflare-tunnel] ✅ Tunnel process exited cleanly`);
+				});
+			};
+			spawnNamedTunnelProcess(protocol);
+			registerExitHandler();
+			finalizeNamedTunnelSetup().catch((error) => {
+				console.error(`[unplugin-cloudflare-tunnel] ❌ Post-start setup failed: ${error.message}`);
+			});
+			registerListeningHandler(() => {
+				const { host: actualServerHost, port: actualPort } = normalizeAddress(server.httpServer?.address());
+				localTargetForAnnouncement = getLocalTarget(actualServerHost, actualPort ?? port);
+				announceNamedTunnelIfReady();
+			});
+			server.httpServer?.once("close", () => {
+				killCloudflared("SIGTERM");
+			});
+			registerListeningHandler(async () => {
+				try {
+					const { host: actualServerHost, port: actualPort } = normalizeAddress(server.httpServer?.address());
+					if (server.httpServer && actualPort !== void 0 && actualPort !== port) {
+						pluginLog.warn(`Port conflict detected - server is using port ${actualPort} instead of ${port}`);
+						pluginLog.info("Updating tunnel configuration...");
+						const newLocalTarget = getLocalTarget(actualServerHost, actualPort ?? port);
+						localTargetForAnnouncement = newLocalTarget;
+						debugLog("← Updating local target to", newLocalTarget);
+						await cf(apiToken, "PUT", `/accounts/${accountId}/cfd_tunnel/${tunnelId}/configurations`, { config: { ingress: [{
+							hostname,
+							service: newLocalTarget,
+							...originRequest ? { originRequest: { httpHostHeader: `${actualServerHost}:${actualPort ?? port}` } } : {}
+						}, { service: "http_status:404" }] } });
+						pluginLog.info(`Tunnel configuration updated to use port ${actualPort}`);
+						globalState.configHash = JSON.stringify({
+							hostname,
+							port: actualPort,
+							tunnelName,
+							dnsOption,
+							sslOption,
+							originRequest: server.httpServer ? void 0 : { httpHostHeader: `${actualServerHost}:${actualPort ?? port}` }
+						});
+						if (tunnelReady && activeTunnelProtocol) pluginLog.info(`Tunnel remains connected via ${activeTunnelProtocol.toUpperCase()} after port update`);
+						announceNamedTunnelIfReady();
+					}
+				} catch (error) {
+					console.error(`[unplugin-cloudflare-tunnel] ❌ Failed to update tunnel for port change: ${error.message}`);
+				}
+			});
+		} catch (error) {
+			if (error instanceof Error) {
+				console.error(`[unplugin-cloudflare-tunnel] ❌ Setup failed: ${error.message}`);
+				if (error.message.includes("API token")) {
+					console.error(`[unplugin-cloudflare-tunnel] 💡 Check your API token at: https://dash.cloudflare.com/profile/api-tokens`);
+					console.error(`[unplugin-cloudflare-tunnel] 💡 Required permissions: Zone:Zone:Read, Zone:DNS:Edit, Account:Cloudflare Tunnel:Edit`);
+				} else if (error.message.includes("Zone") && error.message.includes("not found")) console.error(`[unplugin-cloudflare-tunnel] 💡 Make sure '${hostname}' domain is added to your Cloudflare account`);
+				else if (error.message.includes("cloudflared")) console.error(`[unplugin-cloudflare-tunnel] 💡 Try deleting node_modules and reinstalling to get a fresh cloudflared binary`);
+			}
+			throw error;
+		}
+	};
+	const ensureWebpackAllowedHosts = (devServerOptions, bundler) => {
+		if (!devServerOptions) return;
+		const hostToAllow = isQuickMode ? ".trycloudflare.com" : hostname;
+		if (!hostToAllow) return;
+		const label = bundler === "webpack" ? "Webpack" : "Rspack";
+		const normalizeArray = (values) => {
+			const unique = Array.from(new Set(values.filter(Boolean)));
+			devServerOptions.allowedHosts = unique;
+			return unique;
+		};
+		let modified = false;
+		const current = devServerOptions.allowedHosts;
+		if (current === "all") return;
+		if (typeof current === "undefined" || current === "auto") {
+			normalizeArray(["localhost", hostToAllow]);
+			modified = true;
+		} else if (typeof current === "string") {
+			if (current !== hostToAllow) {
+				normalizeArray([current, hostToAllow]);
+				modified = true;
+			}
+		} else if (Array.isArray(current)) {
+			if (!current.includes(hostToAllow)) {
+				current.push(hostToAllow);
+				modified = true;
+			}
+		}
+		if (modified) debugLog(`[unplugin-cloudflare-tunnel] Configured ${label} devServer.allowedHosts to include ${hostToAllow}`);
+	};
+	const ensureViteAllowedHosts = (serverConfig) => {
+		const hostToAllow = isQuickMode ? ".trycloudflare.com" : hostname;
+		if (!hostToAllow) return;
+		const current = serverConfig.allowedHosts;
+		if (current === true) return;
+		if (typeof current === "undefined") serverConfig.allowedHosts = [hostToAllow];
+		else if (typeof current === "string") {
+			if (current !== hostToAllow) serverConfig.allowedHosts = [current, hostToAllow];
+		} else if (Array.isArray(current)) {
+			if (!current.includes(hostToAllow)) current.push(hostToAllow);
+		}
+	};
+	const setupWebpackVirtualScheme = (compiler) => {
+		const plugins = compiler.options.plugins ??= [];
+		if (plugins.some((plugin) => plugin?.__unpluginCloudflareTunnelVirtualSchemePlugin)) return;
+		const context = typeof compiler.options.context === "string" && compiler.options.context.length > 0 ? compiler.options.context : process.cwd();
+		let VirtualUrlPlugin;
+		try {
+			VirtualUrlPlugin = NodeModule.createRequire(`${context}/package.json`)("webpack/lib/schemes/VirtualUrlPlugin");
+		} catch {
+			return;
+		}
+		const virtualSchemePlugin = new VirtualUrlPlugin({ "unplugin-cloudflare-tunnel": {
+			type: ".js",
+			async source() {
+				const url = await globalState.tunnelUrl;
+				return `export function getTunnelUrl() { return ${JSON.stringify(url || "")}; }`;
+			}
+		} }, "virtual");
+		virtualSchemePlugin.__unpluginCloudflareTunnelVirtualSchemePlugin = true;
+		plugins.unshift(virtualSchemePlugin);
+		virtualSchemePlugin.apply(compiler);
+	};
+	const setupWebpackLikeDevServerIntegration = (compiler, bundler) => {
+		if ((compiler?.options?.mode ?? process.env.NODE_ENV) === "production") return;
+		const optionsContainer = compiler.options;
+		if (!optionsContainer.devServer) optionsContainer.devServer = {};
+		const devServerOptions = optionsContainer.devServer;
+		ensureWebpackAllowedHosts(devServerOptions, bundler);
+		let lastHttpServer;
+		let missingServerWarned = false;
+		const runConfiguration = (devServerInstance) => {
+			if (!devServerInstance) {
+				if (!missingServerWarned) {
+					console.warn(`[unplugin-cloudflare-tunnel] ${bundler} dev server instance unavailable; skipping tunnel setup`);
+					missingServerWarned = true;
+				}
+				return;
+			}
+			const httpServer = [
+				devServerInstance.server,
+				devServerInstance.httpServer,
+				devServerInstance.listeningApp,
+				devServerInstance.server?.server
+			].find((candidate) => candidate);
+			if (!httpServer) {
+				if (!missingServerWarned) {
+					console.warn(`[unplugin-cloudflare-tunnel] Unable to locate HTTP server from ${bundler} dev server; tunnel will not start`);
+					missingServerWarned = true;
+				}
+				return;
+			}
+			if (lastHttpServer === httpServer) return;
+			lastHttpServer = httpServer;
+			httpServer.once("close", () => {
+				if (lastHttpServer === httpServer) lastHttpServer = void 0;
+			});
+			const configuredPromise = configureServer({
+				httpServer,
+				config: { server: { port: devServerInstance.options?.port ?? devServerOptions?.port } }
+			});
+			globalState.tunnelUrl = configuredPromise.then(() => tunnelUrl).catch(() => "");
+			configuredPromise.catch(() => {});
+		};
+		const scheduleConfiguration = (devServerInstance) => {
+			const httpServer = devServerInstance?.server || devServerInstance?.httpServer || devServerInstance?.listeningApp;
+			if (httpServer && typeof httpServer.once === "function") if (httpServer.listening) runConfiguration(devServerInstance);
+			else httpServer.once("listening", () => runConfiguration(devServerInstance));
+			else runConfiguration(devServerInstance);
+		};
+		const originalSetupMiddlewares = devServerOptions.setupMiddlewares;
+		devServerOptions.setupMiddlewares = function(middlewares, devServer) {
+			scheduleConfiguration(devServer);
+			if (typeof originalSetupMiddlewares === "function") return originalSetupMiddlewares.call(this, middlewares, devServer);
+			return middlewares;
+		};
+		const originalOnListening = devServerOptions.onListening;
+		devServerOptions.onListening = function(devServer) {
+			scheduleConfiguration(devServer);
+			if (typeof originalOnListening === "function") return originalOnListening.call(this, devServer);
+		};
+	};
+	return {
+		name: PLUGIN_NAME,
+		enforce: "pre",
+		resolveId(id) {
+			if (id === VIRTUAL_MODULE_ID) {
+				debugLog("resolveId called for", id);
+				return id;
+			}
+		},
+		loadInclude(id) {
+			return id === VIRTUAL_MODULE_ID;
+		},
+		async load(id) {
+			if (id === VIRTUAL_MODULE_ID) {
+				const url = await globalState.tunnelUrl;
+				return `export function getTunnelUrl() { return ${JSON.stringify(url || "")}; }`;
+			}
+		},
+		vite: {
+			config: (config) => {
+				announceConnecting();
+				if (!config.server) config.server = {};
+				ensureViteAllowedHosts(config.server);
+				if (!isQuickMode) debugLog(`[unplugin-cloudflare-tunnel] Configured Vite to allow requests from ${hostname}`);
+			},
+			configureServer: (server) => {
+				const configuredPromise = configureServer(server);
+				globalState.tunnelUrl = configuredPromise.then(() => tunnelUrl).catch(() => "");
+				return async () => {
+					await configuredPromise;
+				};
+			}
+		},
+		esbuild: { config() {
+			announceConnecting();
+			if (typeof userProvidedPort === "number" && !Number.isNaN(userProvidedPort)) globalState.tunnelUrl = configureServer({ config: { server: { port: userProvidedPort } } }).then(() => tunnelUrl).catch(() => "");
+			else {
+				globalState.tunnelUrl = Promise.resolve("");
+				console.warn("[unplugin-cloudflare-tunnel] esbuild requires the plugin `port` option to enable tunnel startup");
+			}
+			if (!isQuickMode) debugLog(`[unplugin-cloudflare-tunnel] Configured esbuild tunnel target for ${hostname}`);
+		} },
+		rspack: (compiler) => {
+			setupWebpackLikeDevServerIntegration(compiler, "rspack");
+		},
+		webpack: (compiler) => {
+			setupWebpackVirtualScheme(compiler);
+			setupWebpackLikeDevServerIntegration(compiler, "webpack");
+		},
+		buildStart() {
+			if (!this?.meta?.watchMode) return;
+			if (typeof userProvidedPort !== "number" || Number.isNaN(userProvidedPort)) return;
+			if (globalState.tunnelUrl) return;
+			announceConnecting();
+			globalState.tunnelUrl = configureServer({ config: { server: { port: userProvidedPort } } }).then(() => tunnelUrl).catch(() => "");
+		},
+		closeBundle() {
+			if (this?.meta?.watchMode) return;
+			killCloudflared("SIGTERM");
+			delete globalState.child;
+			delete globalState.configHash;
+			delete globalState.shuttingDown;
+		}
+	};
+};
+const CloudflareTunnel = createUnplugin(unpluginFactory);
+//#endregion
+export { CloudflareTunnel as t };