@soda-gql/tools 0.13.0

package/dist/codegen.mjs

@@ -0,0 +1,4712 @@
+import { createRequire } from "node:module";
+import { err, ok } from "neverthrow";
+import { createSchemaIndex } from "@soda-gql/core";
+import { Kind, concatAST, parse, print } from "graphql";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { build } from "esbuild";
+import { createHash } from "node:crypto";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region node_modules/picomatch/lib/constants.js
+var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const WIN_SLASH = "\\\\/";
+	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+	/**
+	* Posix glob regex
+	*/
+	const DOT_LITERAL = "\\.";
+	const PLUS_LITERAL = "\\+";
+	const QMARK_LITERAL = "\\?";
+	const SLASH_LITERAL = "\\/";
+	const ONE_CHAR = "(?=.)";
+	const QMARK = "[^/]";
+	const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+	const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+	const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+	const NO_DOT = `(?!${DOT_LITERAL})`;
+	const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+	const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+	const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+	const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+	const STAR = `${QMARK}*?`;
+	const SEP = "/";
+	const POSIX_CHARS = {
+		DOT_LITERAL,
+		PLUS_LITERAL,
+		QMARK_LITERAL,
+		SLASH_LITERAL,
+		ONE_CHAR,
+		QMARK,
+		END_ANCHOR,
+		DOTS_SLASH,
+		NO_DOT,
+		NO_DOTS,
+		NO_DOT_SLASH,
+		NO_DOTS_SLASH,
+		QMARK_NO_DOT,
+		STAR,
+		START_ANCHOR,
+		SEP
+	};
+	/**
+	* Windows glob regex
+	*/
+	const WINDOWS_CHARS = {
+		...POSIX_CHARS,
+		SLASH_LITERAL: `[${WIN_SLASH}]`,
+		QMARK: WIN_NO_SLASH,
+		STAR: `${WIN_NO_SLASH}*?`,
+		DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+		NO_DOT: `(?!${DOT_LITERAL})`,
+		NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+		NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+		NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+		QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+		START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+		END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+		SEP: "\\"
+	};
+	/**
+	* POSIX Bracket Regex
+	*/
+	const POSIX_REGEX_SOURCE$1 = {
+		alnum: "a-zA-Z0-9",
+		alpha: "a-zA-Z",
+		ascii: "\\x00-\\x7F",
+		blank: " \\t",
+		cntrl: "\\x00-\\x1F\\x7F",
+		digit: "0-9",
+		graph: "\\x21-\\x7E",
+		lower: "a-z",
+		print: "\\x20-\\x7E ",
+		punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+		space: " \\t\\r\\n\\v\\f",
+		upper: "A-Z",
+		word: "A-Za-z0-9_",
+		xdigit: "A-Fa-f0-9"
+	};
+	module.exports = {
+		MAX_LENGTH: 1024 * 64,
+		POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
+		REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+		REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+		REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+		REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+		REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+		REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+		REPLACEMENTS: {
+			__proto__: null,
+			"***": "*",
+			"**/**": "**",
+			"**/**/**": "**"
+		},
+		CHAR_0: 48,
+		CHAR_9: 57,
+		CHAR_UPPERCASE_A: 65,
+		CHAR_LOWERCASE_A: 97,
+		CHAR_UPPERCASE_Z: 90,
+		CHAR_LOWERCASE_Z: 122,
+		CHAR_LEFT_PARENTHESES: 40,
+		CHAR_RIGHT_PARENTHESES: 41,
+		CHAR_ASTERISK: 42,
+		CHAR_AMPERSAND: 38,
+		CHAR_AT: 64,
+		CHAR_BACKWARD_SLASH: 92,
+		CHAR_CARRIAGE_RETURN: 13,
+		CHAR_CIRCUMFLEX_ACCENT: 94,
+		CHAR_COLON: 58,
+		CHAR_COMMA: 44,
+		CHAR_DOT: 46,
+		CHAR_DOUBLE_QUOTE: 34,
+		CHAR_EQUAL: 61,
+		CHAR_EXCLAMATION_MARK: 33,
+		CHAR_FORM_FEED: 12,
+		CHAR_FORWARD_SLASH: 47,
+		CHAR_GRAVE_ACCENT: 96,
+		CHAR_HASH: 35,
+		CHAR_HYPHEN_MINUS: 45,
+		CHAR_LEFT_ANGLE_BRACKET: 60,
+		CHAR_LEFT_CURLY_BRACE: 123,
+		CHAR_LEFT_SQUARE_BRACKET: 91,
+		CHAR_LINE_FEED: 10,
+		CHAR_NO_BREAK_SPACE: 160,
+		CHAR_PERCENT: 37,
+		CHAR_PLUS: 43,
+		CHAR_QUESTION_MARK: 63,
+		CHAR_RIGHT_ANGLE_BRACKET: 62,
+		CHAR_RIGHT_CURLY_BRACE: 125,
+		CHAR_RIGHT_SQUARE_BRACKET: 93,
+		CHAR_SEMICOLON: 59,
+		CHAR_SINGLE_QUOTE: 39,
+		CHAR_SPACE: 32,
+		CHAR_TAB: 9,
+		CHAR_UNDERSCORE: 95,
+		CHAR_VERTICAL_LINE: 124,
+		CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+		extglobChars(chars) {
+			return {
+				"!": {
+					type: "negate",
+					open: "(?:(?!(?:",
+					close: `))${chars.STAR})`
+				},
+				"?": {
+					type: "qmark",
+					open: "(?:",
+					close: ")?"
+				},
+				"+": {
+					type: "plus",
+					open: "(?:",
+					close: ")+"
+				},
+				"*": {
+					type: "star",
+					open: "(?:",
+					close: ")*"
+				},
+				"@": {
+					type: "at",
+					open: "(?:",
+					close: ")"
+				}
+			};
+		},
+		globChars(win32) {
+			return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+		}
+	};
+}));
+
+//#endregion
+//#region node_modules/picomatch/lib/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
+	const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = require_constants();
+	exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+	exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+	exports.isRegexChar = (str) => str.length === 1 && exports.hasRegexChars(str);
+	exports.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+	exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+	exports.isWindows = () => {
+		if (typeof navigator !== "undefined" && navigator.platform) {
+			const platform = navigator.platform.toLowerCase();
+			return platform === "win32" || platform === "windows";
+		}
+		if (typeof process !== "undefined" && process.platform) {
+			return process.platform === "win32";
+		}
+		return false;
+	};
+	exports.removeBackslashes = (str) => {
+		return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+			return match === "\\" ? "" : match;
+		});
+	};
+	exports.escapeLast = (input, char, lastIdx) => {
+		const idx = input.lastIndexOf(char, lastIdx);
+		if (idx === -1) return input;
+		if (input[idx - 1] === "\\") return exports.escapeLast(input, char, idx - 1);
+		return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+	};
+	exports.removePrefix = (input, state = {}) => {
+		let output = input;
+		if (output.startsWith("./")) {
+			output = output.slice(2);
+			state.prefix = "./";
+		}
+		return output;
+	};
+	exports.wrapOutput = (input, state = {}, options = {}) => {
+		const prepend = options.contains ? "" : "^";
+		const append = options.contains ? "" : "$";
+		let output = `${prepend}(?:${input})${append}`;
+		if (state.negated === true) {
+			output = `(?:^(?!${output}).*$)`;
+		}
+		return output;
+	};
+	exports.basename = (path, { windows } = {}) => {
+		const segs = path.split(windows ? /[\\/]/ : "/");
+		const last = segs[segs.length - 1];
+		if (last === "") {
+			return segs[segs.length - 2];
+		}
+		return last;
+	};
+}));
+
+//#endregion
+//#region node_modules/picomatch/lib/scan.js
+var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const utils$3 = require_utils();
+	const { CHAR_ASTERISK, CHAR_AT, CHAR_BACKWARD_SLASH, CHAR_COMMA, CHAR_DOT, CHAR_EXCLAMATION_MARK, CHAR_FORWARD_SLASH, CHAR_LEFT_CURLY_BRACE, CHAR_LEFT_PARENTHESES, CHAR_LEFT_SQUARE_BRACKET, CHAR_PLUS, CHAR_QUESTION_MARK, CHAR_RIGHT_CURLY_BRACE, CHAR_RIGHT_PARENTHESES, CHAR_RIGHT_SQUARE_BRACKET } = require_constants();
+	const isPathSeparator = (code) => {
+		return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+	};
+	const depth = (token) => {
+		if (token.isPrefix !== true) {
+			token.depth = token.isGlobstar ? Infinity : 1;
+		}
+	};
+	/**
+	* Quickly scans a glob pattern and returns an object with a handful of
+	* useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+	* `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+	* with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+	*
+	* ```js
+	* const pm = require('picomatch');
+	* console.log(pm.scan('foo/bar/*.js'));
+	* { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+	* ```
+	* @param {String} `str`
+	* @param {Object} `options`
+	* @return {Object} Returns an object with tokens and regex source string.
+	* @api public
+	*/
+	const scan$1 = (input, options) => {
+		const opts = options || {};
+		const length = input.length - 1;
+		const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+		const slashes = [];
+		const tokens = [];
+		const parts = [];
+		let str = input;
+		let index = -1;
+		let start = 0;
+		let lastIndex = 0;
+		let isBrace = false;
+		let isBracket = false;
+		let isGlob = false;
+		let isExtglob = false;
+		let isGlobstar = false;
+		let braceEscaped = false;
+		let backslashes = false;
+		let negated = false;
+		let negatedExtglob = false;
+		let finished = false;
+		let braces = 0;
+		let prev;
+		let code;
+		let token = {
+			value: "",
+			depth: 0,
+			isGlob: false
+		};
+		const eos = () => index >= length;
+		const peek = () => str.charCodeAt(index + 1);
+		const advance = () => {
+			prev = code;
+			return str.charCodeAt(++index);
+		};
+		while (index < length) {
+			code = advance();
+			let next;
+			if (code === CHAR_BACKWARD_SLASH) {
+				backslashes = token.backslashes = true;
+				code = advance();
+				if (code === CHAR_LEFT_CURLY_BRACE) {
+					braceEscaped = true;
+				}
+				continue;
+			}
+			if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+				braces++;
+				while (eos() !== true && (code = advance())) {
+					if (code === CHAR_BACKWARD_SLASH) {
+						backslashes = token.backslashes = true;
+						advance();
+						continue;
+					}
+					if (code === CHAR_LEFT_CURLY_BRACE) {
+						braces++;
+						continue;
+					}
+					if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+						isBrace = token.isBrace = true;
+						isGlob = token.isGlob = true;
+						finished = true;
+						if (scanToEnd === true) {
+							continue;
+						}
+						break;
+					}
+					if (braceEscaped !== true && code === CHAR_COMMA) {
+						isBrace = token.isBrace = true;
+						isGlob = token.isGlob = true;
+						finished = true;
+						if (scanToEnd === true) {
+							continue;
+						}
+						break;
+					}
+					if (code === CHAR_RIGHT_CURLY_BRACE) {
+						braces--;
+						if (braces === 0) {
+							braceEscaped = false;
+							isBrace = token.isBrace = true;
+							finished = true;
+							break;
+						}
+					}
+				}
+				if (scanToEnd === true) {
+					continue;
+				}
+				break;
+			}
+			if (code === CHAR_FORWARD_SLASH) {
+				slashes.push(index);
+				tokens.push(token);
+				token = {
+					value: "",
+					depth: 0,
+					isGlob: false
+				};
+				if (finished === true) continue;
+				if (prev === CHAR_DOT && index === start + 1) {
+					start += 2;
+					continue;
+				}
+				lastIndex = index + 1;
+				continue;
+			}
+			if (opts.noext !== true) {
+				const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
+				if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+					isGlob = token.isGlob = true;
+					isExtglob = token.isExtglob = true;
+					finished = true;
+					if (code === CHAR_EXCLAMATION_MARK && index === start) {
+						negatedExtglob = true;
+					}
+					if (scanToEnd === true) {
+						while (eos() !== true && (code = advance())) {
+							if (code === CHAR_BACKWARD_SLASH) {
+								backslashes = token.backslashes = true;
+								code = advance();
+								continue;
+							}
+							if (code === CHAR_RIGHT_PARENTHESES) {
+								isGlob = token.isGlob = true;
+								finished = true;
+								break;
+							}
+						}
+						continue;
+					}
+					break;
+				}
+			}
+			if (code === CHAR_ASTERISK) {
+				if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+				isGlob = token.isGlob = true;
+				finished = true;
+				if (scanToEnd === true) {
+					continue;
+				}
+				break;
+			}
+			if (code === CHAR_QUESTION_MARK) {
+				isGlob = token.isGlob = true;
+				finished = true;
+				if (scanToEnd === true) {
+					continue;
+				}
+				break;
+			}
+			if (code === CHAR_LEFT_SQUARE_BRACKET) {
+				while (eos() !== true && (next = advance())) {
+					if (next === CHAR_BACKWARD_SLASH) {
+						backslashes = token.backslashes = true;
+						advance();
+						continue;
+					}
+					if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+						isBracket = token.isBracket = true;
+						isGlob = token.isGlob = true;
+						finished = true;
+						break;
+					}
+				}
+				if (scanToEnd === true) {
+					continue;
+				}
+				break;
+			}
+			if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+				negated = token.negated = true;
+				start++;
+				continue;
+			}
+			if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+				isGlob = token.isGlob = true;
+				if (scanToEnd === true) {
+					while (eos() !== true && (code = advance())) {
+						if (code === CHAR_LEFT_PARENTHESES) {
+							backslashes = token.backslashes = true;
+							code = advance();
+							continue;
+						}
+						if (code === CHAR_RIGHT_PARENTHESES) {
+							finished = true;
+							break;
+						}
+					}
+					continue;
+				}
+				break;
+			}
+			if (isGlob === true) {
+				finished = true;
+				if (scanToEnd === true) {
+					continue;
+				}
+				break;
+			}
+		}
+		if (opts.noext === true) {
+			isExtglob = false;
+			isGlob = false;
+		}
+		let base = str;
+		let prefix = "";
+		let glob = "";
+		if (start > 0) {
+			prefix = str.slice(0, start);
+			str = str.slice(start);
+			lastIndex -= start;
+		}
+		if (base && isGlob === true && lastIndex > 0) {
+			base = str.slice(0, lastIndex);
+			glob = str.slice(lastIndex);
+		} else if (isGlob === true) {
+			base = "";
+			glob = str;
+		} else {
+			base = str;
+		}
+		if (base && base !== "" && base !== "/" && base !== str) {
+			if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+				base = base.slice(0, -1);
+			}
+		}
+		if (opts.unescape === true) {
+			if (glob) glob = utils$3.removeBackslashes(glob);
+			if (base && backslashes === true) {
+				base = utils$3.removeBackslashes(base);
+			}
+		}
+		const state = {
+			prefix,
+			input,
+			start,
+			base,
+			glob,
+			isBrace,
+			isBracket,
+			isGlob,
+			isExtglob,
+			isGlobstar,
+			negated,
+			negatedExtglob
+		};
+		if (opts.tokens === true) {
+			state.maxDepth = 0;
+			if (!isPathSeparator(code)) {
+				tokens.push(token);
+			}
+			state.tokens = tokens;
+		}
+		if (opts.parts === true || opts.tokens === true) {
+			let prevIndex;
+			for (let idx = 0; idx < slashes.length; idx++) {
+				const n = prevIndex ? prevIndex + 1 : start;
+				const i = slashes[idx];
+				const value = input.slice(n, i);
+				if (opts.tokens) {
+					if (idx === 0 && start !== 0) {
+						tokens[idx].isPrefix = true;
+						tokens[idx].value = prefix;
+					} else {
+						tokens[idx].value = value;
+					}
+					depth(tokens[idx]);
+					state.maxDepth += tokens[idx].depth;
+				}
+				if (idx !== 0 || value !== "") {
+					parts.push(value);
+				}
+				prevIndex = i;
+			}
+			if (prevIndex && prevIndex + 1 < input.length) {
+				const value = input.slice(prevIndex + 1);
+				parts.push(value);
+				if (opts.tokens) {
+					tokens[tokens.length - 1].value = value;
+					depth(tokens[tokens.length - 1]);
+					state.maxDepth += tokens[tokens.length - 1].depth;
+				}
+			}
+			state.slashes = slashes;
+			state.parts = parts;
+		}
+		return state;
+	};
+	module.exports = scan$1;
+}));
+
+//#endregion
+//#region node_modules/picomatch/lib/parse.js
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const constants$1 = require_constants();
+	const utils$2 = require_utils();
+	/**
+	* Constants
+	*/
+	const { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants$1;
+	/**
+	* Helpers
+	*/
+	const expandRange = (args, options) => {
+		if (typeof options.expandRange === "function") {
+			return options.expandRange(...args, options);
+		}
+		args.sort();
+		const value = `[${args.join("-")}]`;
+		try {
+			new RegExp(value);
+		} catch (ex) {
+			return args.map((v) => utils$2.escapeRegex(v)).join("..");
+		}
+		return value;
+	};
+	/**
+	* Create the message for a syntax error
+	*/
+	const syntaxError = (type, char) => {
+		return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+	};
+	/**
+	* Parse the given input string.
+	* @param {String} input
+	* @param {Object} options
+	* @return {Object}
+	*/
+	const parse$2 = (input, options) => {
+		if (typeof input !== "string") {
+			throw new TypeError("Expected a string");
+		}
+		input = REPLACEMENTS[input] || input;
+		const opts = { ...options };
+		const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+		let len = input.length;
+		if (len > max) {
+			throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+		}
+		const bos = {
+			type: "bos",
+			value: "",
+			output: opts.prepend || ""
+		};
+		const tokens = [bos];
+		const capture = opts.capture ? "" : "?:";
+		const PLATFORM_CHARS = constants$1.globChars(opts.windows);
+		const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);
+		const { DOT_LITERAL: DOT_LITERAL$1, PLUS_LITERAL: PLUS_LITERAL$1, SLASH_LITERAL: SLASH_LITERAL$1, ONE_CHAR: ONE_CHAR$1, DOTS_SLASH: DOTS_SLASH$1, NO_DOT: NO_DOT$1, NO_DOT_SLASH: NO_DOT_SLASH$1, NO_DOTS_SLASH: NO_DOTS_SLASH$1, QMARK: QMARK$1, QMARK_NO_DOT: QMARK_NO_DOT$1, STAR: STAR$1, START_ANCHOR: START_ANCHOR$1 } = PLATFORM_CHARS;
+		const globstar = (opts$1) => {
+			return `(${capture}(?:(?!${START_ANCHOR$1}${opts$1.dot ? DOTS_SLASH$1 : DOT_LITERAL$1}).)*?)`;
+		};
+		const nodot = opts.dot ? "" : NO_DOT$1;
+		const qmarkNoDot = opts.dot ? QMARK$1 : QMARK_NO_DOT$1;
+		let star = opts.bash === true ? globstar(opts) : STAR$1;
+		if (opts.capture) {
+			star = `(${star})`;
+		}
+		if (typeof opts.noext === "boolean") {
+			opts.noextglob = opts.noext;
+		}
+		const state = {
+			input,
+			index: -1,
+			start: 0,
+			dot: opts.dot === true,
+			consumed: "",
+			output: "",
+			prefix: "",
+			backtrack: false,
+			negated: false,
+			brackets: 0,
+			braces: 0,
+			parens: 0,
+			quotes: 0,
+			globstar: false,
+			tokens
+		};
+		input = utils$2.removePrefix(input, state);
+		len = input.length;
+		const extglobs = [];
+		const braces = [];
+		const stack = [];
+		let prev = bos;
+		let value;
+		/**
+		* Tokenizing helpers
+		*/
+		const eos = () => state.index === len - 1;
+		const peek = state.peek = (n = 1) => input[state.index + n];
+		const advance = state.advance = () => input[++state.index] || "";
+		const remaining = () => input.slice(state.index + 1);
+		const consume = (value$1 = "", num = 0) => {
+			state.consumed += value$1;
+			state.index += num;
+		};
+		const append = (token) => {
+			state.output += token.output != null ? token.output : token.value;
+			consume(token.value);
+		};
+		const negate = () => {
+			let count = 1;
+			while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
+				advance();
+				state.start++;
+				count++;
+			}
+			if (count % 2 === 0) {
+				return false;
+			}
+			state.negated = true;
+			state.start++;
+			return true;
+		};
+		const increment = (type) => {
+			state[type]++;
+			stack.push(type);
+		};
+		const decrement = (type) => {
+			state[type]--;
+			stack.pop();
+		};
+		/**
+		* Push tokens onto the tokens array. This helper speeds up
+		* tokenizing by 1) helping us avoid backtracking as much as possible,
+		* and 2) helping us avoid creating extra tokens when consecutive
+		* characters are plain text. This improves performance and simplifies
+		* lookbehinds.
+		*/
+		const push = (tok) => {
+			if (prev.type === "globstar") {
+				const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+				const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
+				if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
+					state.output = state.output.slice(0, -prev.output.length);
+					prev.type = "star";
+					prev.value = "*";
+					prev.output = star;
+					state.output += prev.output;
+				}
+			}
+			if (extglobs.length && tok.type !== "paren") {
+				extglobs[extglobs.length - 1].inner += tok.value;
+			}
+			if (tok.value || tok.output) append(tok);
+			if (prev && prev.type === "text" && tok.type === "text") {
+				prev.output = (prev.output || prev.value) + tok.value;
+				prev.value += tok.value;
+				return;
+			}
+			tok.prev = prev;
+			tokens.push(tok);
+			prev = tok;
+		};
+		const extglobOpen = (type, value$1) => {
+			const token = {
+				...EXTGLOB_CHARS[value$1],
+				conditions: 1,
+				inner: ""
+			};
+			token.prev = prev;
+			token.parens = state.parens;
+			token.output = state.output;
+			const output = (opts.capture ? "(" : "") + token.open;
+			increment("parens");
+			push({
+				type,
+				value: value$1,
+				output: state.output ? "" : ONE_CHAR$1
+			});
+			push({
+				type: "paren",
+				extglob: true,
+				value: advance(),
+				output
+			});
+			extglobs.push(token);
+		};
+		const extglobClose = (token) => {
+			let output = token.close + (opts.capture ? ")" : "");
+			let rest;
+			if (token.type === "negate") {
+				let extglobStar = star;
+				if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
+					extglobStar = globstar(opts);
+				}
+				if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+					output = token.close = `)$))${extglobStar}`;
+				}
+				if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+					const expression = parse$2(rest, {
+						...options,
+						fastpaths: false
+					}).output;
+					output = token.close = `)${expression})${extglobStar})`;
+				}
+				if (token.prev.type === "bos") {
+					state.negatedExtglob = true;
+				}
+			}
+			push({
+				type: "paren",
+				extglob: true,
+				value,
+				output
+			});
+			decrement("parens");
+		};
+		/**
+		* Fast paths
+		*/
+		if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+			let backslashes = false;
+			let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+				if (first === "\\") {
+					backslashes = true;
+					return m;
+				}
+				if (first === "?") {
+					if (esc) {
+						return esc + first + (rest ? QMARK$1.repeat(rest.length) : "");
+					}
+					if (index === 0) {
+						return qmarkNoDot + (rest ? QMARK$1.repeat(rest.length) : "");
+					}
+					return QMARK$1.repeat(chars.length);
+				}
+				if (first === ".") {
+					return DOT_LITERAL$1.repeat(chars.length);
+				}
+				if (first === "*") {
+					if (esc) {
+						return esc + first + (rest ? star : "");
+					}
+					return star;
+				}
+				return esc ? m : `\\${m}`;
+			});
+			if (backslashes === true) {
+				if (opts.unescape === true) {
+					output = output.replace(/\\/g, "");
+				} else {
+					output = output.replace(/\\+/g, (m) => {
+						return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+					});
+				}
+			}
+			if (output === input && opts.contains === true) {
+				state.output = input;
+				return state;
+			}
+			state.output = utils$2.wrapOutput(output, state, options);
+			return state;
+		}
+		/**
+		* Tokenize input until we reach end-of-string
+		*/
+		while (!eos()) {
+			value = advance();
+			if (value === "\0") {
+				continue;
+			}
+			/**
+			* Escaped characters
+			*/
+			if (value === "\\") {
+				const next = peek();
+				if (next === "/" && opts.bash !== true) {
+					continue;
+				}
+				if (next === "." || next === ";") {
+					continue;
+				}
+				if (!next) {
+					value += "\\";
+					push({
+						type: "text",
+						value
+					});
+					continue;
+				}
+				const match = /^\\+/.exec(remaining());
+				let slashes = 0;
+				if (match && match[0].length > 2) {
+					slashes = match[0].length;
+					state.index += slashes;
+					if (slashes % 2 !== 0) {
+						value += "\\";
+					}
+				}
+				if (opts.unescape === true) {
+					value = advance();
+				} else {
+					value += advance();
+				}
+				if (state.brackets === 0) {
+					push({
+						type: "text",
+						value
+					});
+					continue;
+				}
+			}
+			/**
+			* If we're inside a regex character class, continue
+			* until we reach the closing bracket.
+			*/
+			if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+				if (opts.posix !== false && value === ":") {
+					const inner = prev.value.slice(1);
+					if (inner.includes("[")) {
+						prev.posix = true;
+						if (inner.includes(":")) {
+							const idx = prev.value.lastIndexOf("[");
+							const pre = prev.value.slice(0, idx);
+							const rest$1 = prev.value.slice(idx + 2);
+							const posix = POSIX_REGEX_SOURCE[rest$1];
+							if (posix) {
+								prev.value = pre + posix;
+								state.backtrack = true;
+								advance();
+								if (!bos.output && tokens.indexOf(prev) === 1) {
+									bos.output = ONE_CHAR$1;
+								}
+								continue;
+							}
+						}
+					}
+				}
+				if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") {
+					value = `\\${value}`;
+				}
+				if (value === "]" && (prev.value === "[" || prev.value === "[^")) {
+					value = `\\${value}`;
+				}
+				if (opts.posix === true && value === "!" && prev.value === "[") {
+					value = "^";
+				}
+				prev.value += value;
+				append({ value });
+				continue;
+			}
+			/**
+			* If we're inside a quoted string, continue
+			* until we reach the closing double quote.
+			*/
+			if (state.quotes === 1 && value !== "\"") {
+				value = utils$2.escapeRegex(value);
+				prev.value += value;
+				append({ value });
+				continue;
+			}
+			/**
+			* Double quotes
+			*/
+			if (value === "\"") {
+				state.quotes = state.quotes === 1 ? 0 : 1;
+				if (opts.keepQuotes === true) {
+					push({
+						type: "text",
+						value
+					});
+				}
+				continue;
+			}
+			/**
+			* Parentheses
+			*/
+			if (value === "(") {
+				increment("parens");
+				push({
+					type: "paren",
+					value
+				});
+				continue;
+			}
+			if (value === ")") {
+				if (state.parens === 0 && opts.strictBrackets === true) {
+					throw new SyntaxError(syntaxError("opening", "("));
+				}
+				const extglob = extglobs[extglobs.length - 1];
+				if (extglob && state.parens === extglob.parens + 1) {
+					extglobClose(extglobs.pop());
+					continue;
+				}
+				push({
+					type: "paren",
+					value,
+					output: state.parens ? ")" : "\\)"
+				});
+				decrement("parens");
+				continue;
+			}
+			/**
+			* Square brackets
+			*/
+			if (value === "[") {
+				if (opts.nobracket === true || !remaining().includes("]")) {
+					if (opts.nobracket !== true && opts.strictBrackets === true) {
+						throw new SyntaxError(syntaxError("closing", "]"));
+					}
+					value = `\\${value}`;
+				} else {
+					increment("brackets");
+				}
+				push({
+					type: "bracket",
+					value
+				});
+				continue;
+			}
+			if (value === "]") {
+				if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+					push({
+						type: "text",
+						value,
+						output: `\\${value}`
+					});
+					continue;
+				}
+				if (state.brackets === 0) {
+					if (opts.strictBrackets === true) {
+						throw new SyntaxError(syntaxError("opening", "["));
+					}
+					push({
+						type: "text",
+						value,
+						output: `\\${value}`
+					});
+					continue;
+				}
+				decrement("brackets");
+				const prevValue = prev.value.slice(1);
+				if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) {
+					value = `/${value}`;
+				}
+				prev.value += value;
+				append({ value });
+				if (opts.literalBrackets === false || utils$2.hasRegexChars(prevValue)) {
+					continue;
+				}
+				const escaped = utils$2.escapeRegex(prev.value);
+				state.output = state.output.slice(0, -prev.value.length);
+				if (opts.literalBrackets === true) {
+					state.output += escaped;
+					prev.value = escaped;
+					continue;
+				}
+				prev.value = `(${capture}${escaped}|${prev.value})`;
+				state.output += prev.value;
+				continue;
+			}
+			/**
+			* Braces
+			*/
+			if (value === "{" && opts.nobrace !== true) {
+				increment("braces");
+				const open = {
+					type: "brace",
+					value,
+					output: "(",
+					outputIndex: state.output.length,
+					tokensIndex: state.tokens.length
+				};
+				braces.push(open);
+				push(open);
+				continue;
+			}
+			if (value === "}") {
+				const brace = braces[braces.length - 1];
+				if (opts.nobrace === true || !brace) {
+					push({
+						type: "text",
+						value,
+						output: value
+					});
+					continue;
+				}
+				let output = ")";
+				if (brace.dots === true) {
+					const arr = tokens.slice();
+					const range = [];
+					for (let i = arr.length - 1; i >= 0; i--) {
+						tokens.pop();
+						if (arr[i].type === "brace") {
+							break;
+						}
+						if (arr[i].type !== "dots") {
+							range.unshift(arr[i].value);
+						}
+					}
+					output = expandRange(range, opts);
+					state.backtrack = true;
+				}
+				if (brace.comma !== true && brace.dots !== true) {
+					const out = state.output.slice(0, brace.outputIndex);
+					const toks = state.tokens.slice(brace.tokensIndex);
+					brace.value = brace.output = "\\{";
+					value = output = "\\}";
+					state.output = out;
+					for (const t of toks) {
+						state.output += t.output || t.value;
+					}
+				}
+				push({
+					type: "brace",
+					value,
+					output
+				});
+				decrement("braces");
+				braces.pop();
+				continue;
+			}
+			/**
+			* Pipes
+			*/
+			if (value === "|") {
+				if (extglobs.length > 0) {
+					extglobs[extglobs.length - 1].conditions++;
+				}
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Commas
+			*/
+			if (value === ",") {
+				let output = value;
+				const brace = braces[braces.length - 1];
+				if (brace && stack[stack.length - 1] === "braces") {
+					brace.comma = true;
+					output = "|";
+				}
+				push({
+					type: "comma",
+					value,
+					output
+				});
+				continue;
+			}
+			/**
+			* Slashes
+			*/
+			if (value === "/") {
+				if (prev.type === "dot" && state.index === state.start + 1) {
+					state.start = state.index + 1;
+					state.consumed = "";
+					state.output = "";
+					tokens.pop();
+					prev = bos;
+					continue;
+				}
+				push({
+					type: "slash",
+					value,
+					output: SLASH_LITERAL$1
+				});
+				continue;
+			}
+			/**
+			* Dots
+			*/
+			if (value === ".") {
+				if (state.braces > 0 && prev.type === "dot") {
+					if (prev.value === ".") prev.output = DOT_LITERAL$1;
+					const brace = braces[braces.length - 1];
+					prev.type = "dots";
+					prev.output += value;
+					prev.value += value;
+					brace.dots = true;
+					continue;
+				}
+				if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+					push({
+						type: "text",
+						value,
+						output: DOT_LITERAL$1
+					});
+					continue;
+				}
+				push({
+					type: "dot",
+					value,
+					output: DOT_LITERAL$1
+				});
+				continue;
+			}
+			/**
+			* Question marks
+			*/
+			if (value === "?") {
+				const isGroup = prev && prev.value === "(";
+				if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+					extglobOpen("qmark", value);
+					continue;
+				}
+				if (prev && prev.type === "paren") {
+					const next = peek();
+					let output = value;
+					if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) {
+						output = `\\${value}`;
+					}
+					push({
+						type: "text",
+						value,
+						output
+					});
+					continue;
+				}
+				if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+					push({
+						type: "qmark",
+						value,
+						output: QMARK_NO_DOT$1
+					});
+					continue;
+				}
+				push({
+					type: "qmark",
+					value,
+					output: QMARK$1
+				});
+				continue;
+			}
+			/**
+			* Exclamation
+			*/
+			if (value === "!") {
+				if (opts.noextglob !== true && peek() === "(") {
+					if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
+						extglobOpen("negate", value);
+						continue;
+					}
+				}
+				if (opts.nonegate !== true && state.index === 0) {
+					negate();
+					continue;
+				}
+			}
+			/**
+			* Plus
+			*/
+			if (value === "+") {
+				if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+					extglobOpen("plus", value);
+					continue;
+				}
+				if (prev && prev.value === "(" || opts.regex === false) {
+					push({
+						type: "plus",
+						value,
+						output: PLUS_LITERAL$1
+					});
+					continue;
+				}
+				if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
+					push({
+						type: "plus",
+						value
+					});
+					continue;
+				}
+				push({
+					type: "plus",
+					value: PLUS_LITERAL$1
+				});
+				continue;
+			}
+			/**
+			* Plain text
+			*/
+			if (value === "@") {
+				if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+					push({
+						type: "at",
+						extglob: true,
+						value,
+						output: ""
+					});
+					continue;
+				}
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Plain text
+			*/
+			if (value !== "*") {
+				if (value === "$" || value === "^") {
+					value = `\\${value}`;
+				}
+				const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+				if (match) {
+					value += match[0];
+					state.index += match[0].length;
+				}
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Stars
+			*/
+			if (prev && (prev.type === "globstar" || prev.star === true)) {
+				prev.type = "star";
+				prev.star = true;
+				prev.value += value;
+				prev.output = star;
+				state.backtrack = true;
+				state.globstar = true;
+				consume(value);
+				continue;
+			}
+			let rest = remaining();
+			if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+				extglobOpen("star", value);
+				continue;
+			}
+			if (prev.type === "star") {
+				if (opts.noglobstar === true) {
+					consume(value);
+					continue;
+				}
+				const prior = prev.prev;
+				const before = prior.prev;
+				const isStart = prior.type === "slash" || prior.type === "bos";
+				const afterStar = before && (before.type === "star" || before.type === "globstar");
+				if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+					push({
+						type: "star",
+						value,
+						output: ""
+					});
+					continue;
+				}
+				const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+				const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
+				if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
+					push({
+						type: "star",
+						value,
+						output: ""
+					});
+					continue;
+				}
+				while (rest.slice(0, 3) === "/**") {
+					const after = input[state.index + 4];
+					if (after && after !== "/") {
+						break;
+					}
+					rest = rest.slice(3);
+					consume("/**", 3);
+				}
+				if (prior.type === "bos" && eos()) {
+					prev.type = "globstar";
+					prev.value += value;
+					prev.output = globstar(opts);
+					state.output = prev.output;
+					state.globstar = true;
+					consume(value);
+					continue;
+				}
+				if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+					state.output = state.output.slice(0, -(prior.output + prev.output).length);
+					prior.output = `(?:${prior.output}`;
+					prev.type = "globstar";
+					prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+					prev.value += value;
+					state.globstar = true;
+					state.output += prior.output + prev.output;
+					consume(value);
+					continue;
+				}
+				if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
+					const end = rest[1] !== void 0 ? "|$" : "";
+					state.output = state.output.slice(0, -(prior.output + prev.output).length);
+					prior.output = `(?:${prior.output}`;
+					prev.type = "globstar";
+					prev.output = `${globstar(opts)}${SLASH_LITERAL$1}|${SLASH_LITERAL$1}${end})`;
+					prev.value += value;
+					state.output += prior.output + prev.output;
+					state.globstar = true;
+					consume(value + advance());
+					push({
+						type: "slash",
+						value: "/",
+						output: ""
+					});
+					continue;
+				}
+				if (prior.type === "bos" && rest[0] === "/") {
+					prev.type = "globstar";
+					prev.value += value;
+					prev.output = `(?:^|${SLASH_LITERAL$1}|${globstar(opts)}${SLASH_LITERAL$1})`;
+					state.output = prev.output;
+					state.globstar = true;
+					consume(value + advance());
+					push({
+						type: "slash",
+						value: "/",
+						output: ""
+					});
+					continue;
+				}
+				state.output = state.output.slice(0, -prev.output.length);
+				prev.type = "globstar";
+				prev.output = globstar(opts);
+				prev.value += value;
+				state.output += prev.output;
+				state.globstar = true;
+				consume(value);
+				continue;
+			}
+			const token = {
+				type: "star",
+				value,
+				output: star
+			};
+			if (opts.bash === true) {
+				token.output = ".*?";
+				if (prev.type === "bos" || prev.type === "slash") {
+					token.output = nodot + token.output;
+				}
+				push(token);
+				continue;
+			}
+			if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+				token.output = value;
+				push(token);
+				continue;
+			}
+			if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+				if (prev.type === "dot") {
+					state.output += NO_DOT_SLASH$1;
+					prev.output += NO_DOT_SLASH$1;
+				} else if (opts.dot === true) {
+					state.output += NO_DOTS_SLASH$1;
+					prev.output += NO_DOTS_SLASH$1;
+				} else {
+					state.output += nodot;
+					prev.output += nodot;
+				}
+				if (peek() !== "*") {
+					state.output += ONE_CHAR$1;
+					prev.output += ONE_CHAR$1;
+				}
+			}
+			push(token);
+		}
+		while (state.brackets > 0) {
+			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+			state.output = utils$2.escapeLast(state.output, "[");
+			decrement("brackets");
+		}
+		while (state.parens > 0) {
+			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
+			state.output = utils$2.escapeLast(state.output, "(");
+			decrement("parens");
+		}
+		while (state.braces > 0) {
+			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
+			state.output = utils$2.escapeLast(state.output, "{");
+			decrement("braces");
+		}
+		if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
+			push({
+				type: "maybe_slash",
+				value: "",
+				output: `${SLASH_LITERAL$1}?`
+			});
+		}
+		if (state.backtrack === true) {
+			state.output = "";
+			for (const token of state.tokens) {
+				state.output += token.output != null ? token.output : token.value;
+				if (token.suffix) {
+					state.output += token.suffix;
+				}
+			}
+		}
+		return state;
+	};
+	/**
+	* Fast paths for creating regular expressions for common glob patterns.
+	* This can significantly speed up processing and has very little downside
+	* impact when none of the fast paths match.
+	*/
+	parse$2.fastpaths = (input, options) => {
+		const opts = { ...options };
+		const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+		const len = input.length;
+		if (len > max) {
+			throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+		}
+		input = REPLACEMENTS[input] || input;
+		const { DOT_LITERAL: DOT_LITERAL$1, SLASH_LITERAL: SLASH_LITERAL$1, ONE_CHAR: ONE_CHAR$1, DOTS_SLASH: DOTS_SLASH$1, NO_DOT: NO_DOT$1, NO_DOTS: NO_DOTS$1, NO_DOTS_SLASH: NO_DOTS_SLASH$1, STAR: STAR$1, START_ANCHOR: START_ANCHOR$1 } = constants$1.globChars(opts.windows);
+		const nodot = opts.dot ? NO_DOTS$1 : NO_DOT$1;
+		const slashDot = opts.dot ? NO_DOTS_SLASH$1 : NO_DOT$1;
+		const capture = opts.capture ? "" : "?:";
+		const state = {
+			negated: false,
+			prefix: ""
+		};
+		let star = opts.bash === true ? ".*?" : STAR$1;
+		if (opts.capture) {
+			star = `(${star})`;
+		}
+		const globstar = (opts$1) => {
+			if (opts$1.noglobstar === true) return star;
+			return `(${capture}(?:(?!${START_ANCHOR$1}${opts$1.dot ? DOTS_SLASH$1 : DOT_LITERAL$1}).)*?)`;
+		};
+		const create = (str) => {
+			switch (str) {
+				case "*": return `${nodot}${ONE_CHAR$1}${star}`;
+				case ".*": return `${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
+				case "*.*": return `${nodot}${star}${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
+				case "*/*": return `${nodot}${star}${SLASH_LITERAL$1}${ONE_CHAR$1}${slashDot}${star}`;
+				case "**": return nodot + globstar(opts);
+				case "**/*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL$1})?${slashDot}${ONE_CHAR$1}${star}`;
+				case "**/*.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL$1})?${slashDot}${star}${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
+				case "**/.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL$1})?${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
+				default: {
+					const match = /^(.*?)\.(\w+)$/.exec(str);
+					if (!match) return;
+					const source$1 = create(match[1]);
+					if (!source$1) return;
+					return source$1 + DOT_LITERAL$1 + match[2];
+				}
+			}
+		};
+		const output = utils$2.removePrefix(input, state);
+		let source = create(output);
+		if (source && opts.strictSlashes !== true) {
+			source += `${SLASH_LITERAL$1}?`;
+		}
+		return source;
+	};
+	module.exports = parse$2;
+}));
+
+//#endregion
+//#region node_modules/picomatch/lib/picomatch.js
+var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const scan = require_scan();
+	const parse$1 = require_parse();
+	const utils$1 = require_utils();
+	const constants = require_constants();
+	const isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
+	/**
+	* Creates a matcher function from one or more glob patterns. The
+	* returned function takes a string to match as its first argument,
+	* and returns true if the string is a match. The returned matcher
+	* function also takes a boolean as the second argument that, when true,
+	* returns an object with additional information.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch(glob[, options]);
+	*
+	* const isMatch = picomatch('*.!(*a)');
+	* console.log(isMatch('a.a')); //=> false
+	* console.log(isMatch('a.b')); //=> true
+	* ```
+	* @name picomatch
+	* @param {String|Array} `globs` One or more glob patterns.
+	* @param {Object=} `options`
+	* @return {Function=} Returns a matcher function.
+	* @api public
+	*/
+	const picomatch$2 = (glob, options, returnState = false) => {
+		if (Array.isArray(glob)) {
+			const fns = glob.map((input) => picomatch$2(input, options, returnState));
+			const arrayMatcher = (str) => {
+				for (const isMatch of fns) {
+					const state$1 = isMatch(str);
+					if (state$1) return state$1;
+				}
+				return false;
+			};
+			return arrayMatcher;
+		}
+		const isState = isObject(glob) && glob.tokens && glob.input;
+		if (glob === "" || typeof glob !== "string" && !isState) {
+			throw new TypeError("Expected pattern to be a non-empty string");
+		}
+		const opts = options || {};
+		const posix = opts.windows;
+		const regex = isState ? picomatch$2.compileRe(glob, options) : picomatch$2.makeRe(glob, options, false, true);
+		const state = regex.state;
+		delete regex.state;
+		let isIgnored = () => false;
+		if (opts.ignore) {
+			const ignoreOpts = {
+				...options,
+				ignore: null,
+				onMatch: null,
+				onResult: null
+			};
+			isIgnored = picomatch$2(opts.ignore, ignoreOpts, returnState);
+		}
+		const matcher = (input, returnObject = false) => {
+			const { isMatch, match, output } = picomatch$2.test(input, regex, options, {
+				glob,
+				posix
+			});
+			const result = {
+				glob,
+				state,
+				regex,
+				posix,
+				input,
+				output,
+				match,
+				isMatch
+			};
+			if (typeof opts.onResult === "function") {
+				opts.onResult(result);
+			}
+			if (isMatch === false) {
+				result.isMatch = false;
+				return returnObject ? result : false;
+			}
+			if (isIgnored(input)) {
+				if (typeof opts.onIgnore === "function") {
+					opts.onIgnore(result);
+				}
+				result.isMatch = false;
+				return returnObject ? result : false;
+			}
+			if (typeof opts.onMatch === "function") {
+				opts.onMatch(result);
+			}
+			return returnObject ? result : true;
+		};
+		if (returnState) {
+			matcher.state = state;
+		}
+		return matcher;
+	};
+	/**
+	* Test `input` with the given `regex`. This is used by the main
+	* `picomatch()` function to test the input string.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.test(input, regex[, options]);
+	*
+	* console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+	* // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+	* ```
+	* @param {String} `input` String to test.
+	* @param {RegExp} `regex`
+	* @return {Object} Returns an object with matching info.
+	* @api public
+	*/
+	picomatch$2.test = (input, regex, options, { glob, posix } = {}) => {
+		if (typeof input !== "string") {
+			throw new TypeError("Expected input to be a string");
+		}
+		if (input === "") {
+			return {
+				isMatch: false,
+				output: ""
+			};
+		}
+		const opts = options || {};
+		const format = opts.format || (posix ? utils$1.toPosixSlashes : null);
+		let match = input === glob;
+		let output = match && format ? format(input) : input;
+		if (match === false) {
+			output = format ? format(input) : input;
+			match = output === glob;
+		}
+		if (match === false || opts.capture === true) {
+			if (opts.matchBase === true || opts.basename === true) {
+				match = picomatch$2.matchBase(input, regex, options, posix);
+			} else {
+				match = regex.exec(output);
+			}
+		}
+		return {
+			isMatch: Boolean(match),
+			match,
+			output
+		};
+	};
+	/**
+	* Match the basename of a filepath.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.matchBase(input, glob[, options]);
+	* console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+	* ```
+	* @param {String} `input` String to test.
+	* @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+	* @return {Boolean}
+	* @api public
+	*/
+	picomatch$2.matchBase = (input, glob, options) => {
+		const regex = glob instanceof RegExp ? glob : picomatch$2.makeRe(glob, options);
+		return regex.test(utils$1.basename(input));
+	};
+	/**
+	* Returns true if **any** of the given glob `patterns` match the specified `string`.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.isMatch(string, patterns[, options]);
+	*
+	* console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+	* console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+	* ```
+	* @param {String|Array} str The string to test.
+	* @param {String|Array} patterns One or more glob patterns to use for matching.
+	* @param {Object} [options] See available [options](#options).
+	* @return {Boolean} Returns true if any patterns match `str`
+	* @api public
+	*/
+	picomatch$2.isMatch = (str, patterns, options) => picomatch$2(patterns, options)(str);
+	/**
+	* Parse a glob pattern to create the source string for a regular
+	* expression.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* const result = picomatch.parse(pattern[, options]);
+	* ```
+	* @param {String} `pattern`
+	* @param {Object} `options`
+	* @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+	* @api public
+	*/
+	picomatch$2.parse = (pattern, options) => {
+		if (Array.isArray(pattern)) return pattern.map((p) => picomatch$2.parse(p, options));
+		return parse$1(pattern, {
+			...options,
+			fastpaths: false
+		});
+	};
+	/**
+	* Scan a glob pattern to separate the pattern into segments.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.scan(input[, options]);
+	*
+	* const result = picomatch.scan('!./foo/*.js');
+	* console.log(result);
+	* { prefix: '!./',
+	*   input: '!./foo/*.js',
+	*   start: 3,
+	*   base: 'foo',
+	*   glob: '*.js',
+	*   isBrace: false,
+	*   isBracket: false,
+	*   isGlob: true,
+	*   isExtglob: false,
+	*   isGlobstar: false,
+	*   negated: true }
+	* ```
+	* @param {String} `input` Glob pattern to scan.
+	* @param {Object} `options`
+	* @return {Object} Returns an object with
+	* @api public
+	*/
+	picomatch$2.scan = (input, options) => scan(input, options);
+	/**
+	* Compile a regular expression from the `state` object returned by the
+	* [parse()](#parse) method.
+	*
+	* @param {Object} `state`
+	* @param {Object} `options`
+	* @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+	* @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+	* @return {RegExp}
+	* @api public
+	*/
+	picomatch$2.compileRe = (state, options, returnOutput = false, returnState = false) => {
+		if (returnOutput === true) {
+			return state.output;
+		}
+		const opts = options || {};
+		const prepend = opts.contains ? "" : "^";
+		const append = opts.contains ? "" : "$";
+		let source = `${prepend}(?:${state.output})${append}`;
+		if (state && state.negated === true) {
+			source = `^(?!${source}).*$`;
+		}
+		const regex = picomatch$2.toRegex(source, options);
+		if (returnState === true) {
+			regex.state = state;
+		}
+		return regex;
+	};
+	/**
+	* Create a regular expression from a parsed glob pattern.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* const state = picomatch.parse('*.js');
+	* // picomatch.compileRe(state[, options]);
+	*
+	* console.log(picomatch.compileRe(state));
+	* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	* ```
+	* @param {String} `state` The object returned from the `.parse` method.
+	* @param {Object} `options`
+	* @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+	* @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+	* @return {RegExp} Returns a regex created from the given pattern.
+	* @api public
+	*/
+	picomatch$2.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+		if (!input || typeof input !== "string") {
+			throw new TypeError("Expected a non-empty string");
+		}
+		let parsed = {
+			negated: false,
+			fastpaths: true
+		};
+		if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
+			parsed.output = parse$1.fastpaths(input, options);
+		}
+		if (!parsed.output) {
+			parsed = parse$1(input, options);
+		}
+		return picomatch$2.compileRe(parsed, options, returnOutput, returnState);
+	};
+	/**
+	* Create a regular expression from the given regex source string.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.toRegex(source[, options]);
+	*
+	* const { output } = picomatch.parse('*.js');
+	* console.log(picomatch.toRegex(output));
+	* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	* ```
+	* @param {String} `source` Regular expression source string.
+	* @param {Object} `options`
+	* @return {RegExp}
+	* @api public
+	*/
+	picomatch$2.toRegex = (source, options) => {
+		try {
+			const opts = options || {};
+			return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
+		} catch (err$1) {
+			if (options && options.debug === true) throw err$1;
+			return /$^/;
+		}
+	};
+	/**
+	* Picomatch constants.
+	* @return {Object}
+	*/
+	picomatch$2.constants = constants;
+	/**
+	* Expose "picomatch"
+	*/
+	module.exports = picomatch$2;
+}));
+
+//#endregion
+//#region node_modules/picomatch/index.js
+var require_picomatch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const pico = require_picomatch$1();
+	const utils = require_utils();
+	function picomatch$1(glob, options, returnState = false) {
+		if (options && (options.windows === null || options.windows === undefined)) {
+			options = {
+				...options,
+				windows: utils.isWindows()
+			};
+		}
+		return pico(glob, options, returnState);
+	}
+	Object.assign(picomatch$1, pico);
+	module.exports = picomatch$1;
+}));
+
+//#endregion
+//#region packages/tools/src/codegen/type-filter.ts
+var import_picomatch = /* @__PURE__ */ __toESM(require_picomatch(), 1);
+const compileRule = (rule) => {
+	const matcher = (0, import_picomatch.default)(rule.pattern);
+	const categories = rule.category ? Array.isArray(rule.category) ? rule.category : [rule.category] : null;
+	return (context) => {
+		if (categories && !categories.includes(context.category)) {
+			return true;
+		}
+		return !matcher(context.name);
+	};
+};
+const compileTypeFilter = (config) => {
+	if (!config) {
+		return () => true;
+	}
+	if (typeof config === "function") {
+		return config;
+	}
+	const rules = config.exclude.map(compileRule);
+	return (context) => rules.every((rule) => rule(context));
+};
+const buildExclusionSet = (filter, typeNames) => {
+	const excluded = new Set();
+	for (const [category, names] of typeNames) {
+		for (const name of names) {
+			if (!filter({
+				name,
+				category
+			})) {
+				excluded.add(name);
+			}
+		}
+	}
+	return excluded;
+};
+
+//#endregion
+//#region packages/tools/src/codegen/generator.ts
+const builtinScalarTypes$1 = new Map([
+	["ID", {
+		input: "string",
+		output: "string"
+	}],
+	["String", {
+		input: "string",
+		output: "string"
+	}],
+	["Int", {
+		input: "number",
+		output: "number"
+	}],
+	["Float", {
+		input: "number",
+		output: "number"
+	}],
+	["Boolean", {
+		input: "boolean",
+		output: "boolean"
+	}]
+]);
+const collectTypeLevels = (type, nonNull = false, levels = []) => {
+	if (type.kind === Kind.NON_NULL_TYPE) {
+		return collectTypeLevels(type.type, true, levels);
+	}
+	if (type.kind === Kind.LIST_TYPE) {
+		levels.push({
+			kind: "list",
+			nonNull
+		});
+		return collectTypeLevels(type.type, false, levels);
+	}
+	levels.push({
+		kind: "named",
+		nonNull
+	});
+	return {
+		name: type.name.value,
+		levels
+	};
+};
+const buildTypeModifier = (levels) => {
+	let modifier = "?";
+	for (const level of levels.slice().reverse()) {
+		if (level.kind === "named") {
+			modifier = level.nonNull ? "!" : "?";
+			continue;
+		}
+		const listSuffix = level.nonNull ? "[]!" : "[]?";
+		modifier = `${modifier}${listSuffix}`;
+	}
+	return modifier;
+};
+const parseTypeReference = (type) => {
+	const { name, levels } = collectTypeLevels(type);
+	return {
+		name,
+		modifier: buildTypeModifier(levels)
+	};
+};
+const isScalarName$1 = (schema, name) => builtinScalarTypes$1.has(name) || schema.scalars.has(name);
+const isEnumName$1 = (schema, name) => schema.enums.has(name);
+const _isInputName = (schema, name) => schema.inputs.has(name);
+const isUnionName = (schema, name) => schema.unions.has(name);
+const isObjectName = (schema, name) => schema.objects.has(name);
+/**
+* Maps type kind to deferred specifier prefix character.
+*/
+const inputKindToChar = (kind) => {
+	switch (kind) {
+		case "scalar": return "s";
+		case "enum": return "e";
+		case "input": return "i";
+		case "excluded": return "x";
+	}
+};
+const renderInputRef = (schema, definition, excluded) => {
+	const { name, modifier } = parseTypeReference(definition.type);
+	const defaultValue = definition.defaultValue;
+	if (excluded.has(name)) {
+		const defaultSuffix$1 = defaultValue ? "|D" : "";
+		return `"x|${name}|${modifier}${defaultSuffix$1}"`;
+	}
+	let kind;
+	if (isScalarName$1(schema, name)) {
+		kind = "scalar";
+	} else if (isEnumName$1(schema, name)) {
+		kind = "enum";
+	} else {
+		kind = "input";
+	}
+	const kindChar = inputKindToChar(kind);
+	const defaultSuffix = defaultValue ? "|D" : "";
+	return `"${kindChar}|${name}|${modifier}${defaultSuffix}"`;
+};
+/**
+* Maps output type kind to deferred specifier prefix character.
+*/
+const outputKindToChar = (kind) => {
+	switch (kind) {
+		case "scalar": return "s";
+		case "enum": return "e";
+		case "object": return "o";
+		case "union": return "u";
+		case "excluded": return "x";
+	}
+};
+/**
+* Render arguments as object format for DeferredOutputFieldWithArgs.
+* Returns array of "argName: \"spec\"" entries.
+*/
+const renderArgumentsObjectEntries = (schema, args, excluded) => {
+	return [...args].sort((left, right) => left.name.value.localeCompare(right.name.value)).map((arg) => {
+		const { name, modifier } = parseTypeReference(arg.type);
+		if (excluded.has(name)) {
+			return null;
+		}
+		let kind;
+		if (isScalarName$1(schema, name)) {
+			kind = "scalar";
+		} else if (isEnumName$1(schema, name)) {
+			kind = "enum";
+		} else {
+			kind = "input";
+		}
+		const kindChar = inputKindToChar(kind);
+		const defaultSuffix = arg.defaultValue ? "|D" : "";
+		return `${arg.name.value}: "${kindChar}|${name}|${modifier}${defaultSuffix}"`;
+	}).filter((spec) => spec !== null);
+};
+const renderArgumentMap = (schema, args, excluded) => {
+	const entries = [...args ?? []].sort((left, right) => left.name.value.localeCompare(right.name.value)).map((arg) => `${arg.name.value}: ${renderInputRef(schema, arg, excluded)}`);
+	return renderPropertyLines({
+		entries,
+		indentSize: 8
+	});
+};
+const renderOutputRef = (schema, type, args, excluded) => {
+	const { name, modifier } = parseTypeReference(type);
+	if (excluded.has(name)) {
+		const argumentMap = renderArgumentMap(schema, args, excluded);
+		return `{ spec: "x|${name}|${modifier}", arguments: ${argumentMap} }`;
+	}
+	let kind;
+	if (isScalarName$1(schema, name)) {
+		kind = "scalar";
+	} else if (isEnumName$1(schema, name)) {
+		kind = "enum";
+	} else if (isUnionName(schema, name)) {
+		kind = "union";
+	} else if (isObjectName(schema, name)) {
+		kind = "object";
+	} else {
+		kind = "scalar";
+	}
+	const kindChar = outputKindToChar(kind);
+	const spec = `${kindChar}|${name}|${modifier}`;
+	if (args && args.length > 0) {
+		const argEntries = renderArgumentsObjectEntries(schema, args, excluded);
+		if (argEntries.length > 0) {
+			return `{ spec: "${spec}", arguments: { ${argEntries.join(", ")} } }`;
+		}
+	}
+	return `{ spec: "${spec}", arguments: {} }`;
+};
+const renderPropertyLines = ({ entries, indentSize }) => {
+	if (entries.length === 0) {
+		return "{}";
+	}
+	const indent = " ".repeat(indentSize);
+	const lastIndent = " ".repeat(indentSize - 2);
+	return [
+		"{",
+		`${indent}${entries.join(`,\n${indent}`)},`,
+		`${lastIndent}}`
+	].join(`\n`);
+};
+const renderObjectFields = (schema, fields, excluded) => {
+	const entries = Array.from(fields.values()).sort((left, right) => left.name.value.localeCompare(right.name.value)).map((field) => `${field.name.value}: ${renderOutputRef(schema, field.type, field.arguments, excluded)}`);
+	return renderPropertyLines({
+		entries,
+		indentSize: 6
+	});
+};
+const renderInputFields = (schema, fields, excluded) => {
+	const entries = Array.from(fields.values()).sort((left, right) => left.name.value.localeCompare(right.name.value)).map((field) => `${field.name.value}: ${renderInputRef(schema, field, excluded)}`);
+	return renderPropertyLines({
+		entries,
+		indentSize: 6
+	});
+};
+const renderScalarVar = (schemaName, record) => {
+	const typeInfo = builtinScalarTypes$1.get(record.name) ?? {
+		input: "string",
+		output: "string"
+	};
+	return `const scalar_${schemaName}_${record.name} = { name: "${record.name}", $type: {} as { input: ${typeInfo.input}; output: ${typeInfo.output}; inputProfile: { kind: "scalar"; name: "${record.name}"; value: ${typeInfo.input} }; outputProfile: { kind: "scalar"; name: "${record.name}"; value: ${typeInfo.output} } } } as const;`;
+};
+const renderEnumVar = (schemaName, record) => {
+	const valueNames = Array.from(record.values.values()).sort((left, right) => left.name.value.localeCompare(right.name.value)).map((value) => value.name.value);
+	const valuesObj = valueNames.length === 0 ? "{}" : `{ ${valueNames.map((v) => `${v}: true`).join(", ")} }`;
+	const valueUnion = valueNames.length === 0 ? "never" : valueNames.map((v) => `"${v}"`).join(" | ");
+	return `const enum_${schemaName}_${record.name} = defineEnum<"${record.name}", ${valueUnion}>("${record.name}", ${valuesObj});`;
+};
+const renderInputVar = (schemaName, schema, record, excluded) => {
+	const fields = renderInputFields(schema, record.fields, excluded);
+	return `const input_${schemaName}_${record.name} = { name: "${record.name}", fields: ${fields} } as const;`;
+};
+const renderObjectVar = (schemaName, schema, record, excluded) => {
+	const fields = renderObjectFields(schema, record.fields, excluded);
+	return `const object_${schemaName}_${record.name} = { name: "${record.name}", fields: ${fields} } as const;`;
+};
+const renderUnionVar = (schemaName, record, excluded) => {
+	const memberNames = Array.from(record.members.values()).filter((member) => !excluded.has(member.name.value)).sort((left, right) => left.name.value.localeCompare(right.name.value)).map((member) => member.name.value);
+	const typesObj = memberNames.length === 0 ? "{}" : `{ ${memberNames.map((m) => `${m}: true`).join(", ")} }`;
+	return `const union_${schemaName}_${record.name} = { name: "${record.name}", types: ${typesObj} } as const;`;
+};
+const collectObjectTypeNames = (schema) => Array.from(schema.objects.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
+const collectInputTypeNames = (schema) => Array.from(schema.inputs.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
+const collectEnumTypeNames = (schema) => Array.from(schema.enums.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
+const collectUnionTypeNames = (schema) => Array.from(schema.unions.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
+const collectScalarNames = (schema) => Array.from(schema.scalars.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
+const collectDirectiveNames = (schema) => Array.from(schema.directives.keys()).sort((left, right) => left.localeCompare(right));
+const renderInputTypeMethod = (factoryVar, kind, typeName) => `${typeName}: ${factoryVar}("${kind}", "${typeName}")`;
+const renderInputTypeMethods = (schema, factoryVar, excluded) => {
+	const scalarMethods = Array.from(builtinScalarTypes$1.keys()).concat(collectScalarNames(schema).filter((name) => !builtinScalarTypes$1.has(name))).filter((name) => !excluded.has(name)).map((name) => renderInputTypeMethod(factoryVar, "scalar", name));
+	const enumMethods = collectEnumTypeNames(schema).filter((name) => !excluded.has(name)).map((name) => renderInputTypeMethod(factoryVar, "enum", name));
+	const inputMethods = collectInputTypeNames(schema).filter((name) => !excluded.has(name)).map((name) => renderInputTypeMethod(factoryVar, "input", name));
+	const allMethods = [
+		...scalarMethods,
+		...enumMethods,
+		...inputMethods
+	].sort((left, right) => {
+		const leftName = left.split(":")[0] ?? "";
+		const rightName = right.split(":")[0] ?? "";
+		return leftName.localeCompare(rightName);
+	});
+	return renderPropertyLines({
+		entries: allMethods,
+		indentSize: 2
+	});
+};
+/**
+* Renders an input reference as a deferred string for directive arguments.
+* Format: "{kindChar}|{name}|{modifier}"
+*/
+const renderDeferredDirectiveArgRef = (schema, definition, excluded) => {
+	const { name, modifier } = parseTypeReference(definition.type);
+	if (excluded.has(name)) {
+		return null;
+	}
+	let kind;
+	if (isScalarName$1(schema, name)) {
+		kind = "scalar";
+	} else if (isEnumName$1(schema, name)) {
+		kind = "enum";
+	} else {
+		kind = "input";
+	}
+	const kindChar = inputKindToChar(kind);
+	return `"${kindChar}|${name}|${modifier}"`;
+};
+/**
+* Renders argument specifiers for a directive.
+* Returns null if the directive has no arguments.
+* Uses deferred string format for consistency with other type specifiers.
+*/
+const renderDirectiveArgsSpec = (schema, args, excluded) => {
+	if (args.size === 0) return null;
+	const entries = Array.from(args.values()).sort((left, right) => left.name.value.localeCompare(right.name.value)).map((arg) => {
+		const ref = renderDeferredDirectiveArgRef(schema, arg, excluded);
+		return ref ? `${arg.name.value}: ${ref}` : null;
+	}).filter((entry) => entry !== null);
+	if (entries.length === 0) return null;
+	return renderPropertyLines({
+		entries,
+		indentSize: 4
+	});
+};
+const renderDirectiveMethod = (schema, record, excluded) => {
+	const locationsJson = JSON.stringify(record.locations);
+	const argsSpec = renderDirectiveArgsSpec(schema, record.args, excluded);
+	if (argsSpec === null) {
+		return `${record.name}: createDirectiveMethod("${record.name}", ${locationsJson} as const)`;
+	}
+	return `${record.name}: createTypedDirectiveMethod("${record.name}", ${locationsJson} as const, ${argsSpec})`;
+};
+const renderDirectiveMethods = (schema, excluded) => {
+	const directiveNames = collectDirectiveNames(schema);
+	if (directiveNames.length === 0) {
+		return "{}";
+	}
+	const methods = directiveNames.map((name) => {
+		const record = schema.directives.get(name);
+		return record ? renderDirectiveMethod(schema, record, excluded) : null;
+	}).filter((method) => method !== null);
+	return renderPropertyLines({
+		entries: methods,
+		indentSize: 2
+	});
+};
+/**
+* Generates the _internal-injects.ts module code.
+* This file contains only adapter imports (scalar, adapter) to keep it lightweight.
+* The heavy schema types remain in _internal.ts.
+*/
+const generateInjectsCode = (injection) => {
+	const imports = [];
+	const exports$1 = [];
+	const typeExports = [];
+	const importsByPath = new Map();
+	for (const [schemaName, config] of injection) {
+		const scalarAlias = `scalar_${schemaName}`;
+		const scalarSpecifiers = importsByPath.get(config.scalarImportPath) ?? [];
+		if (!importsByPath.has(config.scalarImportPath)) {
+			importsByPath.set(config.scalarImportPath, scalarSpecifiers);
+		}
+		scalarSpecifiers.push(`scalar as ${scalarAlias}`);
+		exports$1.push(`export { ${scalarAlias} };`);
+		typeExports.push(`export type Scalar_${schemaName} = typeof ${scalarAlias};`);
+		if (config.adapterImportPath) {
+			const adapterAlias = `adapter_${schemaName}`;
+			const adapterSpecifiers = importsByPath.get(config.adapterImportPath) ?? [];
+			if (!importsByPath.has(config.adapterImportPath)) {
+				importsByPath.set(config.adapterImportPath, adapterSpecifiers);
+			}
+			adapterSpecifiers.push(`adapter as ${adapterAlias}`);
+			exports$1.push(`export { ${adapterAlias} };`);
+			typeExports.push(`export type Adapter_${schemaName} = typeof ${adapterAlias} & { _?: never };`);
+		}
+	}
+	for (const [path, specifiers] of importsByPath) {
+		if (specifiers.length === 1) {
+			imports.push(`import { ${specifiers[0]} } from "${path}";`);
+		} else {
+			imports.push(`import {\n  ${specifiers.join(",\n  ")},\n} from "${path}";`);
+		}
+	}
+	return `\
+/**
+ * Adapter injections for schema.
+ * Separated to allow lightweight imports for prebuilt module.
+ * @generated by @soda-gql/tools/codegen
+ */
+
+${imports.join("\n")}
+
+// Value exports
+${exports$1.join("\n")}
+
+// Type exports
+${typeExports.join("\n")}
+`;
+};
+const multiRuntimeTemplate = ($$) => {
+	const imports = [];
+	const scalarAliases = new Map();
+	const adapterAliases = new Map();
+	if ($$.injection.mode === "inject") {
+		const injectsImports = [];
+		for (const [schemaName, injection] of $$.injection.perSchema) {
+			const scalarAlias = `scalar_${schemaName}`;
+			scalarAliases.set(schemaName, scalarAlias);
+			injectsImports.push(scalarAlias);
+			if (injection.adapterImportPath) {
+				const adapterAlias = `adapter_${schemaName}`;
+				adapterAliases.set(schemaName, adapterAlias);
+				injectsImports.push(adapterAlias);
+			}
+		}
+		imports.push(`import { ${injectsImports.join(", ")} } from "${$$.injection.injectsModulePath}";`);
+	}
+	{
+		const { importPaths } = $$.splitting;
+		for (const [name, config] of Object.entries($$.schemas)) {
+			if (config.enumNames.length > 0) {
+				const enumImports = config.enumNames.map((n) => `enum_${name}_${n}`).join(", ");
+				imports.push(`import { ${enumImports} } from "${importPaths.enums}";`);
+			}
+			if (config.inputNames.length > 0) {
+				const inputImports = config.inputNames.map((n) => `input_${name}_${n}`).join(", ");
+				imports.push(`import { ${inputImports} } from "${importPaths.inputs}";`);
+			}
+			if (config.objectNames.length > 0) {
+				const objectImports = config.objectNames.map((n) => `object_${name}_${n}`).join(", ");
+				imports.push(`import { ${objectImports} } from "${importPaths.objects}";`);
+			}
+			if (config.unionNames.length > 0) {
+				const unionImports = config.unionNames.map((n) => `union_${name}_${n}`).join(", ");
+				imports.push(`import { ${unionImports} } from "${importPaths.unions}";`);
+			}
+		}
+	}
+	const extraImports = imports.length > 0 ? `${imports.join("\n")}\n` : "";
+	const schemaBlocks = [];
+	const gqlExports = [];
+	for (const [name, config] of Object.entries($$.schemas)) {
+		const schemaVar = `${name}Schema`;
+		const adapterVar = adapterAliases.get(name);
+		const typeExports = [`export type Schema_${name} = typeof ${schemaVar} & { _?: never };`];
+		if (adapterVar) {
+			typeExports.push(`export type Adapter_${name} = typeof ${adapterVar} & { _?: never };`);
+		}
+		const inputTypeMethodsVar = `inputTypeMethods_${name}`;
+		const factoryVar = `createMethod_${name}`;
+		const customDirectivesVar = `customDirectives_${name}`;
+		const defaultDepthBlock = config.defaultInputDepth !== undefined && config.defaultInputDepth !== 3 ? `\n  __defaultInputDepth: ${config.defaultInputDepth},` : "";
+		const depthOverridesBlock = config.inputDepthOverrides && Object.keys(config.inputDepthOverrides).length > 0 ? `\n  __inputDepthOverrides: ${JSON.stringify(config.inputDepthOverrides)},` : "";
+		const isSplitMode = true;
+		const scalarVarsBlock = config.scalarVars.join("\n");
+		const enumVarsBlock = isSplitMode ? "// (enums imported)" : config.enumVars.length > 0 ? config.enumVars.join("\n") : "// (no enums)";
+		const inputVarsBlock = isSplitMode ? "// (inputs imported)" : config.inputVars.length > 0 ? config.inputVars.join("\n") : "// (no inputs)";
+		const objectVarsBlock = isSplitMode ? "// (objects imported)" : config.objectVars.length > 0 ? config.objectVars.join("\n") : "// (no objects)";
+		const unionVarsBlock = isSplitMode ? "// (unions imported)" : config.unionVars.length > 0 ? config.unionVars.join("\n") : "// (no unions)";
+		const scalarAssembly = $$.injection.mode === "inject" ? scalarAliases.get(name) ?? "{}" : config.scalarNames.length > 0 ? `{ ${config.scalarNames.map((n) => `${n}: scalar_${name}_${n}`).join(", ")} }` : "{}";
+		const enumAssembly = config.enumNames.length > 0 ? `{ ${config.enumNames.map((n) => `${n}: enum_${name}_${n}`).join(", ")} }` : "{}";
+		const inputAssembly = config.inputNames.length > 0 ? `{ ${config.inputNames.map((n) => `${n}: input_${name}_${n}`).join(", ")} }` : "{}";
+		const objectAssembly = config.objectNames.length > 0 ? `{ ${config.objectNames.map((n) => `${n}: object_${name}_${n}`).join(", ")} }` : "{}";
+		const unionAssembly = config.unionNames.length > 0 ? `{ ${config.unionNames.map((n) => `${n}: union_${name}_${n}`).join(", ")} }` : "{}";
+		const scalarVarsSection = $$.injection.mode === "inject" ? "// (scalars imported)" : scalarVarsBlock;
+		const scalarAssemblyLine = $$.injection.mode === "inject" ? `// scalar_${name} is imported directly` : `const scalar_${name} = ${scalarAssembly} as const;`;
+		const scalarRef = $$.injection.mode === "inject" ? scalarAliases.get(name) ?? `scalar_${name}` : `scalar_${name}`;
+		schemaBlocks.push(`
+// Individual scalar definitions
+${scalarVarsSection}
+
+// Individual enum definitions
+${enumVarsBlock}
+
+// Individual input definitions
+${inputVarsBlock}
+
+// Individual object definitions
+${objectVarsBlock}
+
+// Individual union definitions
+${unionVarsBlock}
+
+// Category assembly
+${scalarAssemblyLine}
+const enum_${name} = ${enumAssembly} as const;
+const input_${name} = ${inputAssembly} as const;
+const object_${name} = ${objectAssembly} as const;
+const union_${name} = ${unionAssembly} as const;
+
+// Schema assembly
+const ${schemaVar} = {
+  label: "${name}" as const,
+  operations: { query: "${config.queryType}", mutation: "${config.mutationType}", subscription: "${config.subscriptionType}" } as const,
+  scalar: ${scalarRef},
+  enum: enum_${name},
+  input: input_${name},
+  object: object_${name},
+  union: union_${name},${defaultDepthBlock}${depthOverridesBlock}
+} as const satisfies AnyGraphqlSchema;
+
+const ${factoryVar} = createVarMethodFactory<typeof ${schemaVar}>();
+const ${inputTypeMethodsVar} = ${config.inputTypeMethodsBlock};
+const ${customDirectivesVar} = { ...createStandardDirectives(), ...${config.directiveMethodsBlock} };
+
+${typeExports.join("\n")}`);
+		const gqlVarName = `gql_${name}`;
+		if (adapterVar) {
+			const typeParams = `<Schema_${name}, typeof ${customDirectivesVar}, Adapter_${name}>`;
+			schemaBlocks.push(`const ${gqlVarName} = createGqlElementComposer${typeParams}(${schemaVar}, { adapter: ${adapterVar}, inputTypeMethods: ${inputTypeMethodsVar}, directiveMethods: ${customDirectivesVar} });`);
+		} else {
+			const typeParams = `<Schema_${name}, typeof ${customDirectivesVar}>`;
+			schemaBlocks.push(`const ${gqlVarName} = createGqlElementComposer${typeParams}(${schemaVar}, { inputTypeMethods: ${inputTypeMethodsVar}, directiveMethods: ${customDirectivesVar} });`);
+		}
+		schemaBlocks.push(`export type Context_${name} = Parameters<typeof ${gqlVarName}>[0] extends (ctx: infer C) => unknown ? C : never;`);
+		const prebuiltExports = [
+			`export { ${schemaVar} as __schema_${name} }`,
+			`export { ${inputTypeMethodsVar} as __inputTypeMethods_${name} }`,
+			`export { ${customDirectivesVar} as __directiveMethods_${name} }`
+		];
+		if (adapterVar) {
+			prebuiltExports.push(`export { ${adapterVar} as __adapter_${name} }`);
+		}
+		schemaBlocks.push(`${prebuiltExports.join(";\n")};`);
+		gqlExports.push(`export { ${gqlVarName} as __gql_${name} }`);
+	}
+	const needsDefineEnum = false;
+	return `\
+import {${needsDefineEnum ? "\n  defineEnum," : ""}
+  type AnyGraphqlSchema,
+  createDirectiveMethod,
+  createTypedDirectiveMethod,
+  createGqlElementComposer,
+  createStandardDirectives,
+  createVarMethodFactory,
+} from "@soda-gql/core";
+${extraImports}
+${schemaBlocks.join("\n")}
+
+${gqlExports.join(";\n")};
+`;
+};
+const generateMultiSchemaModule = (schemas, options) => {
+	const schemaConfigs = {};
+	const allStats = {
+		objects: 0,
+		enums: 0,
+		inputs: 0,
+		unions: 0
+	};
+	for (const [name, document] of schemas.entries()) {
+		const schema = createSchemaIndex(document);
+		const typeFilterConfig = options?.typeFilters?.get(name);
+		const typeFilter = compileTypeFilter(typeFilterConfig);
+		const allTypeNames = new Map([
+			["object", Array.from(schema.objects.keys()).filter((n) => !n.startsWith("__"))],
+			["input", Array.from(schema.inputs.keys()).filter((n) => !n.startsWith("__"))],
+			["enum", Array.from(schema.enums.keys()).filter((n) => !n.startsWith("__"))],
+			["union", Array.from(schema.unions.keys()).filter((n) => !n.startsWith("__"))],
+			["scalar", Array.from(schema.scalars.keys()).filter((n) => !n.startsWith("__"))]
+		]);
+		const excluded = buildExclusionSet(typeFilter, allTypeNames);
+		const objectTypeNames = collectObjectTypeNames(schema).filter((n) => !excluded.has(n));
+		const enumTypeNames = collectEnumTypeNames(schema).filter((n) => !excluded.has(n));
+		const inputTypeNames = collectInputTypeNames(schema).filter((n) => !excluded.has(n));
+		const unionTypeNames = collectUnionTypeNames(schema).filter((n) => !excluded.has(n));
+		const customScalarNames = collectScalarNames(schema).filter((n) => !builtinScalarTypes$1.has(n) && !excluded.has(n));
+		const scalarVars = [];
+		const enumVars = [];
+		const inputVars = [];
+		const objectVars = [];
+		const unionVars = [];
+		for (const scalarName of builtinScalarTypes$1.keys()) {
+			const record = schema.scalars.get(scalarName) ?? {
+				name: scalarName,
+				directives: []
+			};
+			scalarVars.push(renderScalarVar(name, record));
+		}
+		for (const scalarName of customScalarNames) {
+			const record = schema.scalars.get(scalarName);
+			if (record) {
+				scalarVars.push(renderScalarVar(name, record));
+			}
+		}
+		for (const enumName of enumTypeNames) {
+			const record = schema.enums.get(enumName);
+			if (record) {
+				enumVars.push(renderEnumVar(name, record));
+			}
+		}
+		for (const inputName of inputTypeNames) {
+			const record = schema.inputs.get(inputName);
+			if (record) {
+				inputVars.push(renderInputVar(name, schema, record, excluded));
+			}
+		}
+		for (const objectName of objectTypeNames) {
+			const record = schema.objects.get(objectName);
+			if (record) {
+				objectVars.push(renderObjectVar(name, schema, record, excluded));
+			}
+		}
+		for (const unionName of unionTypeNames) {
+			const record = schema.unions.get(unionName);
+			if (record) {
+				unionVars.push(renderUnionVar(name, record, excluded));
+			}
+		}
+		const allScalarNames = [...builtinScalarTypes$1.keys(), ...customScalarNames];
+		const factoryVar = `createMethod_${name}`;
+		const inputTypeMethodsBlock = renderInputTypeMethods(schema, factoryVar, excluded);
+		const directiveMethodsBlock = renderDirectiveMethods(schema, excluded);
+		const queryType = schema.operationTypes.query ?? "Query";
+		const mutationType = schema.operationTypes.mutation ?? "Mutation";
+		const subscriptionType = schema.operationTypes.subscription ?? "Subscription";
+		schemaConfigs[name] = {
+			queryType,
+			mutationType,
+			subscriptionType,
+			scalarVars,
+			enumVars,
+			inputVars,
+			objectVars,
+			unionVars,
+			scalarNames: allScalarNames,
+			enumNames: enumTypeNames,
+			inputNames: inputTypeNames,
+			objectNames: objectTypeNames,
+			unionNames: unionTypeNames,
+			inputTypeMethodsBlock,
+			directiveMethodsBlock,
+			defaultInputDepth: options?.defaultInputDepth?.get(name),
+			inputDepthOverrides: options?.inputDepthOverrides?.get(name)
+		};
+		allStats.objects += objectVars.length;
+		allStats.enums += enumVars.length;
+		allStats.inputs += inputVars.length;
+		allStats.unions += unionVars.length;
+	}
+	const injection = options?.injection ? {
+		mode: "inject",
+		perSchema: options.injection,
+		injectsModulePath: "./_internal-injects"
+	} : { mode: "inline" };
+	const splitting = { importPaths: {
+		enums: "./_defs/enums",
+		inputs: "./_defs/inputs",
+		objects: "./_defs/objects",
+		unions: "./_defs/unions"
+	} };
+	const code = multiRuntimeTemplate({
+		schemas: schemaConfigs,
+		injection,
+		splitting
+	});
+	const injectsCode = options?.injection ? generateInjectsCode(options.injection) : undefined;
+	const categoryVarsResult = Object.fromEntries(Object.entries(schemaConfigs).map(([schemaName, config]) => {
+		const toDefVar = (code$1, prefix) => {
+			const match = code$1.match(new RegExp(`const (${prefix}_${schemaName}_(\\w+))`));
+			return {
+				name: match?.[1] ?? "",
+				code: code$1
+			};
+		};
+		return [schemaName, {
+			enums: config.enumVars.map((c) => toDefVar(c, "enum")),
+			inputs: config.inputVars.map((c) => toDefVar(c, "input")),
+			objects: config.objectVars.map((c) => toDefVar(c, "object")),
+			unions: config.unionVars.map((c) => toDefVar(c, "union"))
+		}];
+	}));
+	return {
+		code,
+		injectsCode,
+		categoryVars: categoryVarsResult,
+		stats: allStats
+	};
+};
+/**
+* Generate a stub `types.prebuilt.ts` file with empty PrebuiltTypes registries.
+* This stub is only written when `types.prebuilt.ts` does not already exist.
+* Typegen will later overwrite it with the real type registry.
+*/
+const generatePrebuiltStub = (schemaNames) => {
+	const typeDeclarations = schemaNames.map((name) => `export type PrebuiltTypes_${name} = {
+  readonly fragments: {};
+  readonly operations: {};
+};`).join("\n\n");
+	return `\
+/**
+ * Prebuilt type registry stub.
+ *
+ * This file was generated by @soda-gql/tools/codegen as an empty stub.
+ * Run 'soda-gql typegen' to populate with real prebuilt types.
+ *
+ * @module
+ * @generated
+ */
+
+${typeDeclarations}
+`;
+};
+/**
+* Generate the `index.ts` module that re-exports from `_internal`
+* and constructs the `gql` object from individual `__gql_*` exports.
+*
+* The `gql` object preserves the original inferred types from schema inference.
+* PrebuiltContext types will be integrated once the type resolution strategy
+* is redesigned to match the tagged template runtime API.
+*/
+const generateIndexModule = (schemaNames, allFieldNames) => {
+	const gqlImports = schemaNames.map((name) => `__gql_${name}`).join(", ");
+	const prebuiltImports = schemaNames.map((name) => `PrebuiltTypes_${name}`).join(", ");
+	const schemaTypeImports = schemaNames.map((name) => `Schema_${name}`).join(", ");
+	const directiveImports = schemaNames.map((name) => `__directiveMethods_${name}`).join(", ");
+	const perSchemaTypes = schemaNames.map((name) => `
+type ResolveFragmentAtBuilder_${name}<TKey extends string> =
+  TKey extends keyof PrebuiltTypes_${name}["fragments"]
+    ? Fragment<
+        PrebuiltTypes_${name}["fragments"][TKey]["typename"],
+        PrebuiltTypes_${name}["fragments"][TKey]["input"] extends void
+          ? void
+          : Partial<PrebuiltTypes_${name}["fragments"][TKey]["input"] & AnyConstAssignableInput>,
+        Partial<AnyFields>,
+        PrebuiltTypes_${name}["fragments"][TKey]["output"] & object
+      >
+    : Fragment<"(unknown)", PrebuiltEntryNotFound<TKey, "fragment">, Partial<AnyFields>, PrebuiltEntryNotFound<TKey, "fragment">>;
+
+type ResolveOperationAtBuilder_${name}<TOperationType extends OperationType, TName extends string> =
+  TName extends keyof PrebuiltTypes_${name}["operations"]
+    ? Operation<
+        TOperationType,
+        TName,
+        string[],
+        PrebuiltTypes_${name}["operations"][TName]["input"],
+        Partial<AnyFields>,
+        PrebuiltTypes_${name}["operations"][TName]["output"] & object
+      >
+    : Operation<
+        TOperationType,
+        TName,
+        string[],
+        PrebuiltEntryNotFound<TName, "operation">,
+        Partial<AnyFields>,
+        PrebuiltEntryNotFound<TName, "operation">
+      >;
+
+type PrebuiltCurriedFragment_${name} = <TKey extends string>(
+  name: TKey,
+  typeName: string,
+) => (...args: unknown[]) => (...args: unknown[]) => ResolveFragmentAtBuilder_${name}<TKey>;
+
+type PrebuiltCurriedOperation_${name}<TOperationType extends OperationType> = <TName extends string>(
+  operationName: TName,
+) => (...args: unknown[]) => (...args: unknown[]) => ResolveOperationAtBuilder_${name}<TOperationType, TName>;
+
+type FieldFactoryFn_${name} = (...args: unknown[]) => Record<string, unknown> & ((callback: (tools: GenericFieldsBuilderTools_${name}) => Record<string, unknown>) => Record<string, unknown>);
+${(() => {
+		const fieldNames = allFieldNames?.get(name);
+		if (fieldNames && fieldNames.length > 0) {
+			const union = fieldNames.map((n) => JSON.stringify(n)).join(" | ");
+			return `type AllObjectFieldNames_${name} = ${union};
+type GenericFieldFactory_${name} = { readonly [K in AllObjectFieldNames_${name}]: FieldFactoryFn_${name} } & Record<string, FieldFactoryFn_${name}>;`;
+		}
+		return `type GenericFieldFactory_${name} = Record<string, FieldFactoryFn_${name}>;`;
+	})()}
+type GenericFieldsBuilderTools_${name} = { readonly f: GenericFieldFactory_${name}; readonly $: Readonly<Record<string, never>> };
+
+type PrebuiltCallbackOperation_${name}<TOperationType extends OperationType> = <TName extends string>(
+  options: { name: TName; fields: (tools: GenericFieldsBuilderTools_${name}) => Record<string, unknown>; variables?: Record<string, unknown>; metadata?: (tools: { readonly $: Readonly<Record<string, never>>; readonly fragmentMetadata: unknown[] | undefined }) => Record<string, unknown> },
+) => ResolveOperationAtBuilder_${name}<TOperationType, TName>;
+
+export type PrebuiltContext_${name} = {
+  readonly fragment: PrebuiltCurriedFragment_${name};
+  readonly query: PrebuiltCurriedOperation_${name}<"query"> & {
+    readonly operation: PrebuiltCallbackOperation_${name}<"query">;
+    readonly compat: (operationName: string) => (strings: TemplateStringsArray, ...values: never[]) => GqlDefine<unknown>;
+  };
+  readonly mutation: PrebuiltCurriedOperation_${name}<"mutation"> & {
+    readonly operation: PrebuiltCallbackOperation_${name}<"mutation">;
+    readonly compat: (operationName: string) => (strings: TemplateStringsArray, ...values: never[]) => GqlDefine<unknown>;
+  };
+  readonly subscription: PrebuiltCurriedOperation_${name}<"subscription"> & {
+    readonly operation: PrebuiltCallbackOperation_${name}<"subscription">;
+    readonly compat: (operationName: string) => (strings: TemplateStringsArray, ...values: never[]) => GqlDefine<unknown>;
+  };
+  readonly define: <TValue>(factory: () => TValue | Promise<TValue>) => GqlDefine<TValue>;
+  readonly extend: (...args: unknown[]) => AnyOperation;
+  readonly $var: VarBuilder<Schema_${name}>;
+  readonly $dir: typeof __directiveMethods_${name};
+  readonly $colocate: <T extends Record<string, unknown>>(projections: T) => T;
+};
+
+type GqlComposer_${name} = {
+  <TResult>(composeElement: (context: PrebuiltContext_${name}) => TResult): TResult;
+  readonly $schema: AnyGraphqlSchema;
+};`).join("\n");
+	const gqlEntries = schemaNames.map((name) => `  ${name}: __gql_${name} as unknown as GqlComposer_${name}`).join(",\n");
+	return `\
+/**
+ * Generated by @soda-gql/tools/codegen
+ * @module
+ * @generated
+ */
+
+export * from "./_internal";
+import { ${gqlImports} } from "./_internal";
+import type { ${schemaTypeImports} } from "./_internal";
+import type { ${directiveImports} } from "./_internal";
+import type { ${prebuiltImports} } from "./types.prebuilt";
+import type { Fragment, Operation, OperationType, PrebuiltEntryNotFound, AnyConstAssignableInput, AnyFields, AnyGraphqlSchema, AnyOperation, VarBuilder, GqlDefine } from "@soda-gql/core";
+${perSchemaTypes}
+
+export const gql = {
+${gqlEntries}
+};
+`;
+};
+
+//#endregion
+//#region packages/tools/src/codegen/graphql-compat/parser.ts
+/**
+* Parser for .graphql operation files.
+* Extracts operations and fragments from GraphQL documents.
+* @module
+*/
+/**
+* Parse a single .graphql file and extract operations and fragments.
+*/
+const parseGraphqlFile = (filePath) => {
+	const resolvedPath = resolve(filePath);
+	if (!existsSync(resolvedPath)) {
+		return err({
+			code: "GRAPHQL_FILE_NOT_FOUND",
+			message: `GraphQL file not found at ${resolvedPath}`,
+			filePath: resolvedPath
+		});
+	}
+	try {
+		const source = readFileSync(resolvedPath, "utf8");
+		const document = parse(source);
+		return ok(extractFromDocument(document, resolvedPath));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return err({
+			code: "GRAPHQL_PARSE_ERROR",
+			message: `GraphQL parse error: ${message}`,
+			filePath: resolvedPath
+		});
+	}
+};
+/**
+* Parse GraphQL source string directly.
+*/
+const parseGraphqlSource = (source, sourceFile) => {
+	try {
+		const document = parse(source);
+		return ok(extractFromDocument(document, sourceFile));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return err({
+			code: "GRAPHQL_PARSE_ERROR",
+			message: `GraphQL parse error: ${message}`,
+			filePath: sourceFile
+		});
+	}
+};
+/**
+* Extract operations and fragments from a parsed GraphQL document.
+*/
+const extractFromDocument = (document, sourceFile) => {
+	const operations = [];
+	const fragments = [];
+	for (const definition of document.definitions) {
+		if (definition.kind === Kind.OPERATION_DEFINITION) {
+			const operation = extractOperation(definition, sourceFile);
+			if (operation) {
+				operations.push(operation);
+			}
+		} else if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+			fragments.push(extractFragment(definition, sourceFile));
+		}
+	}
+	return {
+		operations,
+		fragments
+	};
+};
+/**
+* Extract a single operation from an OperationDefinitionNode.
+*/
+const extractOperation = (node, sourceFile) => {
+	if (!node.name) {
+		return null;
+	}
+	const variables = (node.variableDefinitions ?? []).map(extractVariable);
+	const selections = extractSelections(node.selectionSet.selections);
+	return {
+		kind: node.operation,
+		name: node.name.value,
+		variables,
+		selections,
+		sourceFile
+	};
+};
+/**
+* Extract a fragment from a FragmentDefinitionNode.
+*/
+const extractFragment = (node, sourceFile) => {
+	const selections = extractSelections(node.selectionSet.selections);
+	return {
+		name: node.name.value,
+		onType: node.typeCondition.name.value,
+		selections,
+		sourceFile
+	};
+};
+/**
+* Extract a variable definition.
+*/
+const extractVariable = (node) => {
+	const { typeName, modifier } = parseTypeNode(node.type);
+	const defaultValue = node.defaultValue ? extractValue(node.defaultValue) : undefined;
+	return {
+		name: node.variable.name.value,
+		typeName,
+		modifier,
+		typeKind: "scalar",
+		defaultValue
+	};
+};
+/**
+* Parse a GraphQL TypeNode into type name and modifier.
+*
+* Format: inner nullability + list modifiers
+* - Inner: `!` (non-null) or `?` (nullable)
+* - List: `[]!` (non-null list) or `[]?` (nullable list)
+*/
+const parseTypeNode = (node) => {
+	const levels = [];
+	const collect = (n, nonNull) => {
+		if (n.kind === Kind.NON_NULL_TYPE) {
+			return collect(n.type, true);
+		}
+		if (n.kind === Kind.LIST_TYPE) {
+			levels.push({
+				kind: "list",
+				nonNull
+			});
+			return collect(n.type, false);
+		}
+		levels.push({
+			kind: "named",
+			nonNull
+		});
+		return n.name.value;
+	};
+	const typeName = collect(node, false);
+	let modifier = "?";
+	for (const level of levels.slice().reverse()) {
+		if (level.kind === "named") {
+			modifier = level.nonNull ? "!" : "?";
+			continue;
+		}
+		const listSuffix = level.nonNull ? "[]!" : "[]?";
+		modifier = `${modifier}${listSuffix}`;
+	}
+	return {
+		typeName,
+		modifier
+	};
+};
+/**
+* Extract selections from a SelectionSet.
+*/
+const extractSelections = (selections) => {
+	return selections.map(extractSelection);
+};
+/**
+* Extract a single selection.
+*/
+const extractSelection = (node) => {
+	switch (node.kind) {
+		case Kind.FIELD: return extractFieldSelection(node);
+		case Kind.FRAGMENT_SPREAD: return extractFragmentSpread(node);
+		case Kind.INLINE_FRAGMENT: return extractInlineFragment(node);
+	}
+};
+/**
+* Extract a field selection.
+*/
+const extractFieldSelection = (node) => {
+	const args = node.arguments?.length ? node.arguments.map(extractArgument) : undefined;
+	const selections = node.selectionSet ? extractSelections(node.selectionSet.selections) : undefined;
+	return {
+		kind: "field",
+		name: node.name.value,
+		alias: node.alias?.value,
+		arguments: args,
+		selections
+	};
+};
+/**
+* Extract a fragment spread.
+*/
+const extractFragmentSpread = (node) => {
+	return {
+		kind: "fragmentSpread",
+		name: node.name.value
+	};
+};
+/**
+* Extract an inline fragment.
+*/
+const extractInlineFragment = (node) => {
+	return {
+		kind: "inlineFragment",
+		onType: node.typeCondition?.name.value ?? "",
+		selections: extractSelections(node.selectionSet.selections)
+	};
+};
+/**
+* Extract an argument.
+*/
+const extractArgument = (node) => {
+	return {
+		name: node.name.value,
+		value: extractValue(node.value)
+	};
+};
+/**
+* Assert unreachable code path (for exhaustiveness checks).
+*/
+const assertUnreachable = (value) => {
+	throw new Error(`Unexpected value: ${JSON.stringify(value)}`);
+};
+/**
+* Extract a value (literal or variable reference).
+*/
+const extractValue = (node) => {
+	switch (node.kind) {
+		case Kind.VARIABLE: return {
+			kind: "variable",
+			name: node.name.value
+		};
+		case Kind.INT: return {
+			kind: "int",
+			value: node.value
+		};
+		case Kind.FLOAT: return {
+			kind: "float",
+			value: node.value
+		};
+		case Kind.STRING: return {
+			kind: "string",
+			value: node.value
+		};
+		case Kind.BOOLEAN: return {
+			kind: "boolean",
+			value: node.value
+		};
+		case Kind.NULL: return { kind: "null" };
+		case Kind.ENUM: return {
+			kind: "enum",
+			value: node.value
+		};
+		case Kind.LIST: return {
+			kind: "list",
+			values: node.values.map(extractValue)
+		};
+		case Kind.OBJECT: return {
+			kind: "object",
+			fields: node.fields.map((field) => ({
+				name: field.name.value,
+				value: extractValue(field.value)
+			}))
+		};
+		default: return assertUnreachable(node);
+	}
+};
+
+//#endregion
+//#region packages/tools/src/codegen/graphql-compat/transformer.ts
+/**
+* Transformer for enriching parsed GraphQL operations with schema information.
+* @module
+*/
+/**
+* Built-in GraphQL scalar types.
+*/
+const builtinScalarTypes = new Set([
+	"ID",
+	"String",
+	"Int",
+	"Float",
+	"Boolean"
+]);
+/**
+* Parse a modifier string into its structural components.
+* @param modifier - Modifier string like "!", "?", "![]!", "?[]?[]!"
+* @returns Parsed structure with inner nullability and list modifiers
+*/
+const parseModifierStructure = (modifier) => {
+	const inner = modifier[0] === "!" ? "!" : "?";
+	const lists = [];
+	const listPattern = /\[\]([!?])/g;
+	let match;
+	while ((match = listPattern.exec(modifier)) !== null) {
+		lists.push(`[]${match[1]}`);
+	}
+	return {
+		inner,
+		lists
+	};
+};
+/**
+* Rebuild modifier string from structure.
+*/
+const buildModifier = (structure) => {
+	return structure.inner + structure.lists.join("");
+};
+/**
+* Check if source modifier can be assigned to target modifier.
+* Implements GraphQL List Coercion: depth difference of 0 or 1 is allowed.
+*
+* Rules:
+* - A single value can be coerced into a list (depth diff = 1)
+* - At each level, non-null can be assigned to nullable (but not vice versa)
+*
+* @param source - The modifier of the value being assigned (variable's type)
+* @param target - The modifier expected by the position (field argument's type)
+* @returns true if assignment is valid
+*/
+const isModifierAssignable = (source, target) => {
+	const srcStruct = parseModifierStructure(source);
+	const tgtStruct = parseModifierStructure(target);
+	const depthDiff = tgtStruct.lists.length - srcStruct.lists.length;
+	if (depthDiff < 0 || depthDiff > 1) return false;
+	const tgtListsToCompare = depthDiff === 1 ? tgtStruct.lists.slice(1) : tgtStruct.lists;
+	if (depthDiff === 1 && srcStruct.lists.length === 0 && srcStruct.inner === "?" && tgtStruct.lists[0] === "[]!") {
+		return false;
+	}
+	if (srcStruct.inner === "?" && tgtStruct.inner === "!") return false;
+	for (let i = 0; i < srcStruct.lists.length; i++) {
+		const srcList = srcStruct.lists[i];
+		const tgtList = tgtListsToCompare[i];
+		if (srcList === undefined || tgtList === undefined) break;
+		if (srcList === "[]?" && tgtList === "[]!") return false;
+	}
+	return true;
+};
+/**
+* Derive minimum modifier needed to satisfy expected modifier.
+* When List Coercion can apply, returns one level shallower.
+*
+* @param expectedModifier - The modifier expected by the field argument
+* @returns The minimum modifier the variable must have
+*/
+const deriveMinimumModifier = (expectedModifier) => {
+	const struct = parseModifierStructure(expectedModifier);
+	if (struct.lists.length > 0) {
+		return buildModifier({
+			inner: struct.inner,
+			lists: struct.lists.slice(1)
+		});
+	}
+	return expectedModifier;
+};
+/**
+* Merge two modifiers by taking the stricter constraint at each level.
+* - Non-null (!) is stricter than nullable (?)
+* - List depths must match
+*
+* @param a - First modifier
+* @param b - Second modifier
+* @returns Merged modifier or error if incompatible
+*/
+const mergeModifiers = (a, b) => {
+	const structA = parseModifierStructure(a);
+	const structB = parseModifierStructure(b);
+	if (structA.lists.length !== structB.lists.length) {
+		return {
+			ok: false,
+			reason: `Incompatible list depths: "${a}" has ${structA.lists.length} list level(s), "${b}" has ${structB.lists.length}`
+		};
+	}
+	const mergedInner = structA.inner === "!" || structB.inner === "!" ? "!" : "?";
+	const mergedLists = [];
+	for (let i = 0; i < structA.lists.length; i++) {
+		const listA = structA.lists[i];
+		const listB = structB.lists[i];
+		if (listA === undefined || listB === undefined) break;
+		mergedLists.push(listA === "[]!" || listB === "[]!" ? "[]!" : "[]?");
+	}
+	return {
+		ok: true,
+		value: buildModifier({
+			inner: mergedInner,
+			lists: mergedLists
+		})
+	};
+};
+/**
+* Get the expected type for a field argument from the schema.
+* Returns null if the field or argument is not found.
+*/
+const getArgumentType = (schema, parentTypeName, fieldName, argumentName) => {
+	const objectRecord = schema.objects.get(parentTypeName);
+	if (!objectRecord) return null;
+	const fieldDef = objectRecord.fields.get(fieldName);
+	if (!fieldDef) return null;
+	const argDef = fieldDef.arguments?.find((arg) => arg.name.value === argumentName);
+	if (!argDef) return null;
+	return parseTypeNode(argDef.type);
+};
+/**
+* Get the expected type for an input object field from the schema.
+*/
+const getInputFieldType = (schema, inputTypeName, fieldName) => {
+	const inputRecord = schema.inputs.get(inputTypeName);
+	if (!inputRecord) return null;
+	const fieldDef = inputRecord.fields.get(fieldName);
+	if (!fieldDef) return null;
+	return parseTypeNode(fieldDef.type);
+};
+/**
+* Resolve the type kind for a type name.
+*/
+const resolveTypeKindFromName = (schema, typeName) => {
+	if (isScalarName(schema, typeName)) return "scalar";
+	if (isEnumName(schema, typeName)) return "enum";
+	if (schema.inputs.has(typeName)) return "input";
+	return null;
+};
+/**
+* Extract variable usages from a parsed value, given the expected type.
+* Handles nested input objects recursively.
+*/
+const collectVariablesFromValue = (value, expectedTypeName, expectedModifier, schema, usages) => {
+	if (value.kind === "variable") {
+		const typeKind = resolveTypeKindFromName(schema, expectedTypeName);
+		if (!typeKind) {
+			return {
+				code: "GRAPHQL_UNKNOWN_TYPE",
+				message: `Unknown type "${expectedTypeName}" for variable "$${value.name}"`,
+				typeName: expectedTypeName
+			};
+		}
+		usages.push({
+			name: value.name,
+			typeName: expectedTypeName,
+			expectedModifier,
+			minimumModifier: deriveMinimumModifier(expectedModifier),
+			typeKind
+		});
+		return null;
+	}
+	if (value.kind === "object") {
+		for (const field of value.fields) {
+			const fieldType = getInputFieldType(schema, expectedTypeName, field.name);
+			if (!fieldType) {
+				return {
+					code: "GRAPHQL_UNKNOWN_FIELD",
+					message: `Unknown field "${field.name}" on input type "${expectedTypeName}"`,
+					typeName: expectedTypeName,
+					fieldName: field.name
+				};
+			}
+			const error = collectVariablesFromValue(field.value, fieldType.typeName, fieldType.modifier, schema, usages);
+			if (error) return error;
+		}
+		return null;
+	}
+	if (value.kind === "list") {
+		const struct = parseModifierStructure(expectedModifier);
+		if (struct.lists.length > 0) {
+			const innerModifier = buildModifier({
+				inner: struct.inner,
+				lists: struct.lists.slice(1)
+			});
+			for (const item of value.values) {
+				const error = collectVariablesFromValue(item, expectedTypeName, innerModifier, schema, usages);
+				if (error) return error;
+			}
+		}
+	}
+	return null;
+};
+/**
+* Collect variable usages from field arguments.
+*/
+const collectVariablesFromArguments = (args, parentTypeName, fieldName, schema, usages) => {
+	for (const arg of args) {
+		const argType = getArgumentType(schema, parentTypeName, fieldName, arg.name);
+		if (!argType) {
+			return {
+				code: "GRAPHQL_UNKNOWN_ARGUMENT",
+				message: `Unknown argument "${arg.name}" on field "${fieldName}"`,
+				fieldName,
+				argumentName: arg.name
+			};
+		}
+		const error = collectVariablesFromValue(arg.value, argType.typeName, argType.modifier, schema, usages);
+		if (error) return error;
+	}
+	return null;
+};
+/**
+* Recursively collect all variable usages from selections.
+*/
+const collectVariableUsages = (selections, parentTypeName, schema) => {
+	const usages = [];
+	const collect = (sels, parentType) => {
+		for (const sel of sels) {
+			switch (sel.kind) {
+				case "field": {
+					if (sel.arguments && sel.arguments.length > 0) {
+						const error$1 = collectVariablesFromArguments(sel.arguments, parentType, sel.name, schema, usages);
+						if (error$1) return error$1;
+					}
+					if (sel.selections && sel.selections.length > 0) {
+						const fieldReturnType = getFieldReturnType(schema, parentType, sel.name);
+						if (!fieldReturnType) {
+							return {
+								code: "GRAPHQL_UNKNOWN_FIELD",
+								message: `Unknown field "${sel.name}" on type "${parentType}"`,
+								typeName: parentType,
+								fieldName: sel.name
+							};
+						}
+						const error$1 = collect(sel.selections, fieldReturnType);
+						if (error$1) return error$1;
+					}
+					break;
+				}
+				case "inlineFragment": {
+					const error$1 = collect(sel.selections, sel.onType);
+					if (error$1) return error$1;
+					break;
+				}
+				case "fragmentSpread": break;
+			}
+		}
+		return null;
+	};
+	const error = collect(selections, parentTypeName);
+	if (error) return err(error);
+	return ok(usages);
+};
+/**
+* Get the return type of a field (unwrapped from modifiers).
+*/
+const getFieldReturnType = (schema, parentTypeName, fieldName) => {
+	const objectRecord = schema.objects.get(parentTypeName);
+	if (!objectRecord) return null;
+	const fieldDef = objectRecord.fields.get(fieldName);
+	if (!fieldDef) return null;
+	const { typeName } = parseTypeNode(fieldDef.type);
+	return typeName;
+};
+/**
+* Merge multiple variable usages into a single InferredVariable.
+* Validates type compatibility and merges modifiers using List Coercion rules.
+*
+* The algorithm:
+* 1. Validate all usages have the same type name
+* 2. Merge minimumModifiers to find the candidate (shallowest type that could work)
+* 3. Verify the candidate can satisfy ALL expected modifiers via isModifierAssignable
+*/
+const mergeVariableUsages = (variableName, usages) => {
+	const first = usages[0];
+	if (!first) {
+		return err({
+			code: "GRAPHQL_UNDECLARED_VARIABLE",
+			message: `No usages found for variable "${variableName}"`,
+			variableName
+		});
+	}
+	for (const usage of usages) {
+		if (usage.typeName !== first.typeName) {
+			return err({
+				code: "GRAPHQL_VARIABLE_TYPE_MISMATCH",
+				message: `Variable "$${variableName}" has conflicting types: "${first.typeName}" and "${usage.typeName}"`,
+				variableName
+			});
+		}
+	}
+	let candidateModifier = first.minimumModifier;
+	for (let i = 1; i < usages.length; i++) {
+		const usage = usages[i];
+		if (!usage) break;
+		const result = mergeModifiers(candidateModifier, usage.minimumModifier);
+		if (!result.ok) {
+			return err({
+				code: "GRAPHQL_VARIABLE_MODIFIER_INCOMPATIBLE",
+				message: `Variable "$${variableName}" has incompatible modifiers: ${result.reason}`,
+				variableName
+			});
+		}
+		candidateModifier = result.value;
+	}
+	for (const usage of usages) {
+		if (!isModifierAssignable(candidateModifier, usage.expectedModifier)) {
+			return err({
+				code: "GRAPHQL_VARIABLE_MODIFIER_INCOMPATIBLE",
+				message: `Variable "$${variableName}" with modifier "${candidateModifier}" cannot satisfy expected "${usage.expectedModifier}"`,
+				variableName
+			});
+		}
+	}
+	return ok({
+		name: variableName,
+		typeName: first.typeName,
+		modifier: candidateModifier,
+		typeKind: first.typeKind
+	});
+};
+/**
+* Infer variables from collected usages.
+* Groups by variable name and merges each group.
+*/
+const inferVariablesFromUsages = (usages) => {
+	const byName = new Map();
+	for (const usage of usages) {
+		const existing = byName.get(usage.name);
+		if (existing) {
+			existing.push(usage);
+		} else {
+			byName.set(usage.name, [usage]);
+		}
+	}
+	const variables = [];
+	for (const [name, group] of byName) {
+		const result = mergeVariableUsages(name, group);
+		if (result.isErr()) return err(result.error);
+		variables.push(result.value);
+	}
+	variables.sort((a, b) => a.name.localeCompare(b.name));
+	return ok(variables);
+};
+/**
+* Check if a type name is a scalar type.
+*/
+const isScalarName = (schema, name) => builtinScalarTypes.has(name) || schema.scalars.has(name);
+/**
+* Topologically sort fragments so dependencies come before dependents.
+* Detects circular dependencies.
+*
+* Note: Uses the existing collectFragmentDependencies function defined below.
+*/
+const sortFragmentsByDependency = (fragments) => {
+	const graph = new Map();
+	for (const fragment of fragments) {
+		const deps = collectFragmentDependenciesSet(fragment.selections);
+		graph.set(fragment.name, deps);
+	}
+	const fragmentByName = new Map();
+	for (const f of fragments) {
+		fragmentByName.set(f.name, f);
+	}
+	const sorted = [];
+	const visited = new Set();
+	const visiting = new Set();
+	const visit = (name, path) => {
+		if (visited.has(name)) return null;
+		if (visiting.has(name)) {
+			const cycleStart = path.indexOf(name);
+			const cycle = path.slice(cycleStart).concat(name);
+			return {
+				code: "GRAPHQL_FRAGMENT_CIRCULAR_DEPENDENCY",
+				message: `Circular dependency detected in fragments: ${cycle.join(" -> ")}`,
+				fragmentNames: cycle
+			};
+		}
+		const fragment = fragmentByName.get(name);
+		if (!fragment) {
+			visited.add(name);
+			return null;
+		}
+		visiting.add(name);
+		const deps = graph.get(name) ?? new Set();
+		for (const dep of deps) {
+			const error = visit(dep, [...path, name]);
+			if (error) return error;
+		}
+		visiting.delete(name);
+		visited.add(name);
+		sorted.push(fragment);
+		return null;
+	};
+	for (const fragment of fragments) {
+		const error = visit(fragment.name, []);
+		if (error) return err(error);
+	}
+	return ok(sorted);
+};
+/**
+* Recursively collect fragment spread names from selections into a Set.
+* Internal helper for sortFragmentsByDependency.
+*/
+const collectFragmentDependenciesSet = (selections) => {
+	const deps = new Set();
+	const collect = (sels) => {
+		for (const sel of sels) {
+			switch (sel.kind) {
+				case "fragmentSpread":
+					deps.add(sel.name);
+					break;
+				case "field":
+					if (sel.selections) {
+						collect(sel.selections);
+					}
+					break;
+				case "inlineFragment":
+					collect(sel.selections);
+					break;
+			}
+		}
+	};
+	collect(selections);
+	return deps;
+};
+/**
+* Check if a type name is an enum type.
+*/
+const isEnumName = (schema, name) => schema.enums.has(name);
+/**
+* Transform parsed operations/fragments by enriching them with schema information.
+*
+* This resolves variable type kinds (scalar, enum, input), collects
+* fragment dependencies, and infers variables for fragments.
+*/
+const transformParsedGraphql = (parsed, options) => {
+	const schema = createSchemaIndex(options.schemaDocument);
+	const sortResult = sortFragmentsByDependency(parsed.fragments);
+	if (sortResult.isErr()) {
+		return err(sortResult.error);
+	}
+	const sortedFragments = sortResult.value;
+	const resolvedFragmentVariables = new Map();
+	const fragments = [];
+	for (const frag of sortedFragments) {
+		const result = transformFragment(frag, schema, resolvedFragmentVariables);
+		if (result.isErr()) {
+			return err(result.error);
+		}
+		resolvedFragmentVariables.set(frag.name, result.value.variables);
+		fragments.push(result.value);
+	}
+	const operations = [];
+	for (const op of parsed.operations) {
+		const result = transformOperation(op, schema);
+		if (result.isErr()) {
+			return err(result.error);
+		}
+		operations.push(result.value);
+	}
+	return ok({
+		operations,
+		fragments
+	});
+};
+/**
+* Transform a single operation.
+*/
+const transformOperation = (op, schema) => {
+	const variables = [];
+	for (const v of op.variables) {
+		const typeKind = resolveTypeKind(schema, v.typeName);
+		if (typeKind === null) {
+			return err({
+				code: "GRAPHQL_UNKNOWN_TYPE",
+				message: `Unknown type "${v.typeName}" in variable "${v.name}"`,
+				typeName: v.typeName
+			});
+		}
+		variables.push({
+			...v,
+			typeKind
+		});
+	}
+	const fragmentDependencies = collectFragmentDependencies(op.selections);
+	return ok({
+		...op,
+		variables,
+		fragmentDependencies
+	});
+};
+/**
+* Transform a single fragment.
+* Infers variables from field arguments and propagates variables from spread fragments.
+*/
+const transformFragment = (frag, schema, resolvedFragmentVariables) => {
+	const fragmentDependencies = collectFragmentDependencies(frag.selections);
+	const directUsagesResult = collectVariableUsages(frag.selections, frag.onType, schema);
+	if (directUsagesResult.isErr()) {
+		return err(directUsagesResult.error);
+	}
+	const directUsages = directUsagesResult.value;
+	const spreadVariables = [];
+	for (const depName of fragmentDependencies) {
+		const depVariables = resolvedFragmentVariables.get(depName);
+		if (depVariables) {
+			spreadVariables.push(...depVariables);
+		}
+	}
+	const allUsages = [...directUsages, ...spreadVariables.map((v) => ({
+		name: v.name,
+		typeName: v.typeName,
+		expectedModifier: v.modifier,
+		minimumModifier: v.modifier,
+		typeKind: v.typeKind
+	}))];
+	const variablesResult = inferVariablesFromUsages(allUsages);
+	if (variablesResult.isErr()) {
+		return err(variablesResult.error);
+	}
+	return ok({
+		...frag,
+		fragmentDependencies,
+		variables: variablesResult.value
+	});
+};
+/**
+* Resolve the type kind for a type name.
+*/
+const resolveTypeKind = (schema, typeName) => {
+	if (isScalarName(schema, typeName)) {
+		return "scalar";
+	}
+	if (isEnumName(schema, typeName)) {
+		return "enum";
+	}
+	if (schema.inputs.has(typeName)) {
+		return "input";
+	}
+	return null;
+};
+/**
+* Collect fragment names used in selections (recursively).
+*/
+const collectFragmentDependencies = (selections) => {
+	const fragments = new Set();
+	const collect = (sels) => {
+		for (const sel of sels) {
+			switch (sel.kind) {
+				case "fragmentSpread":
+					fragments.add(sel.name);
+					break;
+				case "field":
+					if (sel.selections) {
+						collect(sel.selections);
+					}
+					break;
+				case "inlineFragment":
+					collect(sel.selections);
+					break;
+			}
+		}
+	};
+	collect(selections);
+	return [...fragments];
+};
+
+//#endregion
+//#region packages/tools/src/codegen/graphql-compat/emitter.ts
+/**
+* Map operation kind to root type name.
+* Uses schema.operationTypes if available, falls back to standard names.
+*/
+const getRootTypeName = (schema, kind) => {
+	if (schema) {
+		switch (kind) {
+			case "query": return schema.operationTypes.query ?? "Query";
+			case "mutation": return schema.operationTypes.mutation ?? "Mutation";
+			case "subscription": return schema.operationTypes.subscription ?? "Subscription";
+		}
+	}
+	switch (kind) {
+		case "query": return "Query";
+		case "mutation": return "Mutation";
+		case "subscription": return "Subscription";
+	}
+};
+/**
+* Emit TypeScript code for an operation.
+*/
+const emitOperation = (operation, options) => {
+	const lines = [];
+	const schema = options.schemaDocument ? createSchemaIndex(options.schemaDocument) : null;
+	const exportName = `${operation.name}Compat`;
+	const operationType = operation.kind;
+	lines.push(`export const ${exportName} = gql.${options.schemaName}(({ ${operationType}, $var }) =>`);
+	lines.push(`  ${operationType}.compat({`);
+	lines.push(`    name: ${JSON.stringify(operation.name)},`);
+	if (operation.variables.length > 0) {
+		lines.push(`    variables: { ${emitVariables(operation.variables)} },`);
+	}
+	const rootTypeName = getRootTypeName(schema, operation.kind);
+	lines.push(`    fields: ({ f, $ }) => ({`);
+	const fieldLinesResult = emitSelections(operation.selections, 3, operation.variables, schema, rootTypeName);
+	if (fieldLinesResult.isErr()) {
+		return err(fieldLinesResult.error);
+	}
+	lines.push(fieldLinesResult.value);
+	lines.push(`    }),`);
+	lines.push(`  }),`);
+	lines.push(`);`);
+	return ok(lines.join("\n"));
+};
+/**
+* Emit TypeScript code for a fragment.
+*/
+const emitFragment = (fragment, options) => {
+	const lines = [];
+	const schema = options.schemaDocument ? createSchemaIndex(options.schemaDocument) : null;
+	const hasVariables = fragment.variables.length > 0;
+	const exportName = `${fragment.name}Fragment`;
+	const destructure = hasVariables ? "fragment, $var" : "fragment";
+	lines.push(`export const ${exportName} = gql.${options.schemaName}(({ ${destructure} }) =>`);
+	lines.push(`  fragment.${fragment.onType}({`);
+	if (hasVariables) {
+		lines.push(`    variables: { ${emitVariables(fragment.variables)} },`);
+	}
+	const fieldsContext = hasVariables ? "{ f, $ }" : "{ f }";
+	lines.push(`    fields: (${fieldsContext}) => ({`);
+	const fieldLinesResult = emitSelections(fragment.selections, 3, fragment.variables, schema, fragment.onType);
+	if (fieldLinesResult.isErr()) {
+		return err(fieldLinesResult.error);
+	}
+	lines.push(fieldLinesResult.value);
+	lines.push(`    }),`);
+	lines.push(`  }),`);
+	lines.push(`);`);
+	return ok(lines.join("\n"));
+};
+/**
+* Emit variable definitions.
+*/
+const emitVariables = (variables) => {
+	return variables.map((v) => `...$var(${JSON.stringify(v.name)}).${v.typeName}(${JSON.stringify(v.modifier)})`).join(", ");
+};
+/**
+* Emit field selections (public API).
+* Converts variable array to Set<string> and delegates to internal implementation.
+*/
+const emitSelections = (selections, indent, variables, schema, parentTypeName) => {
+	const variableNames = new Set(variables.map((v) => v.name));
+	return emitSelectionsInternal(selections, indent, variableNames, schema, parentTypeName);
+};
+/**
+* Internal implementation for emitting field selections.
+* Takes variableNames as Set<string> for recursive calls.
+*/
+const emitSelectionsInternal = (selections, indent, variableNames, schema, parentTypeName) => {
+	const lines = [];
+	const inlineFragments = [];
+	const otherSelections = [];
+	let hasTypenameField = false;
+	for (const sel of selections) {
+		if (sel.kind === "inlineFragment") {
+			inlineFragments.push(sel);
+		} else if (sel.kind === "field" && sel.name === "__typename" && !sel.alias) {
+			hasTypenameField = true;
+		} else {
+			otherSelections.push(sel);
+		}
+	}
+	for (const sel of otherSelections) {
+		const result = emitSingleSelection(sel, indent, variableNames, schema, parentTypeName);
+		if (result.isErr()) {
+			return err(result.error);
+		}
+		lines.push(result.value);
+	}
+	if (inlineFragments.length > 0) {
+		const unionResult = emitInlineFragmentsAsUnion(inlineFragments, indent, variableNames, schema, hasTypenameField);
+		if (unionResult.isErr()) {
+			return err(unionResult.error);
+		}
+		lines.push(unionResult.value);
+	} else if (hasTypenameField) {
+		const padding = "  ".repeat(indent);
+		lines.push(`${padding}__typename: true,`);
+	}
+	return ok(lines.join("\n"));
+};
+/**
+* Emit a single selection (field or fragment spread).
+*/
+const emitSingleSelection = (sel, indent, variableNames, schema, parentTypeName) => {
+	const padding = "  ".repeat(indent);
+	switch (sel.kind) {
+		case "field": return emitFieldSelection(sel, indent, variableNames, schema, parentTypeName);
+		case "fragmentSpread": return ok(`${padding}...${sel.name}Fragment.spread(),`);
+		case "inlineFragment": return ok("");
+	}
+};
+/**
+* Emit inline fragments grouped as a union selection.
+* Format: { TypeA: ({ f }) => ({ ...fields }), TypeB: ({ f }) => ({ ...fields }), __typename: true }
+*/
+const emitInlineFragmentsAsUnion = (inlineFragments, indent, variableNames, schema, includeTypename) => {
+	const padding = "  ".repeat(indent);
+	for (const frag of inlineFragments) {
+		if (frag.onType === "") {
+			return err({
+				code: "GRAPHQL_INLINE_FRAGMENT_WITHOUT_TYPE",
+				message: "Inline fragments without type condition are not supported. Use `... on TypeName { }` syntax."
+			});
+		}
+	}
+	for (const frag of inlineFragments) {
+		if (schema && !schema.objects.has(frag.onType)) {
+			let isUnionMember = false;
+			for (const [, unionDef] of schema.unions) {
+				if (unionDef.members.has(frag.onType)) {
+					isUnionMember = true;
+					break;
+				}
+			}
+			if (!isUnionMember) {
+				return err({
+					code: "GRAPHQL_INLINE_FRAGMENT_ON_INTERFACE",
+					message: `Inline fragments on interface type "${frag.onType}" are not supported. Use union types instead.`,
+					onType: frag.onType
+				});
+			}
+		}
+	}
+	const entries = [];
+	for (const frag of inlineFragments) {
+		const innerPadding = "  ".repeat(indent + 1);
+		const fieldsResult = emitSelectionsInternal(frag.selections, indent + 2, variableNames, schema, frag.onType);
+		if (fieldsResult.isErr()) {
+			return err(fieldsResult.error);
+		}
+		entries.push(`${innerPadding}${frag.onType}: ({ f }) => ({
+${fieldsResult.value}
+${innerPadding}}),`);
+	}
+	if (includeTypename) {
+		const innerPadding = "  ".repeat(indent + 1);
+		entries.push(`${innerPadding}__typename: true,`);
+	}
+	return ok(`${padding}...({
+${entries.join("\n")}
+${padding}}),`);
+};
+/**
+* Emit a single field selection.
+*/
+const emitFieldSelection = (field, indent, variableNames, schema, parentTypeName) => {
+	const padding = "  ".repeat(indent);
+	const args = field.arguments;
+	const selections = field.selections;
+	const hasArgs = args && args.length > 0;
+	const hasSelections = selections && selections.length > 0;
+	if (!hasArgs && !hasSelections && !field.alias) {
+		return ok(`${padding}${field.name}: true,`);
+	}
+	let line = `${padding}...f.${field.name}(`;
+	if (hasArgs) {
+		const argsResult = emitArguments(args, variableNames, schema, parentTypeName, field.name);
+		if (argsResult.isErr()) {
+			return err(argsResult.error);
+		}
+		line += argsResult.value;
+		if (field.alias) {
+			line += `, { alias: ${JSON.stringify(field.alias)} }`;
+		}
+	} else if (field.alias) {
+		line += `null, { alias: ${JSON.stringify(field.alias)} }`;
+	}
+	line += ")";
+	if (hasSelections) {
+		const hasInlineFragments = selections.some((s) => s.kind === "inlineFragment");
+		const nestedParentType = schema && parentTypeName ? getFieldReturnType(schema, parentTypeName, field.name) ?? undefined : undefined;
+		if (hasInlineFragments) {
+			const nestedResult = emitSelectionsInternal(selections, indent + 1, variableNames, schema, nestedParentType);
+			if (nestedResult.isErr()) {
+				return err(nestedResult.error);
+			}
+			line += "({\n";
+			line += `${nestedResult.value}\n`;
+			line += `${padding}})`;
+		} else {
+			line += "(({ f }) => ({\n";
+			const nestedResult = emitSelectionsInternal(selections, indent + 1, variableNames, schema, nestedParentType);
+			if (nestedResult.isErr()) {
+				return err(nestedResult.error);
+			}
+			line += `${nestedResult.value}\n`;
+			line += `${padding}}))`;
+		}
+	}
+	line += ",";
+	return ok(line);
+};
+/**
+* Check if a modifier represents a list type (contains []).
+*/
+const isListModifier = (modifier) => {
+	return modifier.includes("[]");
+};
+/**
+* Determine if a value needs to be wrapped in an array for list coercion.
+* Returns true if:
+* - Expected type is a list
+* - Value is NOT already a list
+* - Value is NOT a variable (runtime handles coercion)
+* - Value is NOT null
+*/
+const needsListCoercion = (value, expectedModifier) => {
+	if (!expectedModifier) return false;
+	if (!isListModifier(expectedModifier)) return false;
+	if (value.kind === "variable") return false;
+	if (value.kind === "null") return false;
+	if (value.kind === "list") return false;
+	return true;
+};
+/**
+* Extract the element type from a list type by removing the outermost list modifier.
+* For example: "![]!" (non-null list of non-null) → "!" (non-null element)
+*              "?[]![]!" (nested lists) → "?[]!" (inner list type)
+* Returns null if the modifier doesn't represent a list type.
+*/
+const getListElementType = (expectedType) => {
+	const { modifier, typeName } = expectedType;
+	const listMatch = modifier.match(/^(.+?)(\[\][!?])$/);
+	if (!listMatch || !listMatch[1]) return null;
+	return {
+		typeName,
+		modifier: listMatch[1]
+	};
+};
+/**
+* Emit a value with type context for list coercion.
+*/
+const emitValueWithType = (value, expectedType, variableNames, schema) => {
+	const shouldCoerce = needsListCoercion(value, expectedType?.modifier);
+	if (value.kind === "object" && expectedType && schema) {
+		return emitObjectWithType(value, expectedType.typeName, variableNames, schema, shouldCoerce);
+	}
+	if (value.kind === "list" && expectedType && schema) {
+		const elementType = getListElementType(expectedType);
+		if (elementType) {
+			const values = [];
+			for (const v of value.values) {
+				const result$1 = emitValueWithType(v, elementType, variableNames, schema);
+				if (result$1.isErr()) return result$1;
+				values.push(result$1.value);
+			}
+			return ok(`[${values.join(", ")}]`);
+		}
+	}
+	const result = emitValue(value, variableNames);
+	if (result.isErr()) return result;
+	if (shouldCoerce) {
+		return ok(`[${result.value}]`);
+	}
+	return result;
+};
+/**
+* Emit an object value with type context for recursive list coercion.
+*/
+const emitObjectWithType = (value, inputTypeName, variableNames, schema, wrapInArray) => {
+	if (value.fields.length === 0) {
+		return ok(wrapInArray ? "[{}]" : "{}");
+	}
+	const entries = [];
+	for (const f of value.fields) {
+		const fieldType = getInputFieldType(schema, inputTypeName, f.name);
+		if (fieldType === null) {
+			return err({
+				code: "GRAPHQL_UNKNOWN_FIELD",
+				message: `Unknown field "${f.name}" on input type "${inputTypeName}"`,
+				typeName: inputTypeName,
+				fieldName: f.name
+			});
+		}
+		const result = emitValueWithType(f.value, fieldType, variableNames, schema);
+		if (result.isErr()) {
+			return err(result.error);
+		}
+		entries.push(`${f.name}: ${result.value}`);
+	}
+	const objectStr = `{ ${entries.join(", ")} }`;
+	return ok(wrapInArray ? `[${objectStr}]` : objectStr);
+};
+/**
+* Emit field arguments with type context for list coercion.
+*/
+const emitArguments = (args, variableNames, schema, parentTypeName, fieldName) => {
+	if (args.length === 0) {
+		return ok("");
+	}
+	const argEntries = [];
+	for (const arg of args) {
+		const expectedType = schema && parentTypeName && fieldName ? getArgumentType(schema, parentTypeName, fieldName, arg.name) : null;
+		const result = emitValueWithType(arg.value, expectedType, variableNames, schema);
+		if (result.isErr()) {
+			return err(result.error);
+		}
+		argEntries.push(`${arg.name}: ${result.value}`);
+	}
+	return ok(`{ ${argEntries.join(", ")} }`);
+};
+/**
+* Emit a value (literal or variable reference).
+*/
+const emitValue = (value, variableNames) => {
+	switch (value.kind) {
+		case "variable":
+			if (variableNames.has(value.name)) {
+				return ok(`$.${value.name}`);
+			}
+			return err({
+				code: "GRAPHQL_UNDECLARED_VARIABLE",
+				message: `Variable "$${value.name}" is not declared in the operation`,
+				variableName: value.name
+			});
+		case "int":
+		case "float": return ok(value.value);
+		case "string": return ok(JSON.stringify(value.value));
+		case "boolean": return ok(value.value ? "true" : "false");
+		case "null": return ok("null");
+		case "enum": return ok(JSON.stringify(value.value));
+		case "list": {
+			const values = [];
+			for (const v of value.values) {
+				const result = emitValue(v, variableNames);
+				if (result.isErr()) {
+					return err(result.error);
+				}
+				values.push(result.value);
+			}
+			return ok(`[${values.join(", ")}]`);
+		}
+		case "object": {
+			if (value.fields.length === 0) {
+				return ok("{}");
+			}
+			const entries = [];
+			for (const f of value.fields) {
+				const result = emitValue(f.value, variableNames);
+				if (result.isErr()) {
+					return err(result.error);
+				}
+				entries.push(`${f.name}: ${result.value}`);
+			}
+			return ok(`{ ${entries.join(", ")} }`);
+		}
+	}
+};
+
+//#endregion
+//#region packages/tools/src/codegen/inject-template.ts
+const templateContents = `\
+import { defineScalar } from "@soda-gql/core";
+
+export const scalar = {
+  ...defineScalar<"ID", string, string>("ID"),
+  ...defineScalar<"String", string, string>("String"),
+  ...defineScalar<"Int", number, number>("Int"),
+  ...defineScalar<"Float", number, number>("Float"),
+  ...defineScalar<"Boolean", boolean, boolean>("Boolean"),
+} as const;
+`;
+const writeInjectTemplate = (outPath) => {
+	const targetPath = resolve(outPath);
+	try {
+		if (existsSync(targetPath)) {
+			return err({
+				code: "INJECT_TEMPLATE_EXISTS",
+				message: `Inject module already exists: ${targetPath}`,
+				outPath: targetPath
+			});
+		}
+		mkdirSync(dirname(targetPath), { recursive: true });
+		writeFileSync(targetPath, `${templateContents}\n`);
+		return ok(undefined);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return err({
+			code: "INJECT_TEMPLATE_FAILED",
+			message,
+			outPath: targetPath
+		});
+	}
+};
+const getInjectTemplate = () => `${templateContents}\n`;
+
+//#endregion
+//#region packages/tools/src/codegen/reachability.ts
+/**
+* Schema type reachability analysis.
+*
+* Determines which types are reachable from root types (Query/Mutation/Subscription)
+* to specified target types (e.g., fragment onType values from .graphql files).
+* Produces a CompiledFilter for use with existing buildExclusionSet.
+*
+* @module
+*/
+const extractNamedType = (typeNode) => {
+	switch (typeNode.kind) {
+		case Kind.NAMED_TYPE: return typeNode.name.value;
+		case Kind.LIST_TYPE: return extractNamedType(typeNode.type);
+		case Kind.NON_NULL_TYPE: return extractNamedType(typeNode.type);
+	}
+};
+const addEdge = (graph, from, to) => {
+	let edges = graph.get(from);
+	if (!edges) {
+		edges = new Set();
+		graph.set(from, edges);
+	}
+	edges.add(to);
+};
+const buildTypeGraph = (document) => {
+	const schema = createSchemaIndex(document);
+	const forward = new Map();
+	const reverse = new Map();
+	const addBidirectional = (from, to) => {
+		addEdge(forward, from, to);
+		addEdge(reverse, to, from);
+	};
+	for (const [typeName, record] of schema.objects) {
+		for (const field of record.fields.values()) {
+			const returnType = extractNamedType(field.type);
+			addBidirectional(typeName, returnType);
+			if (field.arguments) {
+				for (const arg of field.arguments) {
+					const argType = extractNamedType(arg.type);
+					addBidirectional(typeName, argType);
+				}
+			}
+		}
+	}
+	for (const [typeName, record] of schema.inputs) {
+		for (const field of record.fields.values()) {
+			const fieldType = extractNamedType(field.type);
+			addBidirectional(typeName, fieldType);
+		}
+	}
+	for (const [typeName, record] of schema.unions) {
+		for (const memberName of record.members.keys()) {
+			addBidirectional(typeName, memberName);
+		}
+	}
+	return {
+		graph: {
+			forward,
+			reverse
+		},
+		schema
+	};
+};
+/**
+* BFS traversal collecting all reachable nodes from seeds.
+*/
+const bfs = (adjacency, seeds, constraint) => {
+	const visited = new Set();
+	const queue = [];
+	for (const seed of seeds) {
+		if (!visited.has(seed)) {
+			visited.add(seed);
+			queue.push(seed);
+		}
+	}
+	let head = 0;
+	while (head < queue.length) {
+		const current = queue[head++];
+		if (current === undefined) break;
+		const neighbors = adjacency.get(current);
+		if (!neighbors) continue;
+		for (const neighbor of neighbors) {
+			if (visited.has(neighbor)) continue;
+			if (constraint && !constraint.has(neighbor)) continue;
+			visited.add(neighbor);
+			queue.push(neighbor);
+		}
+	}
+	return visited;
+};
+/**
+* Compute the set of type names reachable on paths from root types to target types.
+*
+* Algorithm:
+* 1. Backward BFS from target types to find all upstream types
+* 2. Forward BFS from root types, constrained to upstream set, to find actual paths
+* 3. Collect input/enum/scalar types used as field arguments on reachable object types
+*/
+const computeReachableTypes = (graph, schema, targetTypes, usedArgumentTypes) => {
+	const upstream = bfs(graph.reverse, targetTypes);
+	const rootTypes = [];
+	if (schema.operationTypes.query) rootTypes.push(schema.operationTypes.query);
+	if (schema.operationTypes.mutation) rootTypes.push(schema.operationTypes.mutation);
+	if (schema.operationTypes.subscription) rootTypes.push(schema.operationTypes.subscription);
+	const validRoots = rootTypes.filter((r) => upstream.has(r));
+	const pathTypes = bfs(graph.forward, validRoots, upstream);
+	const reachable = new Set(pathTypes);
+	const inputQueue = [];
+	for (const typeName of pathTypes) {
+		const objectRecord = schema.objects.get(typeName);
+		if (!objectRecord) continue;
+		for (const field of objectRecord.fields.values()) {
+			const returnType = extractNamedType(field.type);
+			if (!reachable.has(returnType)) {
+				const isKnownComposite = schema.objects.has(returnType) || schema.inputs.has(returnType) || schema.unions.has(returnType);
+				if (!isKnownComposite) {
+					reachable.add(returnType);
+				}
+			}
+			if (!usedArgumentTypes && field.arguments) {
+				for (const arg of field.arguments) {
+					const argType = extractNamedType(arg.type);
+					if (!reachable.has(argType)) {
+						reachable.add(argType);
+						if (schema.inputs.has(argType)) {
+							inputQueue.push(argType);
+						}
+					}
+				}
+			}
+		}
+	}
+	if (usedArgumentTypes) {
+		for (const inputName of usedArgumentTypes) {
+			if (!reachable.has(inputName)) {
+				reachable.add(inputName);
+				inputQueue.push(inputName);
+			}
+		}
+	}
+	let inputHead = 0;
+	while (inputHead < inputQueue.length) {
+		const inputName = inputQueue[inputHead++];
+		if (inputName === undefined) break;
+		const inputRecord = schema.inputs.get(inputName);
+		if (!inputRecord) continue;
+		for (const field of inputRecord.fields.values()) {
+			const fieldType = extractNamedType(field.type);
+			if (!reachable.has(fieldType)) {
+				reachable.add(fieldType);
+				if (schema.inputs.has(fieldType)) {
+					inputQueue.push(fieldType);
+				}
+			}
+		}
+	}
+	return reachable;
+};
+/**
+* Compute a filter function that includes only types reachable from root types
+* to the specified target types.
+*
+* When targetTypes is empty, returns a pass-all filter (no filtering).
+* Warns when target types are not found in the schema.
+*
+* @param document - The parsed GraphQL schema document
+* @param targetTypes - Set of type names that fragments target (e.g., from ParsedFragment.onType)
+* @returns Filter function and any warnings
+*/
+const computeReachabilityFilter = (document, targetTypes, usedArgumentTypes) => {
+	if (targetTypes.size === 0) {
+		return {
+			filter: () => true,
+			warnings: []
+		};
+	}
+	const { graph, schema } = buildTypeGraph(document);
+	const allTypeNames = new Set([
+		...schema.objects.keys(),
+		...schema.inputs.keys(),
+		...schema.enums.keys(),
+		...schema.unions.keys(),
+		...schema.scalars.keys()
+	]);
+	const warnings = [];
+	const validTargets = new Set();
+	for (const target of targetTypes) {
+		if (allTypeNames.has(target)) {
+			validTargets.add(target);
+		} else {
+			warnings.push(`Target type "${target}" not found in schema`);
+		}
+	}
+	if (validTargets.size === 0) {
+		return {
+			filter: () => true,
+			warnings
+		};
+	}
+	const reachable = computeReachableTypes(graph, schema, validTargets, usedArgumentTypes);
+	if (reachable.size === 0) {
+		warnings.push(`No types reachable from root operations to target types: ${[...validTargets].join(", ")}; skipping reachability filter`);
+		return {
+			filter: () => true,
+			warnings
+		};
+	}
+	return {
+		filter: (context) => reachable.has(context.name),
+		warnings
+	};
+};
+
+//#endregion
+//#region packages/tools/src/codegen/bundler/esbuild.ts
+const esbuildBundler = {
+	name: "esbuild",
+	bundle: async ({ sourcePath, external }) => {
+		try {
+			const sourceExt = extname(sourcePath);
+			const baseName = sourcePath.slice(0, -sourceExt.length);
+			const cjsPath = `${baseName}.cjs`;
+			await build({
+				entryPoints: [sourcePath],
+				outfile: cjsPath,
+				format: "cjs",
+				platform: "node",
+				bundle: true,
+				external: [...external],
+				sourcemap: false,
+				minify: false,
+				treeShaking: false
+			});
+			return ok({ cjsPath });
+		} catch (error) {
+			return err({
+				code: "EMIT_FAILED",
+				message: `[esbuild] Failed to bundle: ${error instanceof Error ? error.message : String(error)}`,
+				outPath: sourcePath
+			});
+		}
+	}
+};
+
+//#endregion
+//#region packages/tools/src/codegen/defs-generator.ts
+/**
+* Split an array into chunks of the specified size.
+*/
+const chunkArray = (array, size) => {
+	if (size <= 0) {
+		return [Array.from(array)];
+	}
+	const result = [];
+	for (let i = 0; i < array.length; i += size) {
+		result.push(array.slice(i, i + size));
+	}
+	return result;
+};
+/**
+* Determine if chunking is needed based on the number of definitions.
+*/
+const needsChunking = (vars, chunkSize) => {
+	return vars.length > chunkSize;
+};
+/**
+* Generate a single definition file content.
+*/
+const generateDefinitionFile = (options) => {
+	const { category, vars, needsDefineEnum } = options;
+	if (vars.length === 0) {
+		return `/**
+ * ${category} definitions (empty)
+ * @generated by @soda-gql/tools/codegen
+ */
+`;
+	}
+	const imports = [];
+	if (needsDefineEnum && category === "enums") {
+		imports.push("import { defineEnum } from \"@soda-gql/core\";");
+	}
+	const importsBlock = imports.length > 0 ? `${imports.join("\n")}\n\n` : "";
+	const exportStatements = vars.map((v) => `export ${v.code}`).join("\n");
+	return `/**
+ * ${category} definitions
+ * @generated by @soda-gql/tools/codegen
+ */
+${importsBlock}${exportStatements}
+`;
+};
+/**
+* Generate a chunk file content.
+*/
+const generateChunkFile = (options) => {
+	const { category, vars, chunkIndex, needsDefineEnum } = options;
+	if (vars.length === 0) {
+		return `/**
+ * ${category} chunk ${chunkIndex} (empty)
+ * @generated by @soda-gql/tools/codegen
+ */
+`;
+	}
+	const imports = [];
+	if (needsDefineEnum && category === "enums") {
+		imports.push("import { defineEnum } from \"@soda-gql/core\";");
+	}
+	const importsBlock = imports.length > 0 ? `${imports.join("\n")}\n\n` : "";
+	const exportStatements = vars.map((v) => `export ${v.code}`).join("\n");
+	return `/**
+ * ${category} chunk ${chunkIndex}
+ * @generated by @soda-gql/tools/codegen
+ */
+${importsBlock}${exportStatements}
+`;
+};
+/**
+* Generate the index file that re-exports all chunks.
+*/
+const generateChunkIndex = (options) => {
+	const { category, chunkCount } = options;
+	const reExports = Array.from({ length: chunkCount }, (_, i) => `export * from "./chunk-${i}";`).join("\n");
+	return `/**
+ * ${category} index (re-exports all chunks)
+ * @generated by @soda-gql/tools/codegen
+ */
+${reExports}
+`;
+};
+/**
+* Generate chunked definition files.
+*/
+const generateChunkedDefinitionFiles = (category, schemaName, vars, chunkSize) => {
+	const chunks = chunkArray(vars, chunkSize);
+	const needsDefineEnum = category === "enums";
+	const chunkContents = chunks.map((chunkVars, chunkIndex) => ({
+		chunkIndex,
+		content: generateChunkFile({
+			category,
+			schemaName,
+			vars: chunkVars,
+			chunkIndex,
+			needsDefineEnum
+		}),
+		varNames: chunkVars.map((v) => v.name)
+	}));
+	const allVarNames = vars.map((v) => v.name);
+	const indexContent = generateChunkIndex({
+		category,
+		chunkCount: chunks.length,
+		varNames: allVarNames
+	});
+	return {
+		indexContent,
+		chunks: chunkContents
+	};
+};
+/**
+* Generate the complete _defs directory structure.
+*/
+const generateDefsStructure = (schemaName, categoryVars, chunkSize) => {
+	const files = [];
+	const importPaths = {
+		enums: "./_defs/enums",
+		inputs: "./_defs/inputs",
+		objects: "./_defs/objects",
+		unions: "./_defs/unions"
+	};
+	const categories = [
+		"enums",
+		"inputs",
+		"objects",
+		"unions"
+	];
+	for (const category of categories) {
+		const vars = categoryVars[category];
+		const needsDefineEnum = category === "enums";
+		if (needsChunking(vars, chunkSize)) {
+			const chunked = generateChunkedDefinitionFiles(category, schemaName, vars, chunkSize);
+			importPaths[category] = `./_defs/${category}`;
+			files.push({
+				relativePath: `_defs/${category}/index.ts`,
+				content: chunked.indexContent
+			});
+			for (const chunk of chunked.chunks) {
+				files.push({
+					relativePath: `_defs/${category}/chunk-${chunk.chunkIndex}.ts`,
+					content: chunk.content
+				});
+			}
+		} else {
+			const content = generateDefinitionFile({
+				category,
+				schemaName,
+				vars,
+				needsDefineEnum
+			});
+			files.push({
+				relativePath: `_defs/${category}.ts`,
+				content
+			});
+		}
+	}
+	return {
+		files,
+		importPaths
+	};
+};
+
+//#endregion
+//#region packages/tools/src/codegen/file.ts
+const removeDirectory = (dirPath) => {
+	const targetPath = resolve(dirPath);
+	try {
+		rmSync(targetPath, {
+			recursive: true,
+			force: true
+		});
+		return ok(undefined);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return err({
+			code: "REMOVE_FAILED",
+			message,
+			outPath: targetPath
+		});
+	}
+};
+const readModule = (filePath) => {
+	const targetPath = resolve(filePath);
+	try {
+		const content = readFileSync(targetPath, "utf-8");
+		return ok(content);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return err({
+			code: "READ_FAILED",
+			message,
+			outPath: targetPath
+		});
+	}
+};
+const writeModule = (outPath, contents) => {
+	const targetPath = resolve(outPath);
+	try {
+		mkdirSync(dirname(targetPath), { recursive: true });
+		writeFileSync(targetPath, contents);
+		return ok(undefined);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return err({
+			code: "EMIT_FAILED",
+			message,
+			outPath: targetPath
+		});
+	}
+};
+
+//#endregion
+//#region packages/tools/src/codegen/schema.ts
+/**
+* Load a single schema file.
+* @internal Use loadSchema for public API.
+*/
+const loadSingleSchema = (schemaPath) => {
+	const resolvedPath = resolve(schemaPath);
+	if (!existsSync(resolvedPath)) {
+		return err({
+			code: "SCHEMA_NOT_FOUND",
+			message: `Schema file not found at ${resolvedPath}`,
+			schemaPath: resolvedPath
+		});
+	}
+	try {
+		const schemaSource = readFileSync(resolvedPath, "utf8");
+		const document = parse(schemaSource);
+		return ok(document);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return err({
+			code: "SCHEMA_INVALID",
+			message: `SchemaValidationError: ${message}`,
+			schemaPath: resolvedPath
+		});
+	}
+};
+/**
+* Load and merge multiple schema files into a single DocumentNode.
+* Uses GraphQL's concatAST to combine definitions from all files.
+*/
+const loadSchema = (schemaPaths) => {
+	const documents = [];
+	for (const schemaPath of schemaPaths) {
+		const result = loadSingleSchema(schemaPath);
+		if (result.isErr()) {
+			return err(result.error);
+		}
+		documents.push(result.value);
+	}
+	const merged = concatAST(documents);
+	return ok(merged);
+};
+const hashSchema = (document) => createHash("sha256").update(print(document)).digest("hex");
+
+//#endregion
+//#region packages/tools/src/codegen/runner.ts
+const extensionMap = {
+	".ts": ".js",
+	".tsx": ".js",
+	".mts": ".mjs",
+	".cts": ".cjs",
+	".js": ".js",
+	".mjs": ".mjs",
+	".cjs": ".cjs"
+};
+const toImportSpecifier = (fromPath, targetPath, options) => {
+	const fromDir = dirname(fromPath);
+	const normalized = relative(fromDir, targetPath).replace(/\\/g, "/");
+	const sourceExt = extname(targetPath);
+	if (!options?.includeExtension) {
+		if (normalized.length === 0) {
+			return `./${basename(targetPath, sourceExt)}`;
+		}
+		const withPrefix$1 = normalized.startsWith(".") ? normalized : `./${normalized}`;
+		const currentExt$1 = extname(withPrefix$1);
+		return currentExt$1 ? withPrefix$1.slice(0, -currentExt$1.length) : withPrefix$1;
+	}
+	const runtimeExt = extensionMap[sourceExt] ?? sourceExt;
+	if (normalized.length === 0) {
+		const base = runtimeExt !== sourceExt ? basename(targetPath, sourceExt) : basename(targetPath);
+		return `./${base}${runtimeExt}`;
+	}
+	const withPrefix = normalized.startsWith(".") ? normalized : `./${normalized}`;
+	if (!runtimeExt) {
+		return withPrefix;
+	}
+	if (withPrefix.endsWith(runtimeExt)) {
+		return withPrefix;
+	}
+	const currentExt = extname(withPrefix);
+	const withoutExt = currentExt ? withPrefix.slice(0, -currentExt.length) : withPrefix;
+	return `${withoutExt}${runtimeExt}`;
+};
+const runCodegen = async (options) => {
+	const outPath = resolve(options.outPath);
+	const importSpecifierOptions = { includeExtension: options.importExtension };
+	for (const [schemaName, schemaConfig] of Object.entries(options.schemas)) {
+		const scalarPath = resolve(schemaConfig.inject.scalars);
+		if (!existsSync(scalarPath)) {
+			return err({
+				code: "INJECT_MODULE_NOT_FOUND",
+				message: `Scalar module not found for schema '${schemaName}': ${scalarPath}`,
+				injectPath: scalarPath
+			});
+		}
+		if (schemaConfig.inject.adapter) {
+			const adapterPath = resolve(schemaConfig.inject.adapter);
+			if (!existsSync(adapterPath)) {
+				return err({
+					code: "INJECT_MODULE_NOT_FOUND",
+					message: `Adapter module not found for schema '${schemaName}': ${adapterPath}`,
+					injectPath: adapterPath
+				});
+			}
+		}
+	}
+	const schemas = new Map();
+	const schemaHashes = {};
+	for (const [name, schemaConfig] of Object.entries(options.schemas)) {
+		const preloaded = options.preloadedSchemas?.get(name);
+		if (preloaded) {
+			schemas.set(name, preloaded);
+		} else {
+			const result = await loadSchema(schemaConfig.schema).match((doc) => Promise.resolve(ok(doc)), (error) => Promise.resolve(err(error)));
+			if (result.isErr()) {
+				return err(result.error);
+			}
+			schemas.set(name, result.value);
+		}
+	}
+	const injectionConfig = new Map();
+	for (const [schemaName, schemaConfig] of Object.entries(options.schemas)) {
+		const injectConfig = schemaConfig.inject;
+		injectionConfig.set(schemaName, {
+			scalarImportPath: toImportSpecifier(outPath, resolve(injectConfig.scalars), importSpecifierOptions),
+			...injectConfig.adapter ? { adapterImportPath: toImportSpecifier(outPath, resolve(injectConfig.adapter), importSpecifierOptions) } : {}
+		});
+	}
+	const defaultInputDepthConfig = new Map();
+	const inputDepthOverridesConfig = new Map();
+	for (const [schemaName, schemaConfig] of Object.entries(options.schemas)) {
+		if (schemaConfig.defaultInputDepth !== undefined && schemaConfig.defaultInputDepth !== 3) {
+			defaultInputDepthConfig.set(schemaName, schemaConfig.defaultInputDepth);
+		}
+		if (schemaConfig.inputDepthOverrides && Object.keys(schemaConfig.inputDepthOverrides).length > 0) {
+			inputDepthOverridesConfig.set(schemaName, schemaConfig.inputDepthOverrides);
+		}
+	}
+	const chunkSize = options.chunkSize ?? 100;
+	const typeFiltersConfig = new Map();
+	for (const [schemaName, schemaConfig] of Object.entries(options.schemas)) {
+		if (schemaConfig.typeFilter) {
+			typeFiltersConfig.set(schemaName, schemaConfig.typeFilter);
+		}
+	}
+	const { code: internalCode, injectsCode, categoryVars } = generateMultiSchemaModule(schemas, {
+		injection: injectionConfig,
+		defaultInputDepth: defaultInputDepthConfig.size > 0 ? defaultInputDepthConfig : undefined,
+		inputDepthOverrides: inputDepthOverridesConfig.size > 0 ? inputDepthOverridesConfig : undefined,
+		chunkSize,
+		typeFilters: typeFiltersConfig.size > 0 ? typeFiltersConfig : undefined
+	});
+	const schemaNames = Object.keys(options.schemas);
+	const allFieldNames = new Map();
+	for (const [name, document] of schemas.entries()) {
+		const schemaIndex = createSchemaIndex(document);
+		const fieldNameSet = new Set();
+		for (const [objectName, record] of schemaIndex.objects.entries()) {
+			if (objectName.startsWith("__")) continue;
+			for (const fieldName of record.fields.keys()) {
+				fieldNameSet.add(fieldName);
+			}
+		}
+		allFieldNames.set(name, Array.from(fieldNameSet).sort());
+		const objects = Array.from(schemaIndex.objects.keys()).filter((n) => !n.startsWith("__")).length;
+		const enums = Array.from(schemaIndex.enums.keys()).filter((n) => !n.startsWith("__")).length;
+		const inputs = Array.from(schemaIndex.inputs.keys()).filter((n) => !n.startsWith("__")).length;
+		const unions = Array.from(schemaIndex.unions.keys()).filter((n) => !n.startsWith("__")).length;
+		schemaHashes[name] = {
+			schemaHash: hashSchema(document),
+			objects,
+			enums,
+			inputs,
+			unions
+		};
+	}
+	const indexCode = generateIndexModule(schemaNames, allFieldNames);
+	const injectsPath = join(dirname(outPath), "_internal-injects.ts");
+	if (injectsCode) {
+		const injectsWriteResult = await writeModule(injectsPath, injectsCode).match(() => Promise.resolve(ok(undefined)), (error) => Promise.resolve(err(error)));
+		if (injectsWriteResult.isErr()) {
+			return err(injectsWriteResult.error);
+		}
+	}
+	const defsPaths = [];
+	if (categoryVars) {
+		const outDir = dirname(outPath);
+		const defsDir = join(outDir, "_defs");
+		if (existsSync(defsDir)) {
+			const removeResult = removeDirectory(defsDir);
+			if (removeResult.isErr()) {
+				return err(removeResult.error);
+			}
+		}
+		const combinedVars = {
+			enums: [],
+			inputs: [],
+			objects: [],
+			unions: []
+		};
+		for (const vars of Object.values(categoryVars)) {
+			combinedVars.enums.push(...vars.enums);
+			combinedVars.inputs.push(...vars.inputs);
+			combinedVars.objects.push(...vars.objects);
+			combinedVars.unions.push(...vars.unions);
+		}
+		const defsStructure = generateDefsStructure("combined", combinedVars, chunkSize);
+		for (const file of defsStructure.files) {
+			const filePath = join(outDir, file.relativePath);
+			const writeResult = await writeModule(filePath, file.content).match(() => Promise.resolve(ok(undefined)), (error) => Promise.resolve(err(error)));
+			if (writeResult.isErr()) {
+				return err(writeResult.error);
+			}
+			defsPaths.push(filePath);
+		}
+	}
+	const internalPath = join(dirname(outPath), "_internal.ts");
+	const internalWriteResult = await writeModule(internalPath, internalCode).match(() => Promise.resolve(ok(undefined)), (error) => Promise.resolve(err(error)));
+	if (internalWriteResult.isErr()) {
+		return err(internalWriteResult.error);
+	}
+	const indexWriteResult = await writeModule(outPath, indexCode).match(() => Promise.resolve(ok(undefined)), (error) => Promise.resolve(err(error)));
+	if (indexWriteResult.isErr()) {
+		return err(indexWriteResult.error);
+	}
+	const prebuiltStubPath = join(dirname(outPath), "types.prebuilt.ts");
+	if (!existsSync(prebuiltStubPath)) {
+		const prebuiltStubCode = generatePrebuiltStub(schemaNames);
+		const prebuiltWriteResult = await writeModule(prebuiltStubPath, prebuiltStubCode).match(() => Promise.resolve(ok(undefined)), (error) => Promise.resolve(err(error)));
+		if (prebuiltWriteResult.isErr()) {
+			return err(prebuiltWriteResult.error);
+		}
+	} else {
+		const readResult = readModule(prebuiltStubPath);
+		if (readResult.isErr()) {
+			return err(readResult.error);
+		}
+		const existingContent = readResult.value;
+		const existingNames = new Set();
+		for (const match of existingContent.matchAll(/export type PrebuiltTypes_(\w+)/g)) {
+			const name = match[1];
+			if (name) existingNames.add(name);
+		}
+		const missingNames = schemaNames.filter((name) => !existingNames.has(name));
+		if (missingNames.length > 0) {
+			const missingStubs = generatePrebuiltStub(missingNames);
+			const stubDeclarations = missingStubs.replace(/^\/\*\*[\s\S]*?\*\/\n\n/, "");
+			const updatedContent = `${existingContent.trimEnd()}\n\n${stubDeclarations}`;
+			const patchResult = writeModule(prebuiltStubPath, updatedContent);
+			if (patchResult.isErr()) {
+				return err(patchResult.error);
+			}
+		}
+	}
+	const bundleOutcome = await esbuildBundler.bundle({
+		sourcePath: outPath,
+		external: ["@soda-gql/core", "@soda-gql/core/runtime"]
+	});
+	const bundleResult = bundleOutcome.match((result) => ok(result), (error) => err(error));
+	if (bundleResult.isErr()) {
+		return err(bundleResult.error);
+	}
+	return ok({
+		schemas: schemaHashes,
+		outPath,
+		internalPath,
+		injectsPath,
+		cjsPath: bundleResult.value.cjsPath,
+		...defsPaths.length > 0 ? { defsPaths } : {}
+	});
+};
+
+//#endregion
+export { collectVariableUsages, compileTypeFilter, computeReachabilityFilter, emitFragment, emitOperation, getArgumentType, getFieldReturnType, getInputFieldType, hashSchema, inferVariablesFromUsages, isModifierAssignable, loadSchema, mergeModifiers, mergeVariableUsages, parseGraphqlFile, parseGraphqlSource, parseTypeNode, runCodegen, sortFragmentsByDependency, transformParsedGraphql, writeInjectTemplate };
+//# sourceMappingURL=codegen.mjs.map