limina 0.0.5 → 0.1.1

package/chunks/dep-C5gcXDHp.js

@@ -0,0 +1,4125 @@
+import { createRequire } from "node:module";
+import { existsSync, statSync } from "node:fs";
+import ts from "typescript";
+import { pathToFileURL } from "node:url";
+
+//#region src/utils/collections.ts
+function uniqueValues(values) {
+	return [...new Set(values)];
+}
+function uniqueBy(values, getKey) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const value of values) {
+		const key = getKey(value);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		result.push(value);
+	}
+	return result;
+}
+function uniqueSortedStrings(values) {
+	return uniqueValues(values).sort((left, right) => left.localeCompare(right));
+}
+function uniqueTrimmedNonEmptySortedStrings(values) {
+	return uniqueSortedStrings([...values].map((value) => value?.trim()).filter((value) => Boolean(value)));
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
+let _lazyMatch = () => {
+	var __lib__ = (() => {
+		var m = Object.defineProperty, V = Object.getOwnPropertyDescriptor, G = Object.getOwnPropertyNames, T = Object.prototype.hasOwnProperty, q = (r, e) => {
+			for (var n in e) m(r, n, {
+				get: e[n],
+				enumerable: true
+			});
+		}, H = (r, e, n, a) => {
+			if (e && typeof e == "object" || typeof e == "function") for (let t of G(e)) !T.call(r, t) && t !== n && m(r, t, {
+				get: () => e[t],
+				enumerable: !(a = V(e, t)) || a.enumerable
+			});
+			return r;
+		}, J = (r) => H(m({}, "__esModule", { value: true }), r), w = {};
+		q(w, { default: () => re });
+		var A = (r) => Array.isArray(r), d = (r) => typeof r == "function", Q = (r) => r.length === 0, W = (r) => typeof r == "number", K = (r) => typeof r == "object" && r !== null, X = (r) => r instanceof RegExp, b = (r) => typeof r == "string", h = (r) => r === void 0, Y = (r) => {
+			const e = /* @__PURE__ */ new Map();
+			return (n) => {
+				const a = e.get(n);
+				if (a) return a;
+				const t = r(n);
+				return e.set(n, t), t;
+			};
+		}, rr = (r, e, n = {}) => {
+			const a = {
+				cache: {},
+				input: r,
+				index: 0,
+				indexMax: 0,
+				options: n,
+				output: []
+			};
+			if (v(e)(a) && a.index === r.length) return a.output;
+			throw new Error(`Failed to parse at index ${a.indexMax}`);
+		}, i = (r, e) => A(r) ? er(r, e) : b(r) ? ar(r, e) : nr(r, e), er = (r, e) => {
+			const n = {};
+			for (const a of r) {
+				if (a.length !== 1) throw new Error(`Invalid character: "${a}"`);
+				const t = a.charCodeAt(0);
+				n[t] = true;
+			}
+			return (a) => {
+				const t = a.index, o = a.input;
+				for (; a.index < o.length && o.charCodeAt(a.index) in n;) a.index += 1;
+				const u = a.index;
+				if (u > t) {
+					if (!h(e) && !a.options.silent) {
+						const s = a.input.slice(t, u), c = d(e) ? e(s, o, String(t)) : e;
+						h(c) || a.output.push(c);
+					}
+					a.indexMax = Math.max(a.indexMax, a.index);
+				}
+				return true;
+			};
+		}, nr = (r, e) => {
+			const n = r.source, a = r.flags.replace(/y|$/, "y"), t = new RegExp(n, a);
+			return g((o) => {
+				t.lastIndex = o.index;
+				const u = t.exec(o.input);
+				if (u) {
+					if (!h(e) && !o.options.silent) {
+						const s = d(e) ? e(...u, o.input, String(o.index)) : e;
+						h(s) || o.output.push(s);
+					}
+					return o.index += u[0].length, o.indexMax = Math.max(o.indexMax, o.index), true;
+				} else return false;
+			});
+		}, ar = (r, e) => (n) => {
+			if (n.input.startsWith(r, n.index)) {
+				if (!h(e) && !n.options.silent) {
+					const t = d(e) ? e(r, n.input, String(n.index)) : e;
+					h(t) || n.output.push(t);
+				}
+				return n.index += r.length, n.indexMax = Math.max(n.indexMax, n.index), true;
+			} else return false;
+		}, C = (r, e, n, a) => {
+			const t = v(r);
+			return g(_(M((o) => {
+				let u = 0;
+				for (; u < n;) {
+					const s = o.index;
+					if (!t(o) || (u += 1, o.index === s)) break;
+				}
+				return u >= e;
+			})));
+		}, tr = (r, e) => C(r, 0, 1), f = (r, e) => C(r, 0, Infinity), x = (r, e) => {
+			const n = r.map(v);
+			return g(_(M((a) => {
+				for (let t = 0, o = n.length; t < o; t++) if (!n[t](a)) return false;
+				return true;
+			})));
+		}, l = (r, e) => {
+			const n = r.map(v);
+			return g(_((a) => {
+				for (let t = 0, o = n.length; t < o; t++) if (n[t](a)) return true;
+				return false;
+			}));
+		}, M = (r, e = false) => {
+			const n = v(r);
+			return (a) => {
+				const t = a.index, o = a.output.length, u = n(a);
+				return (!u || e) && (a.index = t, a.output.length !== o && (a.output.length = o)), u;
+			};
+		}, _ = (r, e) => {
+			return v(r);
+		}, g = (() => {
+			let r = 0;
+			return (e) => {
+				const n = v(e), a = r += 1;
+				return (t) => {
+					var o;
+					if (t.options.memoization === false) return n(t);
+					const u = t.index, s = (o = t.cache)[a] || (o[a] = /* @__PURE__ */ new Map()), c = s.get(u);
+					if (c === false) return false;
+					if (W(c)) return t.index = c, true;
+					if (c) return t.index = c.index, c.output?.length && t.output.push(...c.output), true;
+					{
+						const Z = t.output.length;
+						if (n(t)) {
+							const D = t.index, U = t.output.length;
+							if (U > Z) {
+								const ee = t.output.slice(Z, U);
+								s.set(u, {
+									index: D,
+									output: ee
+								});
+							} else s.set(u, D);
+							return true;
+						} else return s.set(u, false), false;
+					}
+				};
+			};
+		})(), E = (r) => {
+			let e;
+			return (n) => (e || (e = v(r())), e(n));
+		}, v = Y((r) => {
+			if (d(r)) return Q(r) ? E(r) : r;
+			if (b(r) || X(r)) return i(r);
+			if (A(r)) return x(r);
+			if (K(r)) return l(Object.values(r));
+			throw new Error("Invalid rule");
+		}), P = "abcdefghijklmnopqrstuvwxyz", ir = (r) => {
+			let e = "";
+			for (; r > 0;) e = P[(r - 1) % 26] + e, r = Math.floor((r - 1) / 26);
+			return e;
+		}, O = (r) => {
+			let e = 0;
+			for (let n = 0, a = r.length; n < a; n++) e = e * 26 + P.indexOf(r[n]) + 1;
+			return e;
+		}, S = (r, e) => {
+			if (e < r) return S(e, r);
+			const n = [];
+			for (; r <= e;) n.push(r++);
+			return n;
+		}, or = (r, e, n) => S(r, e).map((a) => String(a).padStart(n, "0")), R = (r, e) => S(O(r), O(e)).map(ir), p = (r) => r, z = (r) => ur((e) => rr(e, r, { memoization: false }).join("")), ur = (r) => {
+			const e = {};
+			return (n) => e[n] ?? (e[n] = r(n));
+		}, sr = i(/^\*\*\/\*$/, ".*"), cr = i(/^\*\*\/(\*)?([ a-zA-Z0-9._-]+)$/, (r, e, n) => `.*${e ? "" : "(?:^|/)"}${n.replaceAll(".", "\\.")}`), lr = i(/^\*\*\/(\*)?([ a-zA-Z0-9._-]*)\{([ a-zA-Z0-9._-]+(?:,[ a-zA-Z0-9._-]+)*)\}$/, (r, e, n, a) => `.*${e ? "" : "(?:^|/)"}${n.replaceAll(".", "\\.")}(?:${a.replaceAll(",", "|").replaceAll(".", "\\.")})`), y = i(/\\./, p), pr = i(/[$.*+?^(){}[\]\|]/, (r) => `\\${r}`), vr = i(/./, p), fr = l([i(/^(?:!!)*!(.*)$/, (r, e) => `(?!^${L(e)}$).*?`), i(/^(!!)+/, "")]), j = l([
+			i(/\/(\*\*\/)+/, "(?:/.+/|/)"),
+			i(/^(\*\*\/)+/, "(?:^|.*/)"),
+			i(/\/(\*\*)$/, "(?:/.*|$)"),
+			i(/\*\*/, ".*")
+		]), N = l([i(/\*\/(?!\*\*\/)/, "[^/]*/"), i(/\*/, "[^/]*")]), k = i("?", "[^/]"), $r = i("[", p), wr = i("]", p), Ar = i(/[!^]/, "^/"), br = i(/[a-z]-[a-z]|[0-9]-[0-9]/i, p), Er = l([
+			y,
+			i(/[$.*+?^(){}[\|]/, (r) => `\\${r}`),
+			br,
+			i(/[^\]]/, p)
+		]), B = x([
+			$r,
+			tr(Ar),
+			f(Er),
+			wr
+		]), Pr = i("{", "(?:"), Or = i("}", ")"), I = x([
+			Pr,
+			l([
+				i(/(\d+)\.\.(\d+)/, (r, e, n) => or(+e, +n, Math.min(e.length, n.length)).join("|")),
+				i(/([a-z]+)\.\.([a-z]+)/, (r, e, n) => R(e, n).join("|")),
+				i(/([A-Z]+)\.\.([A-Z]+)/, (r, e, n) => R(e.toLowerCase(), n.toLowerCase()).join("|").toUpperCase())
+			]),
+			Or
+		]), kr = i("{", "(?:"), Br = i("}", ")"), Ir = i(",", "|"), Fr = i(/[$.*+?^(){[\]\|]/, (r) => `\\${r}`), Lr = i(/[^}]/, p), F = x([
+			kr,
+			f(l([
+				j,
+				N,
+				k,
+				B,
+				I,
+				E(() => F),
+				y,
+				Fr,
+				Ir,
+				Lr
+			])),
+			Br
+		]), L = z(f(l([
+			sr,
+			cr,
+			lr,
+			fr,
+			j,
+			N,
+			k,
+			B,
+			I,
+			F,
+			y,
+			pr,
+			vr
+		]))), Tr = i(/\\./, p), qr = i(/./, p), Yr = z(f(l([
+			Tr,
+			i(/\*\*\*+/, "*"),
+			i(/([^/{[(!])\*\*/, (r, e) => `${e}*`),
+			i(/(^|.)\*\*(?=[^*/)\]}])/, (r, e) => `${e}*`),
+			qr
+		]))), $ = (r, e) => {
+			const n = Array.isArray(r) ? r : [r];
+			if (!n.length) return false;
+			const a = n.map($.compile), t = n.every((s) => /(\/(?:\*\*)?|\[\/\])$/.test(s)), o = e.replace(/[\\\/]+/g, "/").replace(/\/$/, t ? "/" : "");
+			return a.some((s) => s.test(o));
+		};
+		$.compile = (r) => new RegExp(`^${L(Yr(r))}$`, "s");
+		var re = $;
+		return J(w);
+	})();
+	return __lib__.default || __lib__;
+};
+let _match;
+const zeptomatch = (path, pattern) => {
+	if (!_match) {
+		_match = _lazyMatch();
+		_lazyMatch = null;
+	}
+	return _match(path, pattern);
+};
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+const _PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
+const sep = "/";
+const normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...segments) {
+	let path = "";
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			if (pathTrailing && segLeading) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return normalize(path);
+};
+function cwd() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
+	return "/";
+}
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd();
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+const toNamespacedPath = function(p) {
+	return normalizeWindowsPath(p);
+};
+const extname = function(p) {
+	if (p === "..") return "";
+	const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+	return match && match[1] || "";
+};
+const relative = function(from, to) {
+	const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) return _to.join("/");
+	const _fromCopy = [..._from];
+	for (const segment of _fromCopy) {
+		if (_to[0] !== segment) break;
+		_from.shift();
+		_to.shift();
+	}
+	return [..._from.map(() => ".."), ..._to].join("/");
+};
+const dirname = function(p) {
+	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
+	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+const format = function(p) {
+	const ext = p.ext ? p.ext.startsWith(".") ? p.ext : `.${p.ext}` : "";
+	const segments = [
+		p.root,
+		p.dir,
+		p.base ?? (p.name ?? "") + ext
+	].filter(Boolean);
+	return normalizeWindowsPath(p.root ? resolve(...segments) : segments.join("/"));
+};
+const basename = function(p, extension) {
+	const segments = normalizeWindowsPath(p).split("/");
+	let lastSegment = "";
+	for (let i = segments.length - 1; i >= 0; i--) {
+		const val = segments[i];
+		if (val) {
+			lastSegment = val;
+			break;
+		}
+	}
+	return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+};
+const parse$2 = function(p) {
+	const root = _PATH_ROOT_RE.exec(p)?.[0]?.replace(/\\/g, "/") || "";
+	const base = basename(p);
+	const extension = extname(base);
+	return {
+		root,
+		dir: dirname(p),
+		base,
+		ext: extension,
+		name: base.slice(0, base.length - extension.length)
+	};
+};
+const matchesGlob = (path, pattern) => {
+	return zeptomatch(pattern, normalize(path));
+};
+const _path = {
+	__proto__: null,
+	basename,
+	dirname,
+	extname,
+	format,
+	isAbsolute,
+	join,
+	matchesGlob,
+	normalize,
+	normalizeString,
+	parse: parse$2,
+	relative,
+	resolve,
+	sep,
+	toNamespacedPath
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/index.mjs
+const delimiter = globalThis.process?.platform === "win32" ? ";" : ":";
+const _platforms = {
+	posix: void 0,
+	win32: void 0
+};
+const mix = (del = delimiter) => {
+	return new Proxy(_path, { get(_, prop) {
+		if (prop === "delimiter") return del;
+		if (prop === "posix") return posix;
+		if (prop === "win32") return win32;
+		return _platforms[prop] || _path[prop];
+	} });
+};
+const posix = /* @__PURE__ */ mix(":");
+const win32 = /* @__PURE__ */ mix(";");
+
+//#endregion
+//#region src/utils/module-specifier.ts
+function isRelativeSpecifier(specifier) {
+	return specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
+}
+function isUrlOrDataOrFileSpecifier(specifier) {
+	return specifier.startsWith("data:") || specifier.startsWith("file:") || specifier.startsWith("http:") || specifier.startsWith("https:");
+}
+function isVirtualModuleSpecifier(specifier) {
+	return specifier.startsWith("virtual:");
+}
+function isPackageImportSpecifier(specifier) {
+	return specifier.startsWith("#");
+}
+function isBarePackageSpecifier(specifier) {
+	return !isRelativeSpecifier(specifier) && !isPackageImportSpecifier(specifier) && !isUrlOrDataOrFileSpecifier(specifier) && !isVirtualModuleSpecifier(specifier) && !posix.isAbsolute(specifier);
+}
+
+//#endregion
+//#region src/utils/path.ts
+function toPosixPath(value) {
+	return normalizeSlashes(value);
+}
+function normalizeAbsolutePath(value) {
+	return resolve(value);
+}
+function toRelativePath(rootDir, absolutePath) {
+	const relativePath = relative(rootDir, resolve(absolutePath));
+	return relativePath.length === 0 ? "." : relativePath;
+}
+function normalizeSlashes(value) {
+	return value.replaceAll("\\", "/");
+}
+function isPathInsideDirectory(filePath, directoryPath) {
+	const normalizedFilePath = normalizeAbsolutePath(filePath);
+	const normalizedDirectoryPath = normalizeAbsolutePath(directoryPath);
+	return normalizedFilePath === normalizedDirectoryPath || normalizedFilePath.startsWith(`${normalizedDirectoryPath}/`);
+}
+
+//#endregion
+//#region src/utils/module-resolution.ts
+function pathHasExtension(value) {
+	return posix.extname(value).length > 0;
+}
+function candidatePathsForBasePath(basePath, extensions) {
+	if (pathHasExtension(basePath)) return [basePath];
+	return extensions.flatMap((extension) => [`${basePath}${extension}`, posix.join(basePath, `index${extension}`)]);
+}
+function resolveExistingFilePath(candidatePath) {
+	if (!existsSync(candidatePath)) return null;
+	if (!statSync(candidatePath).isFile()) return null;
+	return normalizeAbsolutePath(candidatePath);
+}
+function matchPathPattern(pattern, specifier) {
+	const wildcardIndex = pattern.indexOf("*");
+	if (wildcardIndex === -1) return pattern === specifier ? "" : null;
+	const prefix = pattern.slice(0, wildcardIndex);
+	const suffix = pattern.slice(wildcardIndex + 1);
+	if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix)) return null;
+	return specifier.slice(prefix.length, specifier.length - suffix.length);
+}
+function resolveRelativeModuleCandidate(options) {
+	if (!isRelativeSpecifier(options.specifier)) return null;
+	const resolvedSpecifierPath = posix.resolve(posix.dirname(options.containingFile), options.specifier);
+	for (const candidatePath of candidatePathsForBasePath(resolvedSpecifierPath, options.extensions)) {
+		const resolvedPath = resolveExistingFilePath(candidatePath);
+		if (resolvedPath) return resolvedPath;
+	}
+	return null;
+}
+function resolvePathMappedModuleCandidate(options) {
+	const paths = options.compilerOptions.paths;
+	const pathsBasePath = getPathsBasePath(options.compilerOptions);
+	if (!paths || !pathsBasePath) return null;
+	const pathEntries = Object.entries(paths).sort(([left], [right]) => {
+		const leftPrefixLength = left.split("*")[0]?.length ?? left.length;
+		return (right.split("*")[0]?.length ?? right.length) - leftPrefixLength;
+	});
+	for (const [alias, targets] of pathEntries) {
+		const matchedText = matchPathPattern(alias, options.specifier);
+		if (matchedText === null) continue;
+		for (const target of targets) {
+			const resolvedTargetPath = posix.resolve(pathsBasePath, applyPathPattern(target, matchedText));
+			for (const candidatePath of candidatePathsForBasePath(resolvedTargetPath, options.extensions)) {
+				const resolvedPath = resolveExistingFilePath(candidatePath);
+				if (resolvedPath) return resolvedPath;
+			}
+		}
+	}
+	return null;
+}
+function resolveBaseUrlModuleCandidate(options) {
+	if (isRelativeSpecifier(options.specifier) || !options.compilerOptions.baseUrl) return null;
+	const baseUrlPath = posix.resolve(options.compilerOptions.baseUrl, options.specifier);
+	for (const candidatePath of candidatePathsForBasePath(baseUrlPath, options.extensions)) {
+		const resolvedPath = resolveExistingFilePath(candidatePath);
+		if (resolvedPath) return resolvedPath;
+	}
+	return null;
+}
+function applyPathPattern(pattern, matchedText) {
+	return pattern.includes("*") ? pattern.replace("*", matchedText) : pattern;
+}
+function getPathsBasePath(compilerOptions) {
+	const pathsBasePath = compilerOptions.pathsBasePath;
+	if (typeof pathsBasePath === "string") return pathsBasePath;
+	return compilerOptions.baseUrl ?? null;
+}
+
+//#endregion
+//#region src/checkers.ts
+function getTypeScriptExtensionApi() {
+	const api = ts;
+	if (typeof api.getSupportedExtensions !== "function" || typeof api.getSupportedExtensionsWithJsonIfResolveJsonModule !== "function") throw new TypeError("Unable to resolve TypeScript checker extensions: the TypeScript compiler API does not expose supported extension metadata.");
+	return api;
+}
+function flattenTypeScriptExtensionGroups(groups) {
+	return groups.flatMap((group) => [...group]);
+}
+function getTypeScriptCheckerExtensions() {
+	const api = getTypeScriptExtensionApi();
+	const options = { resolveJsonModule: true };
+	return normalizeExtensions(flattenTypeScriptExtensionGroups(api.getSupportedExtensionsWithJsonIfResolveJsonModule(options, api.getSupportedExtensions(options))));
+}
+function getNativeTypeScriptProjectExtensions() {
+	const api = getTypeScriptExtensionApi();
+	const options = {
+		allowJs: true,
+		resolveJsonModule: true
+	};
+	return normalizeExtensions(flattenTypeScriptExtensionGroups(api.getSupportedExtensionsWithJsonIfResolveJsonModule(options, api.getSupportedExtensions(options))));
+}
+function getBuildCheckerSupportedExtensions(preset) {
+	const adapter = getCheckerAdapter(preset);
+	if (!adapter || adapter.execution !== "build") return [];
+	const nativeExtensions = getNativeTypeScriptProjectExtensions();
+	return preset === "vue-tsc" ? normalizeExtensions([...nativeExtensions, ".vue"]) : nativeExtensions;
+}
+function getSvelteCheckerExtensions() {
+	return normalizeExtensions([...getTypeScriptCheckerExtensions(), ".svelte"]);
+}
+const parsedProjectConfigCache = /* @__PURE__ */ new Map();
+function createFormatHost(rootDir) {
+	return {
+		getCanonicalFileName: (fileName) => fileName,
+		getCurrentDirectory: () => rootDir,
+		getNewLine: () => "\n"
+	};
+}
+function readTypeScriptProjectConfig(options) {
+	const diagnostics = [];
+	const parsed = ts.getParsedCommandLineOfConfigFile(options.configPath, {}, {
+		...ts.sys,
+		onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+			diagnostics.push(diagnostic);
+		}
+	});
+	if (!parsed) throw new Error(ts.formatDiagnosticsWithColorAndContext(diagnostics, createFormatHost(options.projectRootDir)));
+	return {
+		diagnostics,
+		parsed
+	};
+}
+function createParsedCheckerProjectConfig(options) {
+	return {
+		extensions: normalizeExtensions(options.extensions),
+		fileNames: options.fileNames.map(normalizeAbsolutePath).sort(),
+		options: options.parsed.options
+	};
+}
+function cloneParsedCheckerProjectConfig(parsedConfig) {
+	return {
+		extensions: [...parsedConfig.extensions],
+		fileNames: [...parsedConfig.fileNames],
+		options: { ...parsedConfig.options }
+	};
+}
+function resolveContextCheckerPresets(context) {
+	return context.checkerPresets.length > 0 ? uniqueSortedStrings(context.checkerPresets) : ["tsc"];
+}
+function createParsedProjectConfigCacheKey(options) {
+	const configStat = statSync(options.configPath);
+	return JSON.stringify({
+		checkerPresets: options.checkerPresets,
+		configPath: normalizeAbsolutePath(options.configPath),
+		configSize: configStat.size,
+		configTime: configStat.mtimeMs,
+		extensions: normalizeExtensions(options.extensions),
+		projectRootDir: normalizeAbsolutePath(options.projectRootDir)
+	});
+}
+function clearCheckerProjectConfigCache() {
+	parsedProjectConfigCache.clear();
+}
+function createExtraFileExtensions(extensions) {
+	const nativeExtensions = new Set(getNativeTypeScriptProjectExtensions());
+	return extensions.filter((extension) => !nativeExtensions.has(extension)).map((extension) => ({
+		extension: extension.startsWith(".") ? extension.slice(1) : extension,
+		isMixedContent: true,
+		scriptKind: ts.ScriptKind.Deferred
+	}));
+}
+function parseProjectConfigWithExtraFileExtensions(options, extensions) {
+	const diagnostics = [];
+	const parsed = ts.getParsedCommandLineOfConfigFile(options.configPath, {}, {
+		...ts.sys,
+		onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+			diagnostics.push(diagnostic);
+		}
+	}, void 0, void 0, createExtraFileExtensions(extensions));
+	if (!parsed) throw new Error(ts.formatDiagnosticsWithColorAndContext(diagnostics, createFormatHost(options.projectRootDir)));
+	const errors = [...diagnostics, ...parsed.errors];
+	if (errors.length > 0) throw new Error(ts.formatDiagnosticsWithColorAndContext(errors, createFormatHost(options.projectRootDir)));
+	return createParsedCheckerProjectConfig({
+		extensions,
+		fileNames: parsed.fileNames,
+		parsed
+	});
+}
+function parseTypeScriptProjectConfig(options, extensions) {
+	const { diagnostics, parsed } = readTypeScriptProjectConfig(options);
+	const errors = [...diagnostics, ...parsed.errors];
+	if (errors.length > 0) throw new Error(ts.formatDiagnosticsWithColorAndContext(errors, createFormatHost(options.projectRootDir)));
+	return createParsedCheckerProjectConfig({
+		extensions,
+		fileNames: parsed.fileNames,
+		parsed
+	});
+}
+function isModuleNotFoundError(error) {
+	return error !== null && typeof error === "object" && "code" in error && error.code === "MODULE_NOT_FOUND";
+}
+function createCheckerPackageRequire(options) {
+	for (const basePath of [posix.join(options.projectRootDir, "package.json"), import.meta.url]) {
+		const requireFromBase = createRequire(basePath);
+		try {
+			return createRequire(requireFromBase.resolve(`${options.packageName}/package.json`));
+		} catch (error) {
+			if (error && typeof error === "object" && "code" in error && error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED") return createRequire(requireFromBase.resolve(options.packageName));
+			if (isModuleNotFoundError(error)) continue;
+			throw error;
+		}
+	}
+	return null;
+}
+function getVueLanguageCore(options) {
+	const requireFromChecker = createCheckerPackageRequire(options);
+	if (!requireFromChecker) throw new Error([
+		"Unable to resolve Vue checker package:",
+		`  package: ${options.packageName}`,
+		`  root: ${options.projectRootDir}`
+	].join("\n"));
+	try {
+		return requireFromChecker("@vue/language-core");
+	} catch (error) {
+		if (isModuleNotFoundError(error)) throw new Error([
+			"Unable to resolve Vue checker language core:",
+			`  checker package: ${options.packageName}`,
+			"  required package: @vue/language-core"
+		].join("\n"));
+		throw error;
+	}
+}
+function createVueParsedCommandLine(options) {
+	const vueLanguageCore = getVueLanguageCore({
+		packageName: options.packageName,
+		projectRootDir: options.projectRootDir
+	});
+	const configPath = normalizeAbsolutePath(options.configPath);
+	return {
+		commandLine: vueLanguageCore.createParsedCommandLine(ts, ts.sys, configPath),
+		configPath,
+		vueLanguageCore
+	};
+}
+function resolveVueProjectExtensions(options, packageName) {
+	const { commandLine, vueLanguageCore } = createVueParsedCommandLine({
+		configPath: options.configPath,
+		packageName,
+		projectRootDir: options.projectRootDir
+	});
+	try {
+		return normalizeExtensions([...getTypeScriptCheckerExtensions(), ...vueLanguageCore.getAllExtensions(commandLine.vueOptions)]);
+	} catch (error) {
+		throw new Error([
+			"Unable to resolve Vue checker extensions:",
+			`  checker package: ${packageName}`,
+			`  config: ${toRelativePath(options.projectRootDir, options.configPath)}`,
+			`  reason: ${String(error)}`
+		].join("\n"));
+	}
+}
+function parseProjectConfigWithExtensions(options, extensions) {
+	const resolvedExtensions = options.extensions && options.extensions.length > 0 ? options.extensions : extensions;
+	return createExtraFileExtensions(resolvedExtensions).length > 0 ? parseProjectConfigWithExtraFileExtensions(options, resolvedExtensions) : parseTypeScriptProjectConfig(options, resolvedExtensions);
+}
+function parseVueProjectConfig(options, packageName) {
+	const { commandLine, configPath, vueLanguageCore } = createVueParsedCommandLine({
+		configPath: options.configPath,
+		packageName,
+		projectRootDir: options.projectRootDir
+	});
+	const extensions = normalizeExtensions([
+		...options.extensions ?? [],
+		...getTypeScriptCheckerExtensions(),
+		...vueLanguageCore.getAllExtensions(commandLine.vueOptions)
+	]);
+	const configFile = ts.readJsonConfigFile(configPath, ts.sys.readFile);
+	const parsed = ts.parseJsonSourceFileConfigFileContent(configFile, ts.sys, posix.dirname(configPath), {}, configPath, void 0, createExtraFileExtensions(extensions));
+	const errors = parsed.errors;
+	if (errors.length > 0) throw new Error(ts.formatDiagnosticsWithColorAndContext(errors, createFormatHost(options.projectRootDir)));
+	return createParsedCheckerProjectConfig({
+		extensions,
+		fileNames: parsed.fileNames,
+		parsed
+	});
+}
+function resolveExtensionsForChecker(options, extensions) {
+	return normalizeExtensions(options.extensions && options.extensions.length > 0 ? options.extensions : extensions);
+}
+function resolveVueProjectExtensionsForChecker(options, packageName) {
+	return normalizeExtensions([...options.extensions ?? [], ...resolveVueProjectExtensions(options, packageName)]);
+}
+function resolveTypeScriptModuleName(options) {
+	const resolved = ts.resolveModuleName(options.specifier, options.containingFile, options.compilerOptions, ts.sys).resolvedModule;
+	if (resolved?.resolvedFileName) return normalizeAbsolutePath(resolved.resolvedFileName);
+	return resolveRelativeModuleCandidate(options) ?? resolvePathMappedModuleCandidate(options);
+}
+function mergeParsedProjectConfigs(parsedConfigs, extensions) {
+	const firstConfig = parsedConfigs[0];
+	if (!firstConfig) throw new Error("Unable to parse checker project config: no parser ran.");
+	return {
+		extensions: normalizeExtensions([...extensions, ...parsedConfigs.flatMap((parsedConfig) => parsedConfig.extensions)]),
+		fileNames: uniqueSortedStrings(parsedConfigs.flatMap((parsedConfig) => parsedConfig.fileNames)),
+		options: firstConfig.options
+	};
+}
+function parseCheckerProjectConfigForContext(options) {
+	const checkerPresets = resolveContextCheckerPresets(options.context);
+	const cacheKey = createParsedProjectConfigCacheKey({
+		checkerPresets,
+		configPath: options.configPath,
+		extensions: options.context.extensions,
+		projectRootDir: options.projectRootDir
+	});
+	const cached = parsedProjectConfigCache.get(cacheKey);
+	if (cached) return cloneParsedCheckerProjectConfig(cached);
+	const parsedConfig = mergeParsedProjectConfigs(checkerPresets.map((preset) => {
+		const adapter = getCheckerAdapter(preset);
+		if (!adapter) throw new Error(`Checker preset "${preset}" is not supported.`);
+		return adapter.parseProjectConfig({
+			configPath: options.configPath,
+			extensions: options.context.extensions,
+			projectRootDir: options.projectRootDir
+		});
+	}), options.context.extensions);
+	parsedProjectConfigCache.set(cacheKey, cloneParsedCheckerProjectConfig(parsedConfig));
+	return cloneParsedCheckerProjectConfig(parsedConfig);
+}
+function resolveModuleNameWithCheckers(options) {
+	const checkerPresets = options.context.checkerPresets.length > 0 ? options.context.checkerPresets : ["tsc"];
+	for (const preset of checkerPresets) {
+		const adapter = getCheckerAdapter(preset);
+		if (!adapter) continue;
+		const resolved = adapter.resolveModuleName({
+			compilerOptions: options.compilerOptions,
+			containingFile: options.containingFile,
+			extensions: options.context.extensions,
+			specifier: options.specifier
+		});
+		if (resolved) return resolved;
+	}
+	return null;
+}
+function resolveCheckerProjectExtensions(options) {
+	const adapter = getCheckerAdapter(options.preset);
+	if (!adapter) throw new Error(`Checker preset "${options.preset}" is not supported.`);
+	return adapter.extensions({
+		configPath: options.configPath,
+		projectRootDir: options.projectRootDir
+	});
+}
+function createTscCommandTarget(options) {
+	const relativeConfigPath = toRelativePath(options.projectRootDir, options.configPath);
+	return {
+		args: [
+			"-b",
+			relativeConfigPath,
+			"--pretty",
+			"false",
+			...options.watch ? ["--watch", "--preserveWatchOutput"] : []
+		],
+		command: options.commandOverride ?? "tsc",
+		label: `tsc -b ${relativeConfigPath}${options.watch ? " --watch" : ""}`
+	};
+}
+function createTsgoCommandTarget(options) {
+	const relativeConfigPath = toRelativePath(options.projectRootDir, options.configPath);
+	return {
+		args: [
+			"-b",
+			relativeConfigPath,
+			"--pretty",
+			"false",
+			...options.watch ? ["--watch", "--preserveWatchOutput"] : []
+		],
+		command: "tsgo",
+		label: `tsgo -b ${relativeConfigPath}${options.watch ? " --watch" : ""}`
+	};
+}
+function createVueTscCommandTarget(options) {
+	const relativeConfigPath = toRelativePath(options.projectRootDir, options.configPath);
+	return {
+		args: [
+			"-b",
+			relativeConfigPath,
+			"--pretty",
+			"false",
+			...options.watch ? ["--watch", "--preserveWatchOutput"] : []
+		],
+		command: "vue-tsc",
+		label: `${options.checker.name}: vue-tsc -b ${relativeConfigPath}${options.watch ? " --watch" : ""}`
+	};
+}
+function createVueTsgoCommandTarget(options) {
+	const relativeConfigPath = toRelativePath(options.projectRootDir, options.configPath);
+	/**
+	* vue-tsgo exposes a --build flag, but in current releases that mode
+	* generates a transient virtual TS workspace and asks tsgo's LSP for
+	* diagnostics. It does not preserve TypeScript project-reference boundaries
+	* or provide incremental build semantics, so Limina only uses vue-tsgo as a
+	* second-class typecheck execution checker while still using its tsconfig
+	* entry for Limina's own graph and proof coverage. Prefer vue-tsc for
+	* first-class Vue build checks.
+	*/
+	return {
+		args: ["--project", relativeConfigPath],
+		command: "vue-tsgo",
+		label: `${options.checker.name}: vue-tsgo --project ${relativeConfigPath}`
+	};
+}
+function createSvelteCheckCommandTarget(options) {
+	const relativeConfigPath = toRelativePath(options.projectRootDir, options.configPath);
+	return {
+		args: ["--tsconfig", relativeConfigPath],
+		command: "svelte-check",
+		label: `${options.checker.name}: svelte-check --tsconfig ${relativeConfigPath}`
+	};
+}
+const builtinCheckerAdapters = {
+	"svelte-check": {
+		createCommandTarget: createSvelteCheckCommandTarget,
+		extensions: (options) => resolveExtensionsForChecker(options, getSvelteCheckerExtensions()),
+		execution: "typecheck",
+		packageNames: ["svelte-check"],
+		parseProjectConfig: (options) => parseProjectConfigWithExtensions(options, getSvelteCheckerExtensions()),
+		preset: "svelte-check",
+		resolveModuleName: resolveTypeScriptModuleName,
+		sourceGraph: false
+	},
+	tsc: {
+		createCommandTarget: createTscCommandTarget,
+		extensions: (options) => resolveExtensionsForChecker(options, getTypeScriptCheckerExtensions()),
+		execution: "build",
+		packageNames: ["typescript"],
+		parseProjectConfig: (options) => parseProjectConfigWithExtensions(options, getTypeScriptCheckerExtensions()),
+		preset: "tsc",
+		resolveModuleName: resolveTypeScriptModuleName,
+		sourceGraph: true
+	},
+	tsgo: {
+		createCommandTarget: createTsgoCommandTarget,
+		extensions: (options) => resolveExtensionsForChecker(options, getTypeScriptCheckerExtensions()),
+		execution: "build",
+		packageNames: ["@typescript/native-preview"],
+		parseProjectConfig: (options) => parseProjectConfigWithExtensions(options, getTypeScriptCheckerExtensions()),
+		preset: "tsgo",
+		resolveModuleName: resolveTypeScriptModuleName,
+		sourceGraph: true
+	},
+	"vue-tsc": {
+		createCommandTarget: createVueTscCommandTarget,
+		extensions: (options) => resolveVueProjectExtensionsForChecker(options, "vue-tsc"),
+		execution: "build",
+		packageNames: ["vue-tsc"],
+		parseProjectConfig: (options) => parseVueProjectConfig(options, "vue-tsc"),
+		preset: "vue-tsc",
+		resolveModuleName: resolveTypeScriptModuleName,
+		sourceGraph: true
+	},
+	"vue-tsgo": {
+		createCommandTarget: createVueTsgoCommandTarget,
+		extensions: (options) => resolveVueProjectExtensionsForChecker(options, "vue-tsgo"),
+		execution: "typecheck",
+		packageNames: ["vue-tsgo", "@typescript/native-preview"],
+		parseProjectConfig: (options) => parseVueProjectConfig(options, "vue-tsgo"),
+		preset: "vue-tsgo",
+		resolveModuleName: resolveTypeScriptModuleName,
+		sourceGraph: true
+	}
+};
+function isBuiltinCheckerPreset(value) {
+	return Object.hasOwn(builtinCheckerAdapters, value);
+}
+function getCheckerAdapter(preset) {
+	return isBuiltinCheckerPreset(preset) ? builtinCheckerAdapters[preset] : null;
+}
+function isVueCheckerPreset(preset) {
+	return preset === "vue-tsc" || preset === "vue-tsgo";
+}
+function resolveCheckerPackageFromRoot(options) {
+	const requireFromRoot = createRequire(posix.join(options.projectRootDir, "package.json"));
+	try {
+		return requireFromRoot.resolve(`${options.packageName}/package.json`);
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error && error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED") return options.packageName;
+		if (error && typeof error === "object" && "code" in error && error.code === "MODULE_NOT_FOUND") return;
+		throw error;
+	}
+}
+function collectMissingCheckerPeerDependencies(options) {
+	const resolvePackage = options.resolvePackage ?? resolveCheckerPackageFromRoot;
+	const missingCheckersByPackage = /* @__PURE__ */ new Map();
+	for (const checker of options.checkers) {
+		const packageNames = getCheckerAdapter(checker.preset)?.packageNames ?? [];
+		for (const packageName of packageNames) {
+			if (resolvePackage({
+				packageName,
+				projectRootDir: options.projectRootDir
+			})) continue;
+			const checkerNames = missingCheckersByPackage.get(packageName) ?? /* @__PURE__ */ new Set();
+			checkerNames.add(checker.name);
+			missingCheckersByPackage.set(packageName, checkerNames);
+		}
+	}
+	return [...missingCheckersByPackage.entries()].map(([packageName, checkerNames]) => ({
+		checkerNames: [...checkerNames].sort((left, right) => left.localeCompare(right)),
+		packageName
+	})).sort((left, right) => left.packageName.localeCompare(right.packageName));
+}
+function formatMissingCheckerPeerDependencies(missingDependencies) {
+	const packageNames = missingDependencies.map((dependency) => dependency.packageName);
+	return [
+		"Missing checker peer dependencies:",
+		...missingDependencies.map((dependency) => {
+			const checkerList = dependency.checkerNames.map((checkerName) => `"${checkerName}"`).join(", ");
+			const reason = dependency.reason ? `; ${dependency.reason}` : "";
+			return `  - ${dependency.packageName} (used by checker ${checkerList}${reason})`;
+		}),
+		`Fix: pnpm add -D ${packageNames.join(" ")}`
+	].join("\n");
+}
+function getCheckerExtensions(checker, options = {}) {
+	const adapter = getCheckerAdapter(checker.preset);
+	if (adapter) {
+		if (isVueCheckerPreset(checker.preset)) return normalizeExtensions([...getTypeScriptCheckerExtensions(), ".vue"]);
+		return adapter.extensions({
+			configPath: normalizeAbsolutePath(posix.resolve(options.projectRootDir ?? "", "tsconfig.json")),
+			projectRootDir: options.projectRootDir ?? ""
+		});
+	}
+	throw new Error(`Checker preset "${checker.preset}" is not supported.`);
+}
+function getResolvedCheckers(config) {
+	const checkers = config.config?.checkers;
+	if (!checkers || checkers.mode === "auto") return [];
+	const checkerMap = checkers;
+	return Object.entries(checkerMap).map(([name, checker]) => ({
+		exclude: (checker.exclude ?? []).map((value) => value.trim()),
+		extensions: getCheckerExtensions(checker, { projectRootDir: config.rootDir }),
+		include: checker.include.map((value) => value.trim()),
+		name,
+		preset: checker.preset
+	})).sort((left, right) => left.name.localeCompare(right.name));
+}
+function normalizeExtensions(extensions) {
+	return uniqueValues(extensions).sort((left, right) => {
+		const lengthDelta = right.length - left.length;
+		return lengthDelta === 0 ? left.localeCompare(right) : lengthDelta;
+	});
+}
+
+//#endregion
+//#region src/utils/values.ts
+function isPlainRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function formatUnknownValue(value) {
+	if (value === void 0) return "undefined";
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/core.js
+/** A special constant with type `never` */
+const NEVER = 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.`);
+	}
+};
+var $ZodEncodeError = class extends Error {
+	constructor(name) {
+		super(`Encountered unidirectional transform during encode: ${name}`);
+		this.name = "ZodEncodeError";
+	}
+};
+const globalConfig = {};
+function config(newConfig) {
+	if (newConfig) Object.assign(globalConfig, newConfig);
+	return globalConfig;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/util.js
+function getEnumValues(entries) {
+	const numericValues = Object.values(entries).filter((v) => typeof v === "number");
+	return Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
+}
+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 nullish(input) {
+	return input === null || input === void 0;
+}
+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
+	});
+}
+function assignProp(target, prop, value) {
+	Object.defineProperty(target, prop, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+}
+function mergeDefs(...defs) {
+	const mergedDescriptors = {};
+	for (const def of defs) {
+		const descriptors = Object.getOwnPropertyDescriptors(def);
+		Object.assign(mergedDescriptors, descriptors);
+	}
+	return Object.defineProperties({}, mergedDescriptors);
+}
+function esc(str) {
+	return JSON.stringify(str);
+}
+const captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
+function isObject(data) {
+	return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+const allowsEval = cached(() => {
+	if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) return false;
+	try {
+		new Function("");
+		return true;
+	} catch (_) {
+		return false;
+	}
+});
+function isPlainObject(o) {
+	if (isObject(o) === false) return false;
+	const ctor = o.constructor;
+	if (ctor === void 0) return true;
+	if (typeof ctor !== "function") return true;
+	const prot = ctor.prototype;
+	if (isObject(prot) === false) return false;
+	if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) return false;
+	return true;
+}
+function shallowClone(o) {
+	if (isPlainObject(o)) return { ...o };
+	if (Array.isArray(o)) return [...o];
+	return o;
+}
+const propertyKeyTypes = new Set([
+	"string",
+	"number",
+	"symbol"
+]);
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+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";
+	});
+}
+const NUMBER_FORMAT_RANGES = {
+	safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+	int32: [-2147483648, 2147483647],
+	uint32: [0, 4294967295],
+	float32: [-34028234663852886e22, 34028234663852886e22],
+	float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+};
+function pick(schema, mask) {
+	const currDef = schema._zod.def;
+	const checks = currDef.checks;
+	if (checks && checks.length > 0) throw new Error(".pick() cannot be used on object schemas containing refinements");
+	return clone(schema, mergeDefs(schema._zod.def, {
+		get shape() {
+			const newShape = {};
+			for (const key in mask) {
+				if (!(key in currDef.shape)) throw new Error(`Unrecognized key: "${key}"`);
+				if (!mask[key]) continue;
+				newShape[key] = currDef.shape[key];
+			}
+			assignProp(this, "shape", newShape);
+			return newShape;
+		},
+		checks: []
+	}));
+}
+function omit(schema, mask) {
+	const currDef = schema._zod.def;
+	const checks = currDef.checks;
+	if (checks && checks.length > 0) throw new Error(".omit() cannot be used on object schemas containing refinements");
+	return clone(schema, mergeDefs(schema._zod.def, {
+		get shape() {
+			const newShape = { ...schema._zod.def.shape };
+			for (const key in mask) {
+				if (!(key in currDef.shape)) throw new Error(`Unrecognized key: "${key}"`);
+				if (!mask[key]) continue;
+				delete newShape[key];
+			}
+			assignProp(this, "shape", newShape);
+			return newShape;
+		},
+		checks: []
+	}));
+}
+function extend(schema, shape) {
+	if (!isPlainObject(shape)) throw new Error("Invalid input to extend: expected a plain object");
+	const checks = schema._zod.def.checks;
+	if (checks && checks.length > 0) {
+		const existingShape = schema._zod.def.shape;
+		for (const key in shape) if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
+	}
+	return clone(schema, mergeDefs(schema._zod.def, { get shape() {
+		const _shape = {
+			...schema._zod.def.shape,
+			...shape
+		};
+		assignProp(this, "shape", _shape);
+		return _shape;
+	} }));
+}
+function safeExtend(schema, shape) {
+	if (!isPlainObject(shape)) throw new Error("Invalid input to safeExtend: expected a plain object");
+	return clone(schema, mergeDefs(schema._zod.def, { get shape() {
+		const _shape = {
+			...schema._zod.def.shape,
+			...shape
+		};
+		assignProp(this, "shape", _shape);
+		return _shape;
+	} }));
+}
+function merge(a, b) {
+	return clone(a, mergeDefs(a._zod.def, {
+		get shape() {
+			const _shape = {
+				...a._zod.def.shape,
+				...b._zod.def.shape
+			};
+			assignProp(this, "shape", _shape);
+			return _shape;
+		},
+		get catchall() {
+			return b._zod.def.catchall;
+		},
+		checks: []
+	}));
+}
+function partial(Class, schema, mask) {
+	const checks = schema._zod.def.checks;
+	if (checks && checks.length > 0) throw new Error(".partial() cannot be used on object schemas containing refinements");
+	return clone(schema, mergeDefs(schema._zod.def, {
+		get shape() {
+			const oldShape = schema._zod.def.shape;
+			const shape = { ...oldShape };
+			if (mask) for (const key in mask) {
+				if (!(key in oldShape)) throw new Error(`Unrecognized key: "${key}"`);
+				if (!mask[key]) continue;
+				shape[key] = Class ? new Class({
+					type: "optional",
+					innerType: oldShape[key]
+				}) : oldShape[key];
+			}
+			else for (const key in oldShape) shape[key] = Class ? new Class({
+				type: "optional",
+				innerType: oldShape[key]
+			}) : oldShape[key];
+			assignProp(this, "shape", shape);
+			return shape;
+		},
+		checks: []
+	}));
+}
+function required(Class, schema, mask) {
+	return clone(schema, mergeDefs(schema._zod.def, { get shape() {
+		const oldShape = schema._zod.def.shape;
+		const shape = { ...oldShape };
+		if (mask) for (const key in mask) {
+			if (!(key in shape)) throw new Error(`Unrecognized key: "${key}"`);
+			if (!mask[key]) continue;
+			shape[key] = new Class({
+				type: "nonoptional",
+				innerType: oldShape[key]
+			});
+		}
+		else for (const key in oldShape) shape[key] = new Class({
+			type: "nonoptional",
+			innerType: oldShape[key]
+		});
+		assignProp(this, "shape", shape);
+		return shape;
+	} }));
+}
+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;
+}
+function getLengthableOrigin(input) {
+	if (Array.isArray(input)) return "array";
+	if (typeof input === "string") return "string";
+	return "unknown";
+}
+function issue(...args) {
+	const [iss, input, inst] = args;
+	if (typeof iss === "string") return {
+		message: iss,
+		code: "custom",
+		input,
+		inst
+	};
+	return { ...iss };
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/errors.js
+const initializer$1 = (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$1);
+const $ZodRealError = $constructor("$ZodError", initializer$1, { Parent: Error });
+function flattenError(error, mapper = (issue) => issue.message) {
+	const fieldErrors = {};
+	const formErrors = [];
+	for (const sub of error.issues) if (sub.path.length > 0) {
+		fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+		fieldErrors[sub.path[0]].push(mapper(sub));
+	} else formErrors.push(mapper(sub));
+	return {
+		formErrors,
+		fieldErrors
+	};
+}
+function formatError(error, mapper = (issue) => issue.message) {
+	const fieldErrors = { _errors: [] };
+	const processError = (error) => {
+		for (const issue of error.issues) if (issue.code === "invalid_union" && issue.errors.length) issue.errors.map((issues) => processError({ issues }));
+		else if (issue.code === "invalid_key") processError({ issues: issue.issues });
+		else if (issue.code === "invalid_element") processError({ issues: issue.issues });
+		else if (issue.path.length === 0) fieldErrors._errors.push(mapper(issue));
+		else {
+			let curr = fieldErrors;
+			let i = 0;
+			while (i < issue.path.length) {
+				const el = issue.path[i];
+				if (!(i === issue.path.length - 1)) curr[el] = curr[el] || { _errors: [] };
+				else {
+					curr[el] = curr[el] || { _errors: [] };
+					curr[el]._errors.push(mapper(issue));
+				}
+				curr = curr[el];
+				i++;
+			}
+		}
+	};
+	processError(error);
+	return fieldErrors;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/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$1 = /* @__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$1 = /* @__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$1 = /* @__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$1 = /* @__PURE__ */ _safeParseAsync($ZodRealError);
+const _encode = (_Err) => (schema, value, _ctx) => {
+	const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+	return _parse(_Err)(schema, value, ctx);
+};
+const encode$1 = /* @__PURE__ */ _encode($ZodRealError);
+const _decode = (_Err) => (schema, value, _ctx) => {
+	return _parse(_Err)(schema, value, _ctx);
+};
+const decode$1 = /* @__PURE__ */ _decode($ZodRealError);
+const _encodeAsync = (_Err) => async (schema, value, _ctx) => {
+	const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+	return _parseAsync(_Err)(schema, value, ctx);
+};
+const encodeAsync$1 = /* @__PURE__ */ _encodeAsync($ZodRealError);
+const _decodeAsync = (_Err) => async (schema, value, _ctx) => {
+	return _parseAsync(_Err)(schema, value, _ctx);
+};
+const decodeAsync$1 = /* @__PURE__ */ _decodeAsync($ZodRealError);
+const _safeEncode = (_Err) => (schema, value, _ctx) => {
+	const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+	return _safeParse(_Err)(schema, value, ctx);
+};
+const safeEncode$1 = /* @__PURE__ */ _safeEncode($ZodRealError);
+const _safeDecode = (_Err) => (schema, value, _ctx) => {
+	return _safeParse(_Err)(schema, value, _ctx);
+};
+const safeDecode$1 = /* @__PURE__ */ _safeDecode($ZodRealError);
+const _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
+	const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+	return _safeParseAsync(_Err)(schema, value, ctx);
+};
+const safeEncodeAsync$1 = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
+const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
+	return _safeParseAsync(_Err)(schema, value, _ctx);
+};
+const safeDecodeAsync$1 = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/checks.js
+const $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
+	var _a;
+	inst._zod ?? (inst._zod = {});
+	inst._zod.def = def;
+	(_a = inst._zod).onattach ?? (_a.onattach = []);
+});
+const $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
+	var _a;
+	$ZodCheck.init(inst, def);
+	(_a = inst._zod.def).when ?? (_a.when = (payload) => {
+		const val = payload.value;
+		return !nullish(val) && val.length !== void 0;
+	});
+	inst._zod.onattach.push((inst) => {
+		const curr = inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
+		if (def.maximum < curr) inst._zod.bag.maximum = def.maximum;
+	});
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		if (input.length <= def.maximum) return;
+		const origin = getLengthableOrigin(input);
+		payload.issues.push({
+			origin,
+			code: "too_big",
+			maximum: def.maximum,
+			inclusive: true,
+			input,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
+	var _a;
+	$ZodCheck.init(inst, def);
+	(_a = inst._zod.def).when ?? (_a.when = (payload) => {
+		const val = payload.value;
+		return !nullish(val) && val.length !== void 0;
+	});
+	inst._zod.onattach.push((inst) => {
+		const curr = inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
+		if (def.minimum > curr) inst._zod.bag.minimum = def.minimum;
+	});
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		if (input.length >= def.minimum) return;
+		const origin = getLengthableOrigin(input);
+		payload.issues.push({
+			origin,
+			code: "too_small",
+			minimum: def.minimum,
+			inclusive: true,
+			input,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
+	var _a;
+	$ZodCheck.init(inst, def);
+	(_a = inst._zod.def).when ?? (_a.when = (payload) => {
+		const val = payload.value;
+		return !nullish(val) && val.length !== void 0;
+	});
+	inst._zod.onattach.push((inst) => {
+		const bag = inst._zod.bag;
+		bag.minimum = def.length;
+		bag.maximum = def.length;
+		bag.length = def.length;
+	});
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		const length = input.length;
+		if (length === def.length) return;
+		const origin = getLengthableOrigin(input);
+		const tooBig = length > def.length;
+		payload.issues.push({
+			origin,
+			...tooBig ? {
+				code: "too_big",
+				maximum: def.length
+			} : {
+				code: "too_small",
+				minimum: def.length
+			},
+			inclusive: true,
+			exact: true,
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	inst._zod.check = (payload) => {
+		payload.value = def.tx(payload.value);
+	};
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/doc.js
+var Doc = class {
+	constructor(args = []) {
+		this.content = [];
+		this.indent = 0;
+		if (this) this.args = args;
+	}
+	indented(fn) {
+		this.indent += 1;
+		fn(this);
+		this.indent -= 1;
+	}
+	write(arg) {
+		if (typeof arg === "function") {
+			arg(this, { execution: "sync" });
+			arg(this, { execution: "async" });
+			return;
+		}
+		const lines = arg.split("\n").filter((x) => x);
+		const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
+		const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
+		for (const line of dedented) this.content.push(line);
+	}
+	compile() {
+		const F = Function;
+		const args = this?.args;
+		const lines = [...(this?.content ?? [``]).map((x) => `  ${x}`)];
+		return new F(...args, lines.join("\n"));
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/versions.js
+const version = {
+	major: 4,
+	minor: 3,
+	patch: 6
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/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$1(inst, value);
+				return r.success ? { value: r.data } : { issues: r.error?.issues };
+			} catch (_) {
+				return safeParseAsync$1(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
+			}
+		},
+		vendor: "zod",
+		version: 1
+	}));
+});
+const $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload) => payload;
+});
+const $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, _ctx) => {
+		payload.issues.push({
+			expected: "never",
+			code: "invalid_type",
+			input: payload.value,
+			inst
+		});
+		return 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);
+	};
+});
+const $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => {
+	$ZodObject.init(inst, def);
+	const superParse = inst._zod.parse;
+	const _normalized = cached(() => normalizeDef(def));
+	const generateFastpass = (shape) => {
+		const doc = new Doc([
+			"shape",
+			"payload",
+			"ctx"
+		]);
+		const normalized = _normalized.value;
+		const parseStr = (key) => {
+			const k = esc(key);
+			return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
+		};
+		doc.write(`const input = payload.value;`);
+		const ids = Object.create(null);
+		let counter = 0;
+		for (const key of normalized.keys) ids[key] = `key_${counter++}`;
+		doc.write(`const newResult = {};`);
+		for (const key of normalized.keys) {
+			const id = ids[key];
+			const k = esc(key);
+			const isOptionalOut = shape[key]?._zod?.optout === "optional";
+			doc.write(`const ${id} = ${parseStr(key)};`);
+			if (isOptionalOut) doc.write(`
+        if (${id}.issues.length) {
+          if (${k} in input) {
+            payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+              ...iss,
+              path: iss.path ? [${k}, ...iss.path] : [${k}]
+            })));
+          }
+        }
+        
+        if (${id}.value === undefined) {
+          if (${k} in input) {
+            newResult[${k}] = undefined;
+          }
+        } else {
+          newResult[${k}] = ${id}.value;
+        }
+        
+      `);
+			else doc.write(`
+        if (${id}.issues.length) {
+          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${k}, ...iss.path] : [${k}]
+          })));
+        }
+        
+        if (${id}.value === undefined) {
+          if (${k} in input) {
+            newResult[${k}] = undefined;
+          }
+        } else {
+          newResult[${k}] = ${id}.value;
+        }
+        
+      `);
+		}
+		doc.write(`payload.value = newResult;`);
+		doc.write(`return payload;`);
+		const fn = doc.compile();
+		return (payload, ctx) => fn(shape, payload, ctx);
+	};
+	let fastpass;
+	const isObject$1 = isObject;
+	const jit = !globalConfig.jitless;
+	const allowsEval$1 = allowsEval;
+	const fastEnabled = jit && allowsEval$1.value;
+	const catchall = def.catchall;
+	let value;
+	inst._zod.parse = (payload, ctx) => {
+		value ?? (value = _normalized.value);
+		const input = payload.value;
+		if (!isObject$1(input)) {
+			payload.issues.push({
+				expected: "object",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
+			if (!fastpass) fastpass = generateFastpass(def.shape);
+			payload = fastpass(payload, ctx);
+			if (!catchall) return payload;
+			return handleCatchall([], input, payload, ctx, value, inst);
+		}
+		return superParse(payload, ctx);
+	};
+});
+function handleUnionResults(results, final, inst, ctx) {
+	for (const result of results) if (result.issues.length === 0) {
+		final.value = result.value;
+		return final;
+	}
+	const nonaborted = results.filter((r) => !aborted(r));
+	if (nonaborted.length === 1) {
+		final.value = nonaborted[0].value;
+		return nonaborted[0];
+	}
+	final.issues.push({
+		code: "invalid_union",
+		input: final.value,
+		inst,
+		errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+	});
+	return final;
+}
+const $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
+	defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
+	defineLazy(inst._zod, "values", () => {
+		if (def.options.every((o) => o._zod.values)) return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
+	});
+	defineLazy(inst._zod, "pattern", () => {
+		if (def.options.every((o) => o._zod.pattern)) {
+			const patterns = def.options.map((o) => o._zod.pattern);
+			return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
+		}
+	});
+	const single = def.options.length === 1;
+	const first = def.options[0]._zod.run;
+	inst._zod.parse = (payload, ctx) => {
+		if (single) return first(payload, ctx);
+		let async = false;
+		const results = [];
+		for (const option of def.options) {
+			const result = option._zod.run({
+				value: payload.value,
+				issues: []
+			}, ctx);
+			if (result instanceof Promise) {
+				results.push(result);
+				async = true;
+			} else {
+				if (result.issues.length === 0) return result;
+				results.push(result);
+			}
+		}
+		if (!async) return handleUnionResults(results, payload, inst, ctx);
+		return Promise.all(results).then((results) => {
+			return handleUnionResults(results, payload, inst, ctx);
+		});
+	};
+});
+const $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		const left = def.left._zod.run({
+			value: input,
+			issues: []
+		}, ctx);
+		const right = def.right._zod.run({
+			value: input,
+			issues: []
+		}, ctx);
+		if (left instanceof Promise || right instanceof Promise) return Promise.all([left, right]).then(([left, right]) => {
+			return handleIntersectionResults(payload, left, right);
+		});
+		return handleIntersectionResults(payload, left, right);
+	};
+});
+function mergeValues(a, b) {
+	if (a === b) return {
+		valid: true,
+		data: a
+	};
+	if (a instanceof Date && b instanceof Date && +a === +b) return {
+		valid: true,
+		data: a
+	};
+	if (isPlainObject(a) && isPlainObject(b)) {
+		const bKeys = Object.keys(b);
+		const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
+		const newObj = {
+			...a,
+			...b
+		};
+		for (const key of sharedKeys) {
+			const sharedValue = mergeValues(a[key], b[key]);
+			if (!sharedValue.valid) return {
+				valid: false,
+				mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
+			};
+			newObj[key] = sharedValue.data;
+		}
+		return {
+			valid: true,
+			data: newObj
+		};
+	}
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return {
+			valid: false,
+			mergeErrorPath: []
+		};
+		const newArray = [];
+		for (let index = 0; index < a.length; index++) {
+			const itemA = a[index];
+			const itemB = b[index];
+			const sharedValue = mergeValues(itemA, itemB);
+			if (!sharedValue.valid) return {
+				valid: false,
+				mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
+			};
+			newArray.push(sharedValue.data);
+		}
+		return {
+			valid: true,
+			data: newArray
+		};
+	}
+	return {
+		valid: false,
+		mergeErrorPath: []
+	};
+}
+function handleIntersectionResults(result, left, right) {
+	const unrecKeys = /* @__PURE__ */ new Map();
+	let unrecIssue;
+	for (const iss of left.issues) if (iss.code === "unrecognized_keys") {
+		unrecIssue ?? (unrecIssue = iss);
+		for (const k of iss.keys) {
+			if (!unrecKeys.has(k)) unrecKeys.set(k, {});
+			unrecKeys.get(k).l = true;
+		}
+	} else result.issues.push(iss);
+	for (const iss of right.issues) if (iss.code === "unrecognized_keys") for (const k of iss.keys) {
+		if (!unrecKeys.has(k)) unrecKeys.set(k, {});
+		unrecKeys.get(k).r = true;
+	}
+	else result.issues.push(iss);
+	const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
+	if (bothKeys.length && unrecIssue) result.issues.push({
+		...unrecIssue,
+		keys: bothKeys
+	});
+	if (aborted(result)) return result;
+	const merged = mergeValues(left.value, right.value);
+	if (!merged.valid) throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
+	result.value = merged.data;
+	return result;
+}
+const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
+	$ZodType.init(inst, def);
+	const values = getEnumValues(def.entries);
+	const valuesSet = new Set(values);
+	inst._zod.values = valuesSet;
+	inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
+	inst._zod.parse = (payload, _ctx) => {
+		const input = payload.value;
+		if (valuesSet.has(input)) return payload;
+		payload.issues.push({
+			code: "invalid_value",
+			values,
+			input,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		if (ctx.direction === "backward") throw new $ZodEncodeError(inst.constructor.name);
+		const _out = def.transform(payload.value, payload);
+		if (ctx.async) return (_out instanceof Promise ? _out : Promise.resolve(_out)).then((output) => {
+			payload.value = output;
+			return payload;
+		});
+		if (_out instanceof Promise) throw new $ZodAsyncError();
+		payload.value = _out;
+		return payload;
+	};
+});
+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 $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (inst, def) => {
+	$ZodOptional.init(inst, def);
+	defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+	defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern);
+	inst._zod.parse = (payload, ctx) => {
+		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);
+	};
+});
+const $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.optin = "optional";
+	defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+	inst._zod.parse = (payload, ctx) => {
+		if (ctx.direction === "backward") return def.innerType._zod.run(payload, ctx);
+		if (payload.value === void 0) {
+			payload.value = def.defaultValue;
+			/**
+			* $ZodDefault returns the default value immediately in forward direction.
+			* It doesn't pass the default value into the validator ("prefault"). There's no reason to pass the default value through validation. The validity of the default is enforced by TypeScript statically. Otherwise, it's the responsibility of the user to ensure the default is valid. In the case of pipes with divergent in/out types, you can specify the default on the `in` schema of your ZodPipe to set a "prefault" for the pipe.   */
+			return payload;
+		}
+		const result = def.innerType._zod.run(payload, ctx);
+		if (result instanceof Promise) return result.then((result) => handleDefaultResult(result, def));
+		return handleDefaultResult(result, def);
+	};
+});
+function handleDefaultResult(payload, def) {
+	if (payload.value === void 0) payload.value = def.defaultValue;
+	return payload;
+}
+const $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.optin = "optional";
+	defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+	inst._zod.parse = (payload, ctx) => {
+		if (ctx.direction === "backward") return def.innerType._zod.run(payload, ctx);
+		if (payload.value === void 0) payload.value = def.defaultValue;
+		return def.innerType._zod.run(payload, ctx);
+	};
+});
+const $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazy(inst._zod, "values", () => {
+		const v = def.innerType._zod.values;
+		return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
+	});
+	inst._zod.parse = (payload, ctx) => {
+		const result = def.innerType._zod.run(payload, ctx);
+		if (result instanceof Promise) return result.then((result) => handleNonOptionalResult(result, inst));
+		return handleNonOptionalResult(result, inst);
+	};
+});
+function handleNonOptionalResult(payload, inst) {
+	if (!payload.issues.length && payload.value === void 0) payload.issues.push({
+		code: "invalid_type",
+		expected: "nonoptional",
+		input: payload.value,
+		inst
+	});
+	return payload;
+}
+const $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (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, "values", () => def.innerType._zod.values);
+	inst._zod.parse = (payload, ctx) => {
+		if (ctx.direction === "backward") return def.innerType._zod.run(payload, ctx);
+		const result = def.innerType._zod.run(payload, ctx);
+		if (result instanceof Promise) return result.then((result) => {
+			payload.value = result.value;
+			if (result.issues.length) {
+				payload.value = def.catchValue({
+					...payload,
+					error: { issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config())) },
+					input: payload.value
+				});
+				payload.issues = [];
+			}
+			return payload;
+		});
+		payload.value = result.value;
+		if (result.issues.length) {
+			payload.value = def.catchValue({
+				...payload,
+				error: { issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config())) },
+				input: payload.value
+			});
+			payload.issues = [];
+		}
+		return payload;
+	};
+});
+const $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazy(inst._zod, "values", () => def.in._zod.values);
+	defineLazy(inst._zod, "optin", () => def.in._zod.optin);
+	defineLazy(inst._zod, "optout", () => def.out._zod.optout);
+	defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
+	inst._zod.parse = (payload, ctx) => {
+		if (ctx.direction === "backward") {
+			const right = def.out._zod.run(payload, ctx);
+			if (right instanceof Promise) return right.then((right) => handlePipeResult(right, def.in, ctx));
+			return handlePipeResult(right, def.in, ctx);
+		}
+		const left = def.in._zod.run(payload, ctx);
+		if (left instanceof Promise) return left.then((left) => handlePipeResult(left, def.out, ctx));
+		return handlePipeResult(left, def.out, ctx);
+	};
+});
+function handlePipeResult(left, next, ctx) {
+	if (left.issues.length) {
+		left.aborted = true;
+		return left;
+	}
+	return next._zod.run({
+		value: left.value,
+		issues: left.issues
+	}, ctx);
+}
+const $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
+	defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+	defineLazy(inst._zod, "optin", () => def.innerType?._zod?.optin);
+	defineLazy(inst._zod, "optout", () => def.innerType?._zod?.optout);
+	inst._zod.parse = (payload, ctx) => {
+		if (ctx.direction === "backward") return def.innerType._zod.run(payload, ctx);
+		const result = def.innerType._zod.run(payload, ctx);
+		if (result instanceof Promise) return result.then(handleReadonlyResult);
+		return handleReadonlyResult(result);
+	};
+});
+function handleReadonlyResult(payload) {
+	payload.value = Object.freeze(payload.value);
+	return payload;
+}
+const $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, _) => {
+		return payload;
+	};
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		const r = def.fn(input);
+		if (r instanceof Promise) return r.then((r) => handleRefineResult(r, payload, input, inst));
+		handleRefineResult(r, payload, input, inst);
+	};
+});
+function handleRefineResult(result, payload, input, inst) {
+	if (!result) {
+		const _iss = {
+			code: "custom",
+			input,
+			inst,
+			path: [...inst._zod.def.path ?? []],
+			continue: !inst._zod.def.abort
+		};
+		if (inst._zod.def.params) _iss.params = inst._zod.def.params;
+		payload.issues.push(issue(_iss));
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/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());
+const globalRegistry = globalThis.__zod_globalRegistry;
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/api.js
+/* @__NO_SIDE_EFFECTS__ */
+function _unknown(Class) {
+	return new Class({ type: "unknown" });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _never(Class, params) {
+	return new Class({
+		type: "never",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _maxLength(maximum, params) {
+	return new $ZodCheckMaxLength({
+		check: "max_length",
+		...normalizeParams(params),
+		maximum
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _minLength(minimum, params) {
+	return new $ZodCheckMinLength({
+		check: "min_length",
+		...normalizeParams(params),
+		minimum
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _length(length, params) {
+	return new $ZodCheckLengthEquals({
+		check: "length_equals",
+		...normalizeParams(params),
+		length
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _overwrite(tx) {
+	return new $ZodCheckOverwrite({
+		check: "overwrite",
+		tx
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _array(Class, element, params) {
+	return new Class({
+		type: "array",
+		element,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _refine(Class, fn, _params) {
+	return new Class({
+		type: "custom",
+		check: "custom",
+		fn,
+		...normalizeParams(_params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _superRefine(fn) {
+	const ch = /* @__PURE__ */ _check((payload) => {
+		payload.addIssue = (issue$2) => {
+			if (typeof issue$2 === "string") payload.issues.push(issue(issue$2, payload.value, ch._zod.def));
+			else {
+				const _issue = issue$2;
+				if (_issue.fatal) _issue.continue = false;
+				_issue.code ?? (_issue.code = "custom");
+				_issue.input ?? (_issue.input = payload.value);
+				_issue.inst ?? (_issue.inst = ch);
+				_issue.continue ?? (_issue.continue = !ch._zod.def.abort);
+				payload.issues.push(issue(_issue));
+			}
+		};
+		return fn(payload.value, payload);
+	});
+	return ch;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _check(fn, params) {
+	const ch = new $ZodCheck({
+		check: "custom",
+		...normalizeParams(params)
+	});
+	ch._zod.check = fn;
+	return ch;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function describe$1(description) {
+	const ch = new $ZodCheck({ check: "describe" });
+	ch._zod.onattach = [(inst) => {
+		const existing = globalRegistry.get(inst) ?? {};
+		globalRegistry.add(inst, {
+			...existing,
+			description
+		});
+	}];
+	ch._zod.check = () => {};
+	return ch;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function meta$1(metadata) {
+	const ch = new $ZodCheck({ check: "meta" });
+	ch._zod.onattach = [(inst) => {
+		const existing = globalRegistry.get(inst) ?? {};
+		globalRegistry.add(inst, {
+			...existing,
+			...metadata
+		});
+	}];
+	ch._zod.check = () => {};
+	return ch;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/to-json-schema.js
+function initializeContext(params) {
+	let target = params?.target ?? "draft-2020-12";
+	if (target === "draft-4") target = "draft-04";
+	if (target === "draft-7") target = "draft-07";
+	return {
+		processors: params.processors ?? {},
+		metadataRegistry: params?.metadata ?? globalRegistry,
+		target,
+		unrepresentable: params?.unrepresentable ?? "throw",
+		override: params?.override ?? (() => {}),
+		io: params?.io ?? "output",
+		counter: 0,
+		seen: /* @__PURE__ */ new Map(),
+		cycles: params?.cycles ?? "ref",
+		reused: params?.reused ?? "inline",
+		external: params?.external ?? void 0
+	};
+}
+function process$1(schema, ctx, _params = {
+	path: [],
+	schemaPath: []
+}) {
+	var _a;
+	const def = schema._zod.def;
+	const seen = ctx.seen.get(schema);
+	if (seen) {
+		seen.count++;
+		if (_params.schemaPath.includes(schema)) seen.cycle = _params.path;
+		return seen.schema;
+	}
+	const result = {
+		schema: {},
+		count: 1,
+		cycle: void 0,
+		path: _params.path
+	};
+	ctx.seen.set(schema, result);
+	const overrideSchema = schema._zod.toJSONSchema?.();
+	if (overrideSchema) result.schema = overrideSchema;
+	else {
+		const params = {
+			..._params,
+			schemaPath: [..._params.schemaPath, schema],
+			path: _params.path
+		};
+		if (schema._zod.processJSONSchema) schema._zod.processJSONSchema(ctx, result.schema, params);
+		else {
+			const _json = result.schema;
+			const processor = ctx.processors[def.type];
+			if (!processor) throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
+			processor(schema, ctx, _json, params);
+		}
+		const parent = schema._zod.parent;
+		if (parent) {
+			if (!result.ref) result.ref = parent;
+			process$1(parent, ctx, params);
+			ctx.seen.get(parent).isParent = true;
+		}
+	}
+	const meta = ctx.metadataRegistry.get(schema);
+	if (meta) Object.assign(result.schema, meta);
+	if (ctx.io === "input" && isTransforming(schema)) {
+		delete result.schema.examples;
+		delete result.schema.default;
+	}
+	if (ctx.io === "input" && result.schema._prefault) (_a = result.schema).default ?? (_a.default = result.schema._prefault);
+	delete result.schema._prefault;
+	return ctx.seen.get(schema).schema;
+}
+function extractDefs(ctx, schema) {
+	const root = ctx.seen.get(schema);
+	if (!root) throw new Error("Unprocessed schema. This is a bug in Zod.");
+	const idToSchema = /* @__PURE__ */ new Map();
+	for (const entry of ctx.seen.entries()) {
+		const id = ctx.metadataRegistry.get(entry[0])?.id;
+		if (id) {
+			const existing = idToSchema.get(id);
+			if (existing && existing !== entry[0]) throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
+			idToSchema.set(id, entry[0]);
+		}
+	}
+	const makeURI = (entry) => {
+		const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
+		if (ctx.external) {
+			const externalId = ctx.external.registry.get(entry[0])?.id;
+			const uriGenerator = ctx.external.uri ?? ((id) => id);
+			if (externalId) return { ref: uriGenerator(externalId) };
+			const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
+			entry[1].defId = id;
+			return {
+				defId: id,
+				ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}`
+			};
+		}
+		if (entry[1] === root) return { ref: "#" };
+		const defUriPrefix = `#/${defsSegment}/`;
+		const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
+		return {
+			defId,
+			ref: defUriPrefix + defId
+		};
+	};
+	const extractToDef = (entry) => {
+		if (entry[1].schema.$ref) return;
+		const seen = entry[1];
+		const { ref, defId } = makeURI(entry);
+		seen.def = { ...seen.schema };
+		if (defId) seen.defId = defId;
+		const schema = seen.schema;
+		for (const key in schema) delete schema[key];
+		schema.$ref = ref;
+	};
+	if (ctx.cycles === "throw") for (const entry of ctx.seen.entries()) {
+		const seen = entry[1];
+		if (seen.cycle) throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>
+
+Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
+	}
+	for (const entry of ctx.seen.entries()) {
+		const seen = entry[1];
+		if (schema === entry[0]) {
+			extractToDef(entry);
+			continue;
+		}
+		if (ctx.external) {
+			const ext = ctx.external.registry.get(entry[0])?.id;
+			if (schema !== entry[0] && ext) {
+				extractToDef(entry);
+				continue;
+			}
+		}
+		if (ctx.metadataRegistry.get(entry[0])?.id) {
+			extractToDef(entry);
+			continue;
+		}
+		if (seen.cycle) {
+			extractToDef(entry);
+			continue;
+		}
+		if (seen.count > 1) {
+			if (ctx.reused === "ref") {
+				extractToDef(entry);
+				continue;
+			}
+		}
+	}
+}
+function finalize(ctx, schema) {
+	const root = ctx.seen.get(schema);
+	if (!root) throw new Error("Unprocessed schema. This is a bug in Zod.");
+	const flattenRef = (zodSchema) => {
+		const seen = ctx.seen.get(zodSchema);
+		if (seen.ref === null) return;
+		const schema = seen.def ?? seen.schema;
+		const _cached = { ...schema };
+		const ref = seen.ref;
+		seen.ref = null;
+		if (ref) {
+			flattenRef(ref);
+			const refSeen = ctx.seen.get(ref);
+			const refSchema = refSeen.schema;
+			if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
+				schema.allOf = schema.allOf ?? [];
+				schema.allOf.push(refSchema);
+			} else Object.assign(schema, refSchema);
+			Object.assign(schema, _cached);
+			if (zodSchema._zod.parent === ref) for (const key in schema) {
+				if (key === "$ref" || key === "allOf") continue;
+				if (!(key in _cached)) delete schema[key];
+			}
+			if (refSchema.$ref && refSeen.def) for (const key in schema) {
+				if (key === "$ref" || key === "allOf") continue;
+				if (key in refSeen.def && JSON.stringify(schema[key]) === JSON.stringify(refSeen.def[key])) delete schema[key];
+			}
+		}
+		const parent = zodSchema._zod.parent;
+		if (parent && parent !== ref) {
+			flattenRef(parent);
+			const parentSeen = ctx.seen.get(parent);
+			if (parentSeen?.schema.$ref) {
+				schema.$ref = parentSeen.schema.$ref;
+				if (parentSeen.def) for (const key in schema) {
+					if (key === "$ref" || key === "allOf") continue;
+					if (key in parentSeen.def && JSON.stringify(schema[key]) === JSON.stringify(parentSeen.def[key])) delete schema[key];
+				}
+			}
+		}
+		ctx.override({
+			zodSchema,
+			jsonSchema: schema,
+			path: seen.path ?? []
+		});
+	};
+	for (const entry of [...ctx.seen.entries()].reverse()) flattenRef(entry[0]);
+	const result = {};
+	if (ctx.target === "draft-2020-12") result.$schema = "https://json-schema.org/draft/2020-12/schema";
+	else if (ctx.target === "draft-07") result.$schema = "http://json-schema.org/draft-07/schema#";
+	else if (ctx.target === "draft-04") result.$schema = "http://json-schema.org/draft-04/schema#";
+	else if (ctx.target === "openapi-3.0") {}
+	if (ctx.external?.uri) {
+		const id = ctx.external.registry.get(schema)?.id;
+		if (!id) throw new Error("Schema is missing an `id` property");
+		result.$id = ctx.external.uri(id);
+	}
+	Object.assign(result, root.def ?? root.schema);
+	const defs = ctx.external?.defs ?? {};
+	for (const entry of ctx.seen.entries()) {
+		const seen = entry[1];
+		if (seen.def && seen.defId) defs[seen.defId] = seen.def;
+	}
+	if (ctx.external) {} else if (Object.keys(defs).length > 0) if (ctx.target === "draft-2020-12") result.$defs = defs;
+	else result.definitions = defs;
+	try {
+		const finalized = JSON.parse(JSON.stringify(result));
+		Object.defineProperty(finalized, "~standard", {
+			value: {
+				...schema["~standard"],
+				jsonSchema: {
+					input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
+					output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
+				}
+			},
+			enumerable: false,
+			writable: false
+		});
+		return finalized;
+	} catch (_err) {
+		throw new Error("Error converting schema to JSON.");
+	}
+}
+function isTransforming(_schema, _ctx) {
+	const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };
+	if (ctx.seen.has(_schema)) return false;
+	ctx.seen.add(_schema);
+	const def = _schema._zod.def;
+	if (def.type === "transform") return true;
+	if (def.type === "array") return isTransforming(def.element, ctx);
+	if (def.type === "set") return isTransforming(def.valueType, ctx);
+	if (def.type === "lazy") return isTransforming(def.getter(), ctx);
+	if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") return isTransforming(def.innerType, ctx);
+	if (def.type === "intersection") return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
+	if (def.type === "record" || def.type === "map") return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+	if (def.type === "pipe") return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+	if (def.type === "object") {
+		for (const key in def.shape) if (isTransforming(def.shape[key], ctx)) return true;
+		return false;
+	}
+	if (def.type === "union") {
+		for (const option of def.options) if (isTransforming(option, ctx)) return true;
+		return false;
+	}
+	if (def.type === "tuple") {
+		for (const item of def.items) if (isTransforming(item, ctx)) return true;
+		if (def.rest && isTransforming(def.rest, ctx)) return true;
+		return false;
+	}
+	return false;
+}
+/**
+* Creates a toJSONSchema method for a schema instance.
+* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
+*/
+const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
+	const ctx = initializeContext({
+		...params,
+		processors
+	});
+	process$1(schema, ctx);
+	extractDefs(ctx, schema);
+	return finalize(ctx, schema);
+};
+const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
+	const { libraryOptions, target } = params ?? {};
+	const ctx = initializeContext({
+		...libraryOptions ?? {},
+		target,
+		io,
+		processors
+	});
+	process$1(schema, ctx);
+	extractDefs(ctx, schema);
+	return finalize(ctx, schema);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/json-schema-processors.js
+const neverProcessor = (_schema, _ctx, json, _params) => {
+	json.not = {};
+};
+const unknownProcessor = (_schema, _ctx, _json, _params) => {};
+const enumProcessor = (schema, _ctx, json, _params) => {
+	const def = schema._zod.def;
+	const values = getEnumValues(def.entries);
+	if (values.every((v) => typeof v === "number")) json.type = "number";
+	if (values.every((v) => typeof v === "string")) json.type = "string";
+	json.enum = values;
+};
+const customProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Custom types cannot be represented in JSON Schema");
+};
+const transformProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Transforms cannot be represented in JSON Schema");
+};
+const arrayProcessor = (schema, ctx, _json, params) => {
+	const json = _json;
+	const def = schema._zod.def;
+	const { minimum, maximum } = schema._zod.bag;
+	if (typeof minimum === "number") json.minItems = minimum;
+	if (typeof maximum === "number") json.maxItems = maximum;
+	json.type = "array";
+	json.items = process$1(def.element, ctx, {
+		...params,
+		path: [...params.path, "items"]
+	});
+};
+const objectProcessor = (schema, ctx, _json, params) => {
+	const json = _json;
+	const def = schema._zod.def;
+	json.type = "object";
+	json.properties = {};
+	const shape = def.shape;
+	for (const key in shape) json.properties[key] = process$1(shape[key], ctx, {
+		...params,
+		path: [
+			...params.path,
+			"properties",
+			key
+		]
+	});
+	const allKeys = new Set(Object.keys(shape));
+	const requiredKeys = new Set([...allKeys].filter((key) => {
+		const v = def.shape[key]._zod;
+		if (ctx.io === "input") return v.optin === void 0;
+		else return v.optout === void 0;
+	}));
+	if (requiredKeys.size > 0) json.required = Array.from(requiredKeys);
+	if (def.catchall?._zod.def.type === "never") json.additionalProperties = false;
+	else if (!def.catchall) {
+		if (ctx.io === "output") json.additionalProperties = false;
+	} else if (def.catchall) json.additionalProperties = process$1(def.catchall, ctx, {
+		...params,
+		path: [...params.path, "additionalProperties"]
+	});
+};
+const unionProcessor = (schema, ctx, json, params) => {
+	const def = schema._zod.def;
+	const isExclusive = def.inclusive === false;
+	const options = def.options.map((x, i) => process$1(x, ctx, {
+		...params,
+		path: [
+			...params.path,
+			isExclusive ? "oneOf" : "anyOf",
+			i
+		]
+	}));
+	if (isExclusive) json.oneOf = options;
+	else json.anyOf = options;
+};
+const intersectionProcessor = (schema, ctx, json, params) => {
+	const def = schema._zod.def;
+	const a = process$1(def.left, ctx, {
+		...params,
+		path: [
+			...params.path,
+			"allOf",
+			0
+		]
+	});
+	const b = process$1(def.right, ctx, {
+		...params,
+		path: [
+			...params.path,
+			"allOf",
+			1
+		]
+	});
+	const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
+	json.allOf = [...isSimpleIntersection(a) ? a.allOf : [a], ...isSimpleIntersection(b) ? b.allOf : [b]];
+};
+const nullableProcessor = (schema, ctx, json, params) => {
+	const def = schema._zod.def;
+	const inner = process$1(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	if (ctx.target === "openapi-3.0") {
+		seen.ref = def.innerType;
+		json.nullable = true;
+	} else json.anyOf = [inner, { type: "null" }];
+};
+const nonoptionalProcessor = (schema, ctx, _json, params) => {
+	const def = schema._zod.def;
+	process$1(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = def.innerType;
+};
+const defaultProcessor = (schema, ctx, json, params) => {
+	const def = schema._zod.def;
+	process$1(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = def.innerType;
+	json.default = JSON.parse(JSON.stringify(def.defaultValue));
+};
+const prefaultProcessor = (schema, ctx, json, params) => {
+	const def = schema._zod.def;
+	process$1(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = def.innerType;
+	if (ctx.io === "input") json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
+};
+const catchProcessor = (schema, ctx, json, params) => {
+	const def = schema._zod.def;
+	process$1(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = def.innerType;
+	let catchValue;
+	try {
+		catchValue = def.catchValue(void 0);
+	} catch {
+		throw new Error("Dynamic catch values are not supported in JSON Schema");
+	}
+	json.default = catchValue;
+};
+const pipeProcessor = (schema, ctx, _json, params) => {
+	const def = schema._zod.def;
+	const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
+	process$1(innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = innerType;
+};
+const readonlyProcessor = (schema, ctx, json, params) => {
+	const def = schema._zod.def;
+	process$1(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = def.innerType;
+	json.readOnly = true;
+};
+const optionalProcessor = (schema, ctx, _json, params) => {
+	const def = schema._zod.def;
+	process$1(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = def.innerType;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/errors.js
+const initializer = (inst, issues) => {
+	$ZodError.init(inst, issues);
+	inst.name = "ZodError";
+	Object.defineProperties(inst, {
+		format: { value: (mapper) => formatError(inst, mapper) },
+		flatten: { value: (mapper) => flattenError(inst, mapper) },
+		addIssue: { value: (issue) => {
+			inst.issues.push(issue);
+			inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+		} },
+		addIssues: { value: (issues) => {
+			inst.issues.push(...issues);
+			inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+		} },
+		isEmpty: { get() {
+			return inst.issues.length === 0;
+		} }
+	});
+};
+const ZodError = $constructor("ZodError", initializer);
+const ZodRealError = $constructor("ZodError", initializer, { Parent: Error });
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/parse.js
+const parse = /* @__PURE__ */ _parse(ZodRealError);
+const parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
+const safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
+const safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
+const encode = /* @__PURE__ */ _encode(ZodRealError);
+const decode = /* @__PURE__ */ _decode(ZodRealError);
+const encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);
+const decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);
+const safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);
+const safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
+const safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
+const safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
+
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/schemas.js
+const ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
+	$ZodType.init(inst, def);
+	Object.assign(inst["~standard"], { jsonSchema: {
+		input: createStandardJSONSchemaMethod(inst, "input"),
+		output: createStandardJSONSchemaMethod(inst, "output")
+	} });
+	inst.toJSONSchema = createToJSONSchemaMethod(inst, {});
+	inst.def = def;
+	inst.type = def.type;
+	Object.defineProperty(inst, "_def", { value: def });
+	inst.check = (...checks) => {
+		return inst.clone(mergeDefs(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.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.spa = inst.safeParseAsync;
+	inst.encode = (data, params) => encode(inst, data, params);
+	inst.decode = (data, params) => decode(inst, data, params);
+	inst.encodeAsync = async (data, params) => encodeAsync(inst, data, params);
+	inst.decodeAsync = async (data, params) => decodeAsync(inst, data, params);
+	inst.safeEncode = (data, params) => safeEncode(inst, data, params);
+	inst.safeDecode = (data, params) => safeDecode(inst, data, params);
+	inst.safeEncodeAsync = async (data, params) => safeEncodeAsync(inst, data, params);
+	inst.safeDecodeAsync = async (data, params) => safeDecodeAsync(inst, data, params);
+	inst.refine = (check, params) => inst.check(refine(check, params));
+	inst.superRefine = (refinement) => inst.check(superRefine(refinement));
+	inst.overwrite = (fn) => inst.check(_overwrite(fn));
+	inst.optional = () => optional(inst);
+	inst.exactOptional = () => exactOptional(inst);
+	inst.nullable = () => nullable(inst);
+	inst.nullish = () => optional(nullable(inst));
+	inst.nonoptional = (params) => nonoptional(inst, params);
+	inst.array = () => array(inst);
+	inst.or = (arg) => union([inst, arg]);
+	inst.and = (arg) => intersection(inst, arg);
+	inst.transform = (tx) => pipe(inst, transform(tx));
+	inst.default = (def) => _default(inst, def);
+	inst.prefault = (def) => prefault(inst, def);
+	inst.catch = (params) => _catch(inst, params);
+	inst.pipe = (target) => pipe(inst, target);
+	inst.readonly = () => readonly(inst);
+	inst.describe = (description) => {
+		const cl = inst.clone();
+		globalRegistry.add(cl, { description });
+		return cl;
+	};
+	Object.defineProperty(inst, "description", {
+		get() {
+			return globalRegistry.get(inst)?.description;
+		},
+		configurable: true
+	});
+	inst.meta = (...args) => {
+		if (args.length === 0) return globalRegistry.get(inst);
+		const cl = inst.clone();
+		globalRegistry.add(cl, args[0]);
+		return cl;
+	};
+	inst.isOptional = () => inst.safeParse(void 0).success;
+	inst.isNullable = () => inst.safeParse(null).success;
+	inst.apply = (fn) => fn(inst);
+	return inst;
+});
+const ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
+	$ZodUnknown.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => unknownProcessor(inst, ctx, json, params);
+});
+function unknown() {
+	return _unknown(ZodUnknown);
+}
+const ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
+	$ZodNever.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json, params);
+});
+function never(params) {
+	return _never(ZodNever, params);
+}
+const ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
+	$ZodArray.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => arrayProcessor(inst, ctx, json, params);
+	inst.element = def.element;
+	inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
+	inst.nonempty = (params) => inst.check(_minLength(1, params));
+	inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
+	inst.length = (len, params) => inst.check(_length(len, params));
+	inst.unwrap = () => inst.element;
+});
+function array(element, params) {
+	return _array(ZodArray, element, params);
+}
+const ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
+	$ZodObjectJIT.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => objectProcessor(inst, ctx, json, params);
+	defineLazy(inst, "shape", () => {
+		return def.shape;
+	});
+	inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
+	inst.catchall = (catchall) => inst.clone({
+		...inst._zod.def,
+		catchall
+	});
+	inst.passthrough = () => inst.clone({
+		...inst._zod.def,
+		catchall: unknown()
+	});
+	inst.loose = () => inst.clone({
+		...inst._zod.def,
+		catchall: unknown()
+	});
+	inst.strict = () => inst.clone({
+		...inst._zod.def,
+		catchall: never()
+	});
+	inst.strip = () => inst.clone({
+		...inst._zod.def,
+		catchall: void 0
+	});
+	inst.extend = (incoming) => {
+		return extend(inst, incoming);
+	};
+	inst.safeExtend = (incoming) => {
+		return safeExtend(inst, incoming);
+	};
+	inst.merge = (other) => merge(inst, other);
+	inst.pick = (mask) => pick(inst, mask);
+	inst.omit = (mask) => omit(inst, mask);
+	inst.partial = (...args) => partial(ZodOptional, inst, args[0]);
+	inst.required = (...args) => required(ZodNonOptional, inst, args[0]);
+});
+function looseObject(shape, params) {
+	return new ZodObject({
+		type: "object",
+		shape,
+		catchall: unknown(),
+		...normalizeParams(params)
+	});
+}
+const ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
+	$ZodUnion.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params);
+	inst.options = def.options;
+});
+function union(options, params) {
+	return new ZodUnion({
+		type: "union",
+		options,
+		...normalizeParams(params)
+	});
+}
+const ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
+	$ZodIntersection.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => intersectionProcessor(inst, ctx, json, params);
+});
+function intersection(left, right) {
+	return new ZodIntersection({
+		type: "intersection",
+		left,
+		right
+	});
+}
+const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
+	$ZodEnum.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => enumProcessor(inst, ctx, json, params);
+	inst.enum = def.entries;
+	inst.options = Object.values(def.entries);
+	const keys = new Set(Object.keys(def.entries));
+	inst.extract = (values, params) => {
+		const newEntries = {};
+		for (const value of values) if (keys.has(value)) newEntries[value] = def.entries[value];
+		else throw new Error(`Key ${value} not found in enum`);
+		return new ZodEnum({
+			...def,
+			checks: [],
+			...normalizeParams(params),
+			entries: newEntries
+		});
+	};
+	inst.exclude = (values, params) => {
+		const newEntries = { ...def.entries };
+		for (const value of values) if (keys.has(value)) delete newEntries[value];
+		else throw new Error(`Key ${value} not found in enum`);
+		return new ZodEnum({
+			...def,
+			checks: [],
+			...normalizeParams(params),
+			entries: newEntries
+		});
+	};
+});
+function _enum(values, params) {
+	return new ZodEnum({
+		type: "enum",
+		entries: Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values,
+		...normalizeParams(params)
+	});
+}
+const ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
+	$ZodTransform.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => transformProcessor(inst, ctx, json, params);
+	inst._zod.parse = (payload, _ctx) => {
+		if (_ctx.direction === "backward") throw new $ZodEncodeError(inst.constructor.name);
+		payload.addIssue = (issue$1) => {
+			if (typeof issue$1 === "string") payload.issues.push(issue(issue$1, payload.value, def));
+			else {
+				const _issue = issue$1;
+				if (_issue.fatal) _issue.continue = false;
+				_issue.code ?? (_issue.code = "custom");
+				_issue.input ?? (_issue.input = payload.value);
+				_issue.inst ?? (_issue.inst = inst);
+				payload.issues.push(issue(_issue));
+			}
+		};
+		const output = def.transform(payload.value, payload);
+		if (output instanceof Promise) return output.then((output) => {
+			payload.value = output;
+			return payload;
+		});
+		payload.value = output;
+		return payload;
+	};
+});
+function transform(fn) {
+	return new ZodTransform({
+		type: "transform",
+		transform: fn
+	});
+}
+const ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
+	$ZodOptional.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
+	inst.unwrap = () => inst._zod.def.innerType;
+});
+function optional(innerType) {
+	return new ZodOptional({
+		type: "optional",
+		innerType
+	});
+}
+const ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
+	$ZodExactOptional.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
+	inst.unwrap = () => inst._zod.def.innerType;
+});
+function exactOptional(innerType) {
+	return new ZodExactOptional({
+		type: "optional",
+		innerType
+	});
+}
+const ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
+	$ZodNullable.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => nullableProcessor(inst, ctx, json, params);
+	inst.unwrap = () => inst._zod.def.innerType;
+});
+function nullable(innerType) {
+	return new ZodNullable({
+		type: "nullable",
+		innerType
+	});
+}
+const ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
+	$ZodDefault.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => defaultProcessor(inst, ctx, json, params);
+	inst.unwrap = () => inst._zod.def.innerType;
+	inst.removeDefault = inst.unwrap;
+});
+function _default(innerType, defaultValue) {
+	return new ZodDefault({
+		type: "default",
+		innerType,
+		get defaultValue() {
+			return typeof defaultValue === "function" ? defaultValue() : shallowClone(defaultValue);
+		}
+	});
+}
+const ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
+	$ZodPrefault.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => prefaultProcessor(inst, ctx, json, params);
+	inst.unwrap = () => inst._zod.def.innerType;
+});
+function prefault(innerType, defaultValue) {
+	return new ZodPrefault({
+		type: "prefault",
+		innerType,
+		get defaultValue() {
+			return typeof defaultValue === "function" ? defaultValue() : shallowClone(defaultValue);
+		}
+	});
+}
+const ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
+	$ZodNonOptional.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => nonoptionalProcessor(inst, ctx, json, params);
+	inst.unwrap = () => inst._zod.def.innerType;
+});
+function nonoptional(innerType, params) {
+	return new ZodNonOptional({
+		type: "nonoptional",
+		innerType,
+		...normalizeParams(params)
+	});
+}
+const ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
+	$ZodCatch.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => catchProcessor(inst, ctx, json, params);
+	inst.unwrap = () => inst._zod.def.innerType;
+	inst.removeCatch = inst.unwrap;
+});
+function _catch(innerType, catchValue) {
+	return new ZodCatch({
+		type: "catch",
+		innerType,
+		catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
+	});
+}
+const ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
+	$ZodPipe.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => pipeProcessor(inst, ctx, json, params);
+	inst.in = def.in;
+	inst.out = def.out;
+});
+function pipe(in_, out) {
+	return new ZodPipe({
+		type: "pipe",
+		in: in_,
+		out
+	});
+}
+const ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
+	$ZodReadonly.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => readonlyProcessor(inst, ctx, json, params);
+	inst.unwrap = () => inst._zod.def.innerType;
+});
+function readonly(innerType) {
+	return new ZodReadonly({
+		type: "readonly",
+		innerType
+	});
+}
+const ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
+	$ZodCustom.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx, json, params);
+});
+function refine(fn, _params = {}) {
+	return _refine(ZodCustom, fn, _params);
+}
+function superRefine(fn) {
+	return _superRefine(fn);
+}
+const describe = describe$1;
+const meta = meta$1;
+
+//#endregion
+//#region src/config/schema.ts
+const checkerExtensionsConfigReason = "checker extensions are fixed by built-in presets and cannot be configured.";
+const checkerRoutesConfigReason = "checker routes are not supported; configure checker.include with source tsconfig selectors.";
+const unsupportedCheckerPresetReason = "configured checkers require a built-in checker adapter.";
+const checkerEntryConfigReason = "checker.entry has been removed; configure checker.include with source tsconfig selectors.";
+const checkerConfigReason = "config.checkers must be an object auto config or an object keyed by checker name.";
+const checkerAutoStringConfigReason = "checkers: \"auto\" has been removed; omit config.checkers or use { mode: \"auto\" }.";
+const autoCheckerMixedConfigReason = "auto checker config must not be mixed with named checker entries.";
+const autoCheckerModeConfigReason = "auto checker config requires mode: \"auto\".";
+const importAnalysisConfigReason = "config.imports must be an object when configured.";
+const vueImportParserConfigReason = "config.imports.vue must be \"heuristic\" or \"compiler-sfc\".";
+const checkerConfigShapeSchema = looseObject({}).superRefine((checker, ctx) => {
+	const preset = checker.preset;
+	const include = checker.include;
+	const exclude = checker.exclude;
+	if (Object.hasOwn(checker, "entry")) ctx.addIssue({
+		code: "custom",
+		message: checkerEntryConfigReason,
+		path: ["entry"]
+	});
+	if (Object.hasOwn(checker, "extensions")) ctx.addIssue({
+		code: "custom",
+		message: checkerExtensionsConfigReason,
+		path: ["extensions"]
+	});
+	if (Object.hasOwn(checker, "routes")) ctx.addIssue({
+		code: "custom",
+		message: checkerRoutesConfigReason,
+		path: ["routes"]
+	});
+	if (typeof preset !== "string" || preset.trim().length === 0) ctx.addIssue({
+		code: "custom",
+		message: "checker preset must be a non-empty string.",
+		path: ["preset"]
+	});
+	else if (!getCheckerAdapter(preset)) ctx.addIssue({
+		code: "custom",
+		message: unsupportedCheckerPresetReason,
+		path: ["preset"]
+	});
+	if (!Array.isArray(include) || include.length === 0) ctx.addIssue({
+		code: "custom",
+		message: "checker include must be a non-empty string array.",
+		path: ["include"]
+	});
+	else for (const [index, value] of include.entries()) if (typeof value !== "string" || value.trim().length === 0) ctx.addIssue({
+		code: "custom",
+		message: "checker include entries must be non-empty string paths.",
+		path: ["include", index]
+	});
+	if (exclude === void 0) return;
+	if (!Array.isArray(exclude)) {
+		ctx.addIssue({
+			code: "custom",
+			message: "checker exclude must be a string array when configured.",
+			path: ["exclude"]
+		});
+		return;
+	}
+	for (const [index, value] of exclude.entries()) if (typeof value !== "string" || value.trim().length === 0) ctx.addIssue({
+		code: "custom",
+		message: "checker exclude entries must be non-empty string paths.",
+		path: ["exclude", index]
+	});
+});
+function isPlainConfigRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+const sharedLiminaConfigShapeSchema = looseObject({}).superRefine((sharedConfig, ctx) => {
+	const checkers = sharedConfig.checkers;
+	const imports = sharedConfig.imports;
+	const source = sharedConfig.source;
+	if (checkers !== void 0) if (checkers === "auto") ctx.addIssue({
+		code: "custom",
+		message: checkerAutoStringConfigReason,
+		path: ["checkers"]
+	});
+	else if (!isPlainConfigRecord(checkers)) ctx.addIssue({
+		code: "custom",
+		message: checkerConfigReason,
+		path: ["checkers"]
+	});
+	else if (Object.hasOwn(checkers, "mode")) {
+		if (checkers.mode !== "auto") ctx.addIssue({
+			code: "custom",
+			message: autoCheckerModeConfigReason,
+			path: ["checkers", "mode"]
+		});
+		const exclude = checkers.exclude;
+		if (exclude !== void 0 && !Array.isArray(exclude)) ctx.addIssue({
+			code: "custom",
+			message: "auto checker exclude must be a string array when configured.",
+			path: ["checkers", "exclude"]
+		});
+		else if (Array.isArray(exclude)) {
+			for (const [index, value] of exclude.entries()) if (typeof value !== "string" || value.trim().length === 0) ctx.addIssue({
+				code: "custom",
+				message: "auto checker exclude entries must be non-empty string paths.",
+				path: [
+					"checkers",
+					"exclude",
+					index
+				]
+			});
+		}
+		for (const key of Object.keys(checkers)) {
+			if (key === "mode" || key === "exclude") continue;
+			ctx.addIssue({
+				code: "custom",
+				message: autoCheckerMixedConfigReason,
+				path: ["checkers", key]
+			});
+		}
+	} else for (const [checkerName, checker] of Object.entries(checkers)) {
+		const result = checkerConfigShapeSchema.safeParse(checker);
+		if (result.success) continue;
+		for (const issue of result.error.issues) ctx.addIssue({
+			...issue,
+			path: [
+				"checkers",
+				checkerName,
+				...issue.path
+			]
+		});
+	}
+	if (imports !== void 0) {
+		if (!isPlainConfigRecord(imports)) ctx.addIssue({
+			code: "custom",
+			message: importAnalysisConfigReason,
+			path: ["imports"]
+		});
+		else if (imports.vue !== void 0 && imports.vue !== "heuristic" && imports.vue !== "compiler-sfc") ctx.addIssue({
+			code: "custom",
+			message: vueImportParserConfigReason,
+			path: ["imports", "vue"]
+		});
+	}
+	if (source === void 0) return;
+	if (!isPlainConfigRecord(source)) {
+		ctx.addIssue({
+			code: "custom",
+			message: "source boundary config must be an object.",
+			path: ["source"]
+		});
+		return;
+	}
+	for (const key of Object.keys(source)) {
+		if (key === "include" || key === "exclude") continue;
+		ctx.addIssue({
+			code: "custom",
+			message: "unknown source boundary config field.",
+			path: ["source", key]
+		});
+	}
+});
+const releaseContentHashShapeSchema = looseObject({}).superRefine((contentHash, ctx) => {
+	const baselineTag = contentHash.baselineTag;
+	if (baselineTag !== void 0 && typeof baselineTag !== "function" && (typeof baselineTag !== "string" || baselineTag.trim().length === 0)) ctx.addIssue({
+		code: "custom",
+		message: "baselineTag must be a non-empty string or function.",
+		path: ["baselineTag"]
+	});
+	const builtinIgnore = contentHash.builtinIgnore;
+	if (builtinIgnore !== void 0 && typeof builtinIgnore !== "boolean") ctx.addIssue({
+		code: "custom",
+		message: "builtinIgnore must be a boolean.",
+		path: ["builtinIgnore"]
+	});
+	const ignore = contentHash.ignore;
+	if (ignore === void 0 || typeof ignore === "function") return;
+	if (!Array.isArray(ignore)) {
+		ctx.addIssue({
+			code: "custom",
+			message: "ignore must be an array of non-empty strings or function.",
+			path: ["ignore"]
+		});
+		return;
+	}
+	for (const [index, pattern] of ignore.entries()) {
+		if (typeof pattern === "string" && pattern.trim().length > 0) continue;
+		ctx.addIssue({
+			code: "custom",
+			message: "ignore patterns must be non-empty strings.",
+			path: ["ignore", index]
+		});
+	}
+});
+const releaseConfigShapeSchema = looseObject({ contentHash: releaseContentHashShapeSchema.optional() });
+const executionConcurrencyFields = [
+	"tasks",
+	"checkerBuild",
+	"checkerTypecheck",
+	"packageEntries",
+	"releaseEntries"
+];
+function isValidExecutionConcurrencyValue(value) {
+	return value === "auto" || typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+const executionConfigShapeSchema = looseObject({}).superRefine((execution, ctx) => {
+	for (const key of Object.keys(execution)) {
+		if (key === "failFast" || executionConcurrencyFields.includes(key)) continue;
+		ctx.addIssue({
+			code: "custom",
+			message: "unknown execution config field.",
+			path: [key]
+		});
+	}
+	for (const key of executionConcurrencyFields) {
+		const value = execution[key];
+		if (value === void 0 || isValidExecutionConcurrencyValue(value)) continue;
+		ctx.addIssue({
+			code: "custom",
+			message: "execution concurrency must be a positive integer or \"auto\".",
+			path: [key]
+		});
+	}
+	if (execution.failFast !== void 0 && typeof execution.failFast !== "boolean") ctx.addIssue({
+		code: "custom",
+		message: "execution failFast must be a boolean.",
+		path: ["failFast"]
+	});
+});
+function validateStringArrayField(options) {
+	if (options.value === void 0) {
+		if (options.required) options.ctx.addIssue({
+			code: "custom",
+			message: `${options.valueName} must be a non-empty string array.`,
+			path: options.path
+		});
+		return false;
+	}
+	if (!Array.isArray(options.value) || options.value.length === 0) {
+		options.ctx.addIssue({
+			code: "custom",
+			message: `${options.valueName} must be a non-empty string array.`,
+			path: options.path
+		});
+		return false;
+	}
+	for (const [index, item] of options.value.entries()) {
+		if (typeof item === "string" && item.trim().length > 0) continue;
+		options.ctx.addIssue({
+			code: "custom",
+			message: `${options.valueName} entries must be non-empty strings.`,
+			path: [...options.path, index]
+		});
+	}
+	return true;
+}
+function validateSourceImportAuthorityConfig(value, ctx) {
+	if (value === void 0) return;
+	if (!isPlainConfigRecord(value)) {
+		ctx.addIssue({
+			code: "custom",
+			message: "importAuthority must be an object.",
+			path: ["source", "importAuthority"]
+		});
+		return;
+	}
+	const allow = value.allow;
+	if (allow === void 0) return;
+	if (!Array.isArray(allow)) {
+		ctx.addIssue({
+			code: "custom",
+			message: "importAuthority.allow must be an array.",
+			path: [
+				"source",
+				"importAuthority",
+				"allow"
+			]
+		});
+		return;
+	}
+	for (const [index, entry] of allow.entries()) {
+		const path = [
+			"source",
+			"importAuthority",
+			"allow",
+			index
+		];
+		if (!isPlainConfigRecord(entry)) {
+			ctx.addIssue({
+				code: "custom",
+				message: "importAuthority allow entries must be objects with files, packages or specifiers, and reason fields.",
+				path
+			});
+			continue;
+		}
+		validateStringArrayField({
+			ctx,
+			path: [...path, "files"],
+			required: true,
+			value: entry.files,
+			valueName: "files"
+		});
+		const hasPackages = validateStringArrayField({
+			ctx,
+			path: [...path, "packages"],
+			value: entry.packages,
+			valueName: "packages"
+		});
+		const hasSpecifiers = validateStringArrayField({
+			ctx,
+			path: [...path, "specifiers"],
+			value: entry.specifiers,
+			valueName: "specifiers"
+		});
+		if (!hasPackages && !hasSpecifiers) ctx.addIssue({
+			code: "custom",
+			message: "importAuthority allow entries must declare packages or specifiers.",
+			path
+		});
+		if (entry.owner !== void 0) {
+			if (typeof entry.owner !== "string" || entry.owner.trim().length === 0) ctx.addIssue({
+				code: "custom",
+				message: "owner must be a non-empty string when configured.",
+				path: [...path, "owner"]
+			});
+		}
+		if (typeof entry.reason !== "string" || entry.reason.trim().length === 0) ctx.addIssue({
+			code: "custom",
+			message: "reason must be a non-empty string.",
+			path: [...path, "reason"]
+		});
+	}
+}
+const liminaConfigShapeSchema = looseObject({
+	config: sharedLiminaConfigShapeSchema.optional(),
+	execution: executionConfigShapeSchema.optional(),
+	release: releaseConfigShapeSchema.optional()
+}).superRefine((config, ctx) => {
+	if (Object.hasOwn(config, "paths")) ctx.addIssue({
+		code: "custom",
+		message: "paths config has been removed; use graph/proof/source checks instead.",
+		path: ["paths"]
+	});
+	const source = config.source;
+	if (source === void 0) return;
+	if (!isPlainConfigRecord(source)) {
+		ctx.addIssue({
+			code: "custom",
+			message: "source config must be an object.",
+			path: ["source"]
+		});
+		return;
+	}
+	for (const key of Object.keys(source)) {
+		if (key === "knip" || key === "importAuthority") continue;
+		ctx.addIssue({
+			code: "custom",
+			message: "unknown source config field.",
+			path: ["source", key]
+		});
+	}
+	validateSourceImportAuthorityConfig(source.importAuthority, ctx);
+});
+function formatZodPath(pathSegments) {
+	return pathSegments.map((segment) => typeof segment === "number" ? `[${segment}]` : `.${String(segment)}`).join("").replace(/^\./u, "");
+}
+function getValueAtPath(value, pathSegments) {
+	let current = value;
+	for (const segment of pathSegments) {
+		if (current === void 0 || current === null) return;
+		current = current[segment];
+	}
+	return current;
+}
+function formatLiminaConfigShapeIssue(value, issue) {
+	const pathSegments = issue.path;
+	const field = formatZodPath(pathSegments);
+	if (pathSegments.length === 0) return "limina config must export or return an object.";
+	if (field === "config") return [
+		"Invalid Limina config:",
+		"  field: config",
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		"  reason: config must be an object."
+	].join("\n");
+	if (field === "paths") return [
+		"Invalid Limina paths config:",
+		"  field: paths",
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		`  reason: ${issue.message}`
+	].join("\n");
+	if (field === "execution") return [
+		"Invalid Limina execution config:",
+		"  field: execution",
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		"  reason: execution must be an object."
+	].join("\n");
+	if (field === "execution.failFast") return [
+		"Invalid Limina execution config:",
+		"  field: execution.failFast",
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		"  reason: execution failFast must be a boolean."
+	].join("\n");
+	if (field.startsWith("execution.")) return [
+		"Invalid Limina execution config:",
+		`  field: ${field}`,
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		`  reason: ${issue.message}`
+	].join("\n");
+	if (field === "config.checkers") return [
+		"Invalid Limina checker config:",
+		"  field: config.checkers",
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		`  reason: ${issue.message}`
+	].join("\n");
+	if (field === "config.checkers.mode") return [
+		"Invalid Limina checker config:",
+		"  field: config.checkers.mode",
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		`  reason: ${issue.message}`
+	].join("\n");
+	if (field.startsWith("config.checkers.exclude")) return [
+		"Invalid Limina checker config:",
+		`  field: ${field}`,
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		`  reason: ${issue.message}`
+	].join("\n");
+	if (field === "config.imports" || field.startsWith("config.imports.")) return [
+		"Invalid Limina import analysis config:",
+		`  field: ${field}`,
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		`  reason: ${issue.message}`
+	].join("\n");
+	if (field === "config.source" || field.startsWith("config.source.")) return [
+		"Invalid Limina source boundary config:",
+		`  field: ${field}`,
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		`  reason: ${issue.message}`
+	].join("\n");
+	if (field === "source" || field.startsWith("source.")) return [
+		"Invalid Limina source config:",
+		`  field: ${field}`,
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		`  reason: ${issue.message}`
+	].join("\n");
+	if (pathSegments[0] === "config" && pathSegments[1] === "checkers") {
+		const checkerName = pathSegments[2];
+		const checkerField = `config.checkers.${String(checkerName)}`;
+		if (pathSegments.length === 3) return [
+			"Invalid Limina checker config:",
+			`  field: ${checkerField}`,
+			`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+			`  reason: ${issue.message === autoCheckerMixedConfigReason ? issue.message : "checker entries must be objects."}`
+		].join("\n");
+		if (pathSegments[3] === "preset") {
+			if (issue.message === unsupportedCheckerPresetReason) return [
+				"Unsupported Limina checker preset:",
+				`  field: ${checkerField}.preset`,
+				`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+				`  reason: ${issue.message}`
+			].join("\n");
+			return [
+				"Invalid Limina checker config:",
+				`  field: ${checkerField}.preset`,
+				`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+				"  reason: checker preset must be a non-empty string."
+			].join("\n");
+		}
+		if (pathSegments[3] === "entry") return [
+			"Invalid Limina checker entry config:",
+			`  field: ${checkerField}.entry`,
+			`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+			`  reason: ${issue.message}`
+		].join("\n");
+		if (pathSegments[3] === "extensions") return [
+			"Invalid Limina checker config:",
+			`  field: ${checkerField}.extensions`,
+			`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+			`  reason: ${issue.message}`
+		].join("\n");
+		if (pathSegments[3] === "routes") return [
+			"Invalid Limina checker config:",
+			`  field: ${checkerField}.routes`,
+			`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+			`  reason: ${issue.message}`
+		].join("\n");
+	}
+	if (field === "release") return [
+		"Invalid Limina release config:",
+		"  field: release",
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		"  reason: release must be an object."
+	].join("\n");
+	if (field === "release.contentHash") return [
+		"Invalid Limina release config:",
+		"  field: release.contentHash",
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		"  reason: release.contentHash must be an object."
+	].join("\n");
+	if (field === "release.contentHash.baselineTag") return [
+		"Invalid Limina release config:",
+		"  field: release.contentHash.baselineTag",
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		"  reason: baselineTag must be a non-empty string or function."
+	].join("\n");
+	if (field === "release.contentHash.builtinIgnore") return [
+		"Invalid Limina release config:",
+		"  field: release.contentHash.builtinIgnore",
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		"  reason: builtinIgnore must be a boolean."
+	].join("\n");
+	if (field === "release.contentHash.ignore") return [
+		"Invalid Limina release config:",
+		"  field: release.contentHash.ignore",
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		"  reason: ignore must be an array of non-empty strings or function."
+	].join("\n");
+	if (pathSegments[0] === "release" && pathSegments[1] === "contentHash" && pathSegments[2] === "ignore") return [
+		"Invalid Limina release config:",
+		`  field: ${field}`,
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		"  reason: ignore patterns must be non-empty strings."
+	].join("\n");
+	return [
+		"Invalid Limina config:",
+		`  field: ${field}`,
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		`  reason: ${issue.message}`
+	].join("\n");
+}
+function collectLiminaConfigShapeProblems(value) {
+	const result = liminaConfigShapeSchema.safeParse(value);
+	if (result.success) return [];
+	return result.error.issues.map((issue) => formatLiminaConfigShapeIssue(value, issue));
+}
+function validateLiminaConfig(config) {
+	const problems = collectLiminaConfigShapeProblems(config);
+	if (problems.length > 0) throw new Error(problems.join("\n\n"));
+}
+
+//#endregion
+//#region src/config/runner.ts
+function isAutoCheckerConfigMode(checkers) {
+	return Boolean(checkers && checkers.mode === "auto");
+}
+function defineConfig(config) {
+	return config;
+}
+function getActiveCheckers(config) {
+	validateLiminaConfig(config);
+	return getResolvedCheckers(config);
+}
+function normalizeConfig(value) {
+	const config = value;
+	validateLiminaConfig(config);
+	return config;
+}
+function createConfigEnv(options) {
+	return {
+		command: options.command ?? "check",
+		mode: options.mode ?? process.env.NODE_ENV ?? "default"
+	};
+}
+function findPnpmWorkspaceRoot(startDir) {
+	let currentDir = posix.resolve(startDir);
+	while (true) {
+		if (existsSync(posix.join(currentDir, "pnpm-workspace.yaml"))) return currentDir;
+		const parentDir = posix.dirname(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+}
+function findLiminaConfigPath(startDir, rootDir) {
+	let currentDir = posix.resolve(startDir);
+	const workspaceRootDir = posix.resolve(rootDir);
+	while (isPathInsideDirectory(currentDir, workspaceRootDir)) {
+		const candidatePath = posix.join(currentDir, "limina.config.mjs");
+		if (existsSync(candidatePath)) return candidatePath;
+		if (currentDir === workspaceRootDir) return null;
+		const parentDir = posix.dirname(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+	return null;
+}
+function inferWorkspaceRoot(startDir) {
+	const rootDir = findPnpmWorkspaceRoot(startDir);
+	if (!rootDir) throw new Error([`Unable to infer Limina workspace root from ${startDir}:`, "no pnpm-workspace.yaml was found in this directory or its parents."].join(" "));
+	return rootDir;
+}
+function validateConfigPathInsideWorkspace(configPath, rootDir) {
+	if (isPathInsideDirectory(configPath, rootDir)) return;
+	throw new Error([`Unable to load Limina config at ${configPath}:`, `config file must be inside the governed pnpm workspace at ${rootDir}.`].join(" "));
+}
+async function resolveConfigExport(configExport, configEnv) {
+	return normalizeConfig(typeof configExport === "function" ? await configExport(configEnv) : await configExport);
+}
+function hasSourceImportAuthorityPackageRules(config) {
+	return Boolean(config.source?.importAuthority?.allow?.some((rule) => rule.packages?.some((packageName) => packageName.trim().length > 0)));
+}
+function validateRootPackageImportAuthorityConfig(config, rootDir) {
+	if (!hasSourceImportAuthorityPackageRules(config)) return;
+	if (existsSync(posix.join(rootDir, "package.json"))) return;
+	throw new Error([
+		"Invalid Limina source config:",
+		"  field: source.importAuthority.allow[].packages",
+		`  value: ${JSON.stringify(config.source?.importAuthority?.allow)}`,
+		"  reason: package allow rules enable workspace root package.json as a dependency authority manifest, but no package.json exists at the workspace root."
+	].join("\n"));
+}
+async function loadConfig(options = {}) {
+	const cwd = options.cwd ? posix.resolve(options.cwd) : process.cwd();
+	const rootDir = inferWorkspaceRoot(cwd);
+	const configPath = options.configPath ? posix.resolve(cwd, options.configPath) : findLiminaConfigPath(cwd, rootDir);
+	if (configPath) validateConfigPathInsideWorkspace(configPath, rootDir);
+	if (!configPath || !existsSync(configPath)) throw new Error(options.configPath ? `Unable to find limina config at ${configPath}` : `Unable to find limina config. Searched for limina.config.mjs from ${cwd} up to the pnpm workspace root at ${rootDir}.`);
+	const config = await resolveConfigExport((await import(`${pathToFileURL(configPath).href}?t=${Date.now()}`)).default, createConfigEnv(options));
+	validateRootPackageImportAuthorityConfig(config, rootDir);
+	return {
+		...config,
+		configPath,
+		rootDir
+	};
+}
+
+//#endregion
+export { isRelativeSpecifier as A, isPathInsideDirectory as C, toRelativePath as D, toPosixPath as E, uniqueSortedStrings as F, uniqueTrimmedNonEmptySortedStrings as I, uniqueValues as L, isVirtualModuleSpecifier as M, posix as N, isBarePackageSpecifier as O, uniqueBy as P, resolveRelativeModuleCandidate as S, normalizeSlashes as T, resolveModuleNameWithCheckers as _, formatUnknownValue as a, resolveExistingFilePath as b, clearCheckerProjectConfigCache as c, getBuildCheckerSupportedExtensions as d, getCheckerAdapter as f, resolveCheckerProjectExtensions as g, parseCheckerProjectConfigForContext as h, loadConfig as i, isUrlOrDataOrFileSpecifier as j, isPackageImportSpecifier as k, collectMissingCheckerPeerDependencies as l, normalizeExtensions as m, getActiveCheckers as n, isNonEmptyString as o, getCheckerExtensions as p, isAutoCheckerConfigMode as r, isPlainRecord as s, defineConfig as t, formatMissingCheckerPeerDependencies as u, candidatePathsForBasePath as v, normalizeAbsolutePath as w, resolvePathMappedModuleCandidate as x, resolveBaseUrlModuleCandidate as y };