@ptdgrp/typedgql 1.0.0-beta.10

package/dist/schema-loader-dDSoNpTn.cjs

@@ -0,0 +1,1929 @@
+let graphql = require("graphql");
+let fs_promises = require("fs/promises");
+let fs = require("fs");
+let path = require("path");
+
+//#region src/codegen/utils.ts
+/**
+* Unwrap NonNull/List wrappers and return the underlying composite type,
+* or `undefined` if the base type is a scalar/enum/input.
+*/
+function targetTypeOf(type) {
+	if (type instanceof graphql.GraphQLNonNull) return targetTypeOf(type.ofType);
+	if (type instanceof graphql.GraphQLList) return targetTypeOf(type.ofType);
+	if (type instanceof graphql.GraphQLObjectType || type instanceof graphql.GraphQLInterfaceType || type instanceof graphql.GraphQLUnionType) return type;
+}
+/**
+* Lower-case the first character of a name for use as a variable/instance prefix.
+* e.g. "QuerySelection" → "querySelection"
+*/
+function instancePrefix(name) {
+	return name.substring(0, 1).toLowerCase() + name.substring(1);
+}
+/**
+* Check whether a type name is in the user's exclusion list.
+*/
+function isExcludedTypeName(options, typeName) {
+	if (typeName == void 0) return false;
+	const list = options.excludedTypes;
+	return list !== void 0 && list.findIndex((v) => v == typeName) !== -1;
+}
+/**
+* Convert a PascalCase or camelCase name to kebab-case.
+* e.g. "TaskSelection" → "task-selection", "EnumInputMetadata" → "enum-input-metadata"
+*/
+function toKebabCase(name) {
+	return name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
+}
+
+//#endregion
+//#region src/codegen/writer.ts
+const SCOPE_BRACKETS = {
+	blank: ["", ""],
+	block: ["{", "}"],
+	parameters: ["(", ")"],
+	array: ["[", "]"],
+	generic: ["<", ">"]
+};
+const SCALAR_MAP = {
+	Boolean: "boolean",
+	Byte: "number",
+	Short: "number",
+	Int: "number",
+	Long: "number",
+	Float: "number",
+	Double: "number",
+	BigInteger: "number",
+	BigDecimal: "number",
+	String: "string",
+	Date: "string",
+	DateTime: "string",
+	LocalDate: "string",
+	LocalDateTime: "string",
+	ID: "string",
+	UUID: "string"
+};
+const GLOBAL_SCOPE = {
+	type: "blank",
+	multiLines: true,
+	dirty: true
+};
+var Writer = class {
+	indent;
+	scopes = [];
+	needIndent = false;
+	importStatements = /* @__PURE__ */ new Set();
+	importedTypes = /* @__PURE__ */ new Set();
+	importedScalarTypes = /* @__PURE__ */ new Map();
+	importFinalized = false;
+	constructor(stream, options) {
+		this.stream = stream;
+		this.options = options;
+		this.indent = options.indent ?? "    ";
+	}
+	/**
+	* Two-phase render lifecycle:
+	* 1) collect imports
+	* 2) flush imports and emit body
+	*/
+	write() {
+		this.prepareImports();
+		this.importFinalized = true;
+		for (const stmt of Array.from(this.importStatements).sort()) {
+			this.stream.write(stmt);
+			this.stream.write("\n");
+		}
+		this.writeNamedTypeImports();
+		this.writeMappedScalarImports();
+		if (this.hasAnyImports) this.stream.write("\n");
+		this.writeCode();
+	}
+	/**
+	* Hook for subclasses to register all imports before body generation.
+	*/
+	prepareImports() {}
+	importFieldTypes(field) {
+		this.importType(field.type);
+		for (const arg of field.args) this.importType(arg.type);
+	}
+	/**
+	* Registers type imports by recursively unwrapping list/non-null wrappers.
+	*/
+	importType(type) {
+		if (this.importFinalized) throw new Error("Cannot import after write phase has started");
+		const namedType = unwrapType(type);
+		if (namedType instanceof graphql.GraphQLInputObjectType || namedType instanceof graphql.GraphQLEnumType) {
+			this.importedTypes.add(namedType);
+			return;
+		}
+		if (namedType instanceof graphql.GraphQLScalarType && this.options.scalarTypeMap) {
+			const mapped = this.options.scalarTypeMap[namedType.name];
+			if (typeof mapped !== "object") return;
+			const set = this.importedScalarTypes.get(mapped.importSource) ?? /* @__PURE__ */ new Set();
+			set.add(mapped.typeName);
+			this.importedScalarTypes.set(mapped.importSource, set);
+		}
+	}
+	importStatement(statement) {
+		if (this.importFinalized) throw new Error("Cannot import after write phase has started");
+		let stmt = statement.trimEnd();
+		if (stmt.endsWith("\n")) stmt = stmt.slice(0, -1);
+		if (!stmt.endsWith(";")) stmt += ";";
+		this.importStatements.add(stmt);
+	}
+	importingBehavior(_type) {
+		return "other_dir";
+	}
+	enter(type, multiLines = false, prefix) {
+		if (prefix) this.text(prefix);
+		const [open] = SCOPE_BRACKETS[type];
+		if (open) this.text(open);
+		if (multiLines) this.text("\n");
+		this.scopes.push({
+			type,
+			multiLines,
+			dirty: false
+		});
+	}
+	leave(suffix) {
+		const scope = this.scopes.pop();
+		if (!scope) throw new Error("No scope to leave");
+		if (scope.multiLines && !this.needIndent) this.text("\n");
+		const [, close] = SCOPE_BRACKETS[scope.type];
+		if (close) this.text(close);
+		if (suffix) this.text(suffix);
+	}
+	scope(args, action) {
+		this.enter(args.type, args.multiLines === true, args.prefix);
+		action();
+		this.leave(args.suffix);
+	}
+	separator(value) {
+		const scope = this.currentScope;
+		if (scope.dirty) {
+			if (value) this.text(value);
+			else if (scope.type === "parameters" || scope.type === "generic") this.text(", ");
+			if (scope.multiLines) this.text("\n");
+		}
+	}
+	text(value) {
+		const lines = value.split("\n");
+		lines.forEach((line, idx) => {
+			if (line) {
+				if (this.needIndent) {
+					this.flushIndent();
+					this.needIndent = false;
+				}
+				this.stream.write(line);
+				this.currentScope.dirty = true;
+			}
+			if (idx < lines.length - 1) {
+				this.stream.write("\n");
+				this.needIndent = true;
+			}
+		});
+	}
+	str(value) {
+		this.text(`'${value}'`);
+	}
+	variableDecl(name, type, overrideObjectTypeName) {
+		this.text(name);
+		if (!(type instanceof graphql.GraphQLNonNull)) this.text("?");
+		this.text(": ");
+		this.typeRef(type, overrideObjectTypeName);
+	}
+	/**
+	* Renders a GraphQL type as TypeScript type syntax.
+	*/
+	typeRef(type, objectRender) {
+		if (type instanceof graphql.GraphQLNonNull) {
+			this.typeRef(type.ofType, objectRender);
+			return;
+		}
+		if (type instanceof graphql.GraphQLList) {
+			const arrayType = this.options.arrayEditable ? "Array" : "ReadonlyArray";
+			this.typeApplication(arrayType, () => {
+				this.typeRef(type.ofType, objectRender);
+				if (!(type.ofType instanceof graphql.GraphQLNonNull)) this.text(" | undefined");
+			});
+			return;
+		}
+		if (type instanceof graphql.GraphQLScalarType) {
+			const mapped = this.options.scalarTypeMap?.[type.name] ?? SCALAR_MAP[type.name];
+			if (!mapped) throw new Error(`Unknown scalar type ${type.name}`);
+			this.text(typeof mapped === "string" ? mapped : mapped.typeName);
+			return;
+		}
+		if (type instanceof graphql.GraphQLEnumType || type instanceof graphql.GraphQLInputObjectType) {
+			this.text(type.name);
+			return;
+		}
+		if (type instanceof graphql.GraphQLObjectType || type instanceof graphql.GraphQLInterfaceType || type instanceof graphql.GraphQLUnionType) {
+			this.writeObjectLikeTypeRef(type, objectRender);
+			return;
+		}
+		const neverType = type;
+		throw new Error(`Unsupported GraphQL type ${neverType.toString()}`);
+	}
+	/**
+	* Renders a GraphQL type in SDL notation, e.g. `[User!]!`.
+	*/
+	gqlTypeRef(type) {
+		if (type instanceof graphql.GraphQLNonNull) {
+			this.gqlTypeRef(type.ofType);
+			this.text("!");
+			return;
+		}
+		if (type instanceof graphql.GraphQLList) {
+			this.text("[");
+			this.gqlTypeRef(type.ofType);
+			this.text("]");
+			return;
+		}
+		if (type instanceof graphql.GraphQLUnionType) {
+			this.writeUnion(type.getTypes().map((itemType) => itemType.name));
+			return;
+		}
+		this.text(type.name);
+	}
+	isUnderGlobalDir() {
+		return false;
+	}
+	writeNamedTypeImports() {
+		const sortedTypes = Array.from(this.importedTypes).sort((a, b) => a.name.localeCompare(b.name));
+		for (const importedType of sortedTypes) {
+			const behavior = this.importingBehavior(importedType);
+			if (behavior === "self") continue;
+			const from = this.resolveTypeImportPath(importedType, behavior);
+			this.stream.write(`import type {${importedType.name}} from '${from}';\n`);
+		}
+	}
+	writeMappedScalarImports() {
+		if (this.importedScalarTypes.size === 0) return;
+		const sourcePrefix = this.isUnderGlobalDir() ? "../" : "../../";
+		const sortedEntries = Array.from(this.importedScalarTypes.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+		for (const [importSource, typeNames] of sortedEntries) this.stream.write(`import type { ${Array.from(typeNames).sort().join(", ")} } from '${sourcePrefix}${importSource}';\n`);
+	}
+	typeApplication(typeName, renderTypeArg) {
+		this.text(`${typeName}<`);
+		renderTypeArg();
+		this.text(">");
+	}
+	resolveTypeImportPath(importedType, behavior) {
+		if (behavior === "same_dir") return ".";
+		const subDir = this.typeSubDir(importedType);
+		return this.isUnderGlobalDir() ? `./${subDir}` : `../${subDir}`;
+	}
+	typeSubDir(importedType) {
+		if (importedType instanceof graphql.GraphQLInputObjectType) return "inputs";
+		if (importedType instanceof graphql.GraphQLEnumType) return "enums";
+		return "selections";
+	}
+	writeObjectLikeTypeRef(type, objectRender) {
+		if (typeof objectRender === "string") {
+			this.text(objectRender);
+			return;
+		}
+		if (type instanceof graphql.GraphQLUnionType) {
+			this.writeUnion(type.getTypes().map((itemType) => itemType.name));
+			return;
+		}
+		if (typeof objectRender !== "function") {
+			this.text(type.name);
+			return;
+		}
+		this.scope({
+			type: "block",
+			multiLines: true
+		}, () => {
+			for (const [fieldName, field] of Object.entries(type.getFields())) {
+				if (!objectRender(type, field)) continue;
+				this.separator(", ");
+				this.text("readonly ");
+				this.text(fieldName);
+				this.text(": ");
+				this.typeRef(field.type, objectRender);
+			}
+		});
+	}
+	get hasAnyImports() {
+		return this.importStatements.size !== 0 || this.importedTypes.size !== 0 || this.importedScalarTypes.size !== 0;
+	}
+	writeUnion(members) {
+		this.enter("blank");
+		for (const member of members) {
+			this.separator(" | ");
+			this.text(member);
+		}
+		this.leave();
+	}
+	flushIndent() {
+		for (const scope of this.scopes) if (scope.multiLines) this.stream.write(this.indent);
+	}
+	get currentScope() {
+		return this.scopes.at(-1) ?? GLOBAL_SCOPE;
+	}
+};
+function unwrapType(type) {
+	if (type instanceof graphql.GraphQLNonNull || type instanceof graphql.GraphQLList) return unwrapType(type.ofType);
+	return type;
+}
+
+//#endregion
+//#region src/codegen/imports.ts
+/**
+* Shared import collector for codegen writers.
+*
+* Responsibilities:
+* - normalize imports by source
+* - deduplicate symbols
+* - keep emitted import statements stable (sorted)
+*/
+var JSImportCollector = class {
+	typeBySource = /* @__PURE__ */ new Map();
+	valueBySource = /* @__PURE__ */ new Map();
+	sideEffects = /* @__PURE__ */ new Set();
+	constructor(sink, sourceMap) {
+		this.sink = sink;
+		this.sourceMap = sourceMap;
+	}
+	useMapped(symbol) {
+		const spec = this.sourceMap[symbol];
+		if (spec.kind === "type") this.useType(spec.source, symbol);
+		else this.useValue(spec.source, symbol);
+	}
+	useType(source, symbol) {
+		this.collect(this.typeBySource, source, symbol);
+	}
+	useValue(source, symbol) {
+		this.collect(this.valueBySource, source, symbol);
+	}
+	useSideEffect(source) {
+		this.sideEffects.add(source);
+	}
+	emit() {
+		for (const [source, symbols] of this.sorted(this.typeBySource)) this.sink(`import type { ${Array.from(symbols).sort().join(", ")} } from '${source}';`);
+		for (const [source, symbols] of this.sorted(this.valueBySource)) this.sink(`import { ${Array.from(symbols).sort().join(", ")} } from '${source}';`);
+		for (const source of Array.from(this.sideEffects).sort()) this.sink(`import '${source}';`);
+	}
+	collect(map, source, symbol) {
+		const set = map.get(source) ?? /* @__PURE__ */ new Set();
+		set.add(symbol);
+		map.set(source, set);
+	}
+	sorted(map) {
+		return Array.from(map.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+	}
+};
+const RUNTIME_ENTRY_SOURCE = "../../dist/index.mjs";
+const TYPE_HIERARCHY_SOURCE = "../type-hierarchy";
+const ENUM_INPUT_METADATA_SOURCE = "../enum-input-metadata";
+const CODEGEN_IMPORT_SOURCE_MAP = {
+	AcceptableVariables: {
+		source: RUNTIME_ENTRY_SOURCE,
+		kind: "type"
+	},
+	UnresolvedVariables: {
+		source: RUNTIME_ENTRY_SOURCE,
+		kind: "type"
+	},
+	DirectiveArgs: {
+		source: RUNTIME_ENTRY_SOURCE,
+		kind: "type"
+	},
+	Selection: {
+		source: RUNTIME_ENTRY_SOURCE,
+		kind: "type"
+	},
+	ValueOrThunk: {
+		source: RUNTIME_ENTRY_SOURCE,
+		kind: "type"
+	},
+	FragmentSpread: {
+		source: RUNTIME_ENTRY_SOURCE,
+		kind: "type"
+	},
+	createSelection: {
+		source: RUNTIME_ENTRY_SOURCE,
+		kind: "value"
+	},
+	withOperationName: {
+		source: RUNTIME_ENTRY_SOURCE,
+		kind: "value"
+	},
+	createSchemaType: {
+		source: RUNTIME_ENTRY_SOURCE,
+		kind: "value"
+	},
+	registerSchemaTypeFactory: {
+		source: RUNTIME_ENTRY_SOURCE,
+		kind: "value"
+	},
+	resolveRegisteredSchemaType: {
+		source: RUNTIME_ENTRY_SOURCE,
+		kind: "value"
+	},
+	ENUM_INPUT_METADATA: {
+		source: ENUM_INPUT_METADATA_SOURCE,
+		kind: "value"
+	},
+	WithTypeName: {
+		source: TYPE_HIERARCHY_SOURCE,
+		kind: "type"
+	},
+	ImplementationType: {
+		source: TYPE_HIERARCHY_SOURCE,
+		kind: "type"
+	},
+	EnumInputMetadataBuilder: {
+		source: "../dist/index.mjs",
+		kind: "value"
+	}
+};
+
+//#endregion
+//#region src/codegen/writers/selection.ts
+var SelectionWriter = class extends Writer {
+	selectionTypeName;
+	defaultSelectionProps;
+	emptySelectionName;
+	defaultSelectionName;
+	fieldMap;
+	fieldArgsMap;
+	fieldCategoryMap;
+	hasArgs;
+	_declaredFieldNames;
+	constructor(modelType, ctx, stream, options) {
+		super(stream, options);
+		this.modelType = modelType;
+		this.ctx = ctx;
+		this.selectionTypeName = `${this.modelType.name}${options.selectionSuffix ?? "Selection"}`;
+		this.fieldMap = this.resolveFieldMap(modelType, options);
+		const analysis = this.analyzeFields(this.fieldMap, modelType, options);
+		this.defaultSelectionProps = analysis.defaultSelectionProps;
+		this.fieldArgsMap = analysis.fieldArgsMap;
+		this.fieldCategoryMap = analysis.fieldCategoryMap;
+		this.hasArgs = analysis.hasArgs;
+		if (isOperationRootTypeName(this.modelType.name)) {
+			const prefix = instancePrefix(this.modelType.name);
+			this.emptySelectionName = `${prefix}$`;
+			this.defaultSelectionName = this.defaultSelectionProps.length !== 0 ? `${prefix}$$` : void 0;
+		} else {
+			this.emptySelectionName = void 0;
+			this.defaultSelectionName = void 0;
+		}
+	}
+	resolveFieldMap(modelType, options) {
+		if (modelType instanceof graphql.GraphQLUnionType) return this.sharedUnionFields(modelType);
+		if (options.excludedTypes === void 0) return modelType.getFields();
+		const filteredFieldMap = {};
+		for (const [fieldName, field] of Object.entries(modelType.getFields())) {
+			const targetTypeName = targetTypeOf(field.type)?.name;
+			if (!isExcludedTypeName(options, targetTypeName)) filteredFieldMap[fieldName] = field;
+		}
+		return filteredFieldMap;
+	}
+	sharedUnionFields(unionType) {
+		const memberTypes = unionType.getTypes();
+		const memberCount = memberTypes.length;
+		if (memberCount === 0) return {};
+		const fieldCounts = /* @__PURE__ */ new Map();
+		for (const type of memberTypes) for (const fieldName of Object.keys(type.getFields())) fieldCounts.set(fieldName, (fieldCounts.get(fieldName) ?? 0) + 1);
+		const shared = {};
+		for (const [fieldName, field] of Object.entries(memberTypes[0].getFields())) if (fieldCounts.get(fieldName) === memberCount) shared[fieldName] = field;
+		return shared;
+	}
+	analyzeFields(fieldMap, modelType, options) {
+		const defaultSelectionProps = [];
+		const fieldArgsMap = /* @__PURE__ */ new Map();
+		const fieldCategoryMap = /* @__PURE__ */ new Map();
+		let hasArgs = false;
+		for (const [fieldName, field] of Object.entries(fieldMap)) {
+			if (this.isDefaultSelectionField(fieldName, field, modelType, options)) defaultSelectionProps.push(fieldName);
+			if (field.args.length !== 0) {
+				hasArgs = true;
+				fieldArgsMap.set(fieldName, [...field.args]);
+			}
+			const category = this.fieldCategory(field);
+			if (category !== void 0) fieldCategoryMap.set(fieldName, category);
+		}
+		return {
+			defaultSelectionProps,
+			fieldArgsMap,
+			fieldCategoryMap,
+			hasArgs
+		};
+	}
+	isDefaultSelectionField(fieldName, field, modelType, options) {
+		if (isOperationRootTypeName(this.modelType.name)) return false;
+		if (targetTypeOf(field.type) !== void 0) return false;
+		if (field.args.length !== 0) return false;
+		if (field.deprecationReason) return false;
+		return !(options.defaultSelectionExcludeMap?.[modelType.name])?.includes(fieldName);
+	}
+	fieldCategory(field) {
+		const fieldCoreType = field.type instanceof graphql.GraphQLNonNull ? field.type.ofType : field.type;
+		if (this.ctx.embeddedTypes.has(fieldCoreType)) return "SCALAR";
+		if (fieldCoreType instanceof graphql.GraphQLList) {
+			const elementType = fieldCoreType.ofType instanceof graphql.GraphQLNonNull ? fieldCoreType.ofType.ofType : fieldCoreType.ofType;
+			if (elementType instanceof graphql.GraphQLObjectType || elementType instanceof graphql.GraphQLInterfaceType || elementType instanceof graphql.GraphQLUnionType) return "LIST";
+			return;
+		}
+		if (fieldCoreType instanceof graphql.GraphQLObjectType || fieldCoreType instanceof graphql.GraphQLInterfaceType || fieldCoreType instanceof graphql.GraphQLUnionType) return "REFERENCE";
+		if (this.ctx.idFieldMap.get(this.modelType) === field) return "ID";
+		return "SCALAR";
+	}
+	prepareImports() {
+		const imports = new JSImportCollector((stmt) => this.importStatement(stmt), CODEGEN_IMPORT_SOURCE_MAP);
+		imports.useMapped("DirectiveArgs");
+		imports.useMapped("Selection");
+		if (this.hasArgs) {
+			imports.useMapped("AcceptableVariables");
+			imports.useMapped("UnresolvedVariables");
+		}
+		imports.useMapped("createSchemaType");
+		imports.useMapped("registerSchemaTypeFactory");
+		const superTypesForResolve = this.ctx.typeHierarchy.upcastTypeMap.get(this.modelType);
+		if (isOperationRootTypeName(this.modelType.name) || superTypesForResolve?.size) imports.useMapped("resolveRegisteredSchemaType");
+		if (isOperationRootTypeName(this.modelType.name)) {
+			imports.useMapped("createSelection");
+			imports.useMapped("ENUM_INPUT_METADATA");
+			imports.useMapped("withOperationName");
+		}
+		if (!isOperationRootTypeName(this.modelType.name)) {
+			imports.useMapped("WithTypeName");
+			imports.useMapped("ImplementationType");
+			imports.useMapped("ValueOrThunk");
+			imports.useMapped("FragmentSpread");
+		}
+		for (const field of Object.values(this.fieldMap)) this.importFieldTypes(field);
+		const importedConcreteSelectionNames = /* @__PURE__ */ new Set();
+		const importedConcreteSelectionModules = /* @__PURE__ */ new Set();
+		const ensureConcreteSelectionTypeImported = (type) => {
+			if (type === this.modelType) return;
+			const selectionTypeName = this.selectionTypeNameForType(type);
+			const selectionModule = `./${toKebabCase(selectionTypeName)}`;
+			if (!importedConcreteSelectionNames.has(selectionTypeName)) {
+				importedConcreteSelectionNames.add(selectionTypeName);
+				imports.useType(selectionModule, selectionTypeName);
+			}
+			if (!importedConcreteSelectionModules.has(selectionModule)) {
+				importedConcreteSelectionModules.add(selectionModule);
+				imports.useSideEffect(selectionModule);
+			}
+		};
+		for (const field of Object.values(this.fieldMap)) {
+			const targetType = targetTypeOf(field.type);
+			if (targetType === void 0 || targetType === this.modelType) continue;
+			ensureConcreteSelectionTypeImported(targetType);
+		}
+		const downcasts = this.ctx.typeHierarchy.downcastTypeMap.get(this.modelType);
+		if (downcasts) for (const downcast of downcasts) ensureConcreteSelectionTypeImported(downcast);
+		const upcastTypes = this.ctx.typeHierarchy.upcastTypeMap.get(this.modelType);
+		if (upcastTypes !== void 0) for (const upcastType of upcastTypes) {
+			const selectionTypeName = `${upcastType.name}${this.options.selectionSuffix ?? "Selection"}`;
+			const importedNames = this.importedNamesForSuperType(upcastType);
+			if (importedNames.length === 0) continue;
+			const importSource = `./${toKebabCase(selectionTypeName)}`;
+			for (const importedName of importedNames) imports.useValue(importSource, importedName);
+		}
+		imports.emit();
+	}
+	importedNamesForSuperType(superType) {
+		if (isOperationRootTypeName(superType.name)) return [`${instancePrefix(superType.name)}$`];
+		return [];
+	}
+	importingBehavior(type) {
+		if (type === this.modelType) return "self";
+		if (type instanceof graphql.GraphQLObjectType || type instanceof graphql.GraphQLInterfaceType) return "same_dir";
+		return "other_dir";
+	}
+	writeCode() {
+		this.text(COMMENT$1);
+		this.writeSelectionInterface();
+		this.writeInstances();
+		this.writeArgsInterface();
+	}
+	writeSelectionInterface() {
+		this.writeSelectionInterfaceHeader();
+		this.scope({
+			type: "block",
+			multiLines: true,
+			suffix: "\n"
+		}, () => {
+			this.writeSelectionInterfaceBody();
+		});
+	}
+	writeSelectionInterfaceHeader() {
+		const superSelection = this.superSelectionTypeName(this.modelType);
+		this.text(`export interface ${this.selectionTypeName}<T extends object = {}, TVariables extends object = {}, TLastField extends string = never> extends ${superSelection}<'${this.modelType.name}', T, TVariables> `);
+	}
+	writeSelectionInterfaceBody() {
+		this.writeFragmentMethods();
+		this.writeDirectiveBuiltins();
+		this.write$omit();
+		this.write$alias();
+		this.writeTypeName();
+		const fields = Object.values(this.fieldMap);
+		for (const field of fields) {
+			this.text("\n");
+			this.writePositiveProp(field);
+		}
+	}
+	writeFragmentMethods() {
+		if (isOperationRootTypeName(this.modelType.name)) return;
+		const t = this.text.bind(this);
+		const modelName = this.modelType.name;
+		const selfSelectionType = this.selectionTypeName;
+		const fragmentTypeName = `ImplementationType<'${modelName}'>`;
+		const inlineSelectionFor = (xName, data, vars) => this.fragmentSelectionTypeForModel(xName, data, vars);
+		const resultDataType = `XName extends '${modelName}' ?\nT & X :\nWithTypeName<T, ${fragmentTypeName}> & (WithTypeName<X, ImplementationType<XName>> | {__typename: Exclude<${fragmentTypeName}, ImplementationType<XName>>})`;
+		t("\n$on<X extends object, XVariables extends object>");
+		this.scope({
+			type: "parameters",
+			multiLines: true
+		}, () => {
+			t(`builder: (it: ${selfSelectionType}<{}, {}>) => ${selfSelectionType}<X, XVariables>`);
+		});
+		t(`: ${this.selectionTypeName}`);
+		this.scope({
+			type: "generic",
+			multiLines: true
+		}, () => {
+			t("T & X");
+			this.separator(", ");
+			t("TVariables & XVariables");
+		});
+		t(";\n");
+		t(`\n$on<XName extends ${fragmentTypeName}, X extends object, XVariables extends object>`);
+		this.scope({
+			type: "parameters",
+			multiLines: true
+		}, () => {
+			t("typeName: XName");
+			this.separator(", ");
+			t(`builder: (it: ${inlineSelectionFor("XName", "{}", "{}")}) => ${inlineSelectionFor("XName", "X", "XVariables")}`);
+		});
+		t(`: ${this.selectionTypeName}`);
+		this.scope({
+			type: "generic",
+			multiLines: true
+		}, () => {
+			t(resultDataType);
+			this.separator(", ");
+			t("TVariables & XVariables");
+		});
+		t(";\n");
+		t(`\n$use<XName extends ${fragmentTypeName}, X extends object, XVariables extends object>`);
+		this.scope({
+			type: "parameters",
+			multiLines: true
+		}, () => {
+			t("fragment: ValueOrThunk<FragmentSpread<string, XName, X, XVariables>>");
+		});
+		t(`: ${this.selectionTypeName}`);
+		this.scope({
+			type: "generic",
+			multiLines: true
+		}, () => {
+			t(resultDataType);
+			this.separator(", ");
+			t("TVariables & XVariables");
+		});
+		t(";\n");
+	}
+	fragmentSelectionTypeForModel(xNameRef, dataType, variableType) {
+		const branches = [];
+		const selectionTypeByName = /* @__PURE__ */ new Map();
+		selectionTypeByName.set(this.modelType.name, this.selectionTypeName);
+		const downcasts = this.ctx.typeHierarchy.downcastTypeMap.get(this.modelType);
+		if (downcasts) for (const t of downcasts) selectionTypeByName.set(t.name, this.selectionTypeNameForType(t));
+		for (const [typeName, selectionTypeName] of selectionTypeByName) branches.push(`${xNameRef} extends '${typeName}' ? ${selectionTypeName}<${dataType}, ${variableType}> :`);
+		branches.push("never");
+		return branches.join("\n");
+	}
+	writeDirectiveBuiltins() {
+		const t = this.text.bind(this);
+		t("\n\n$directive(name: string, args?: DirectiveArgs): ");
+		this.writeFieldAwareSelectionReturnType();
+		t(";\n");
+		t("\n$include(condition: unknown): ");
+		this.writeFieldAwareSelectionReturnType();
+		t(";\n");
+		t("\n$skip(condition: unknown): ");
+		this.writeFieldAwareSelectionReturnType();
+		t(";\n");
+	}
+	writeFieldAwareSelectionReturnType() {
+		const t = this.text.bind(this);
+		t(this.selectionTypeName);
+		this.scope({
+			type: "generic",
+			multiLines: true
+		}, () => {
+			t("TLastField extends keyof T ? Omit<T, TLastField> & {readonly [key in TLastField]?: T[key]} : T");
+			this.separator(", ");
+			t("TVariables");
+			this.separator(", ");
+			t("TLastField");
+		});
+	}
+	writeTypeName() {
+		if (!isOperationRootTypeName(this.modelType.name)) {
+			const t = this.text.bind(this);
+			t("\n\n");
+			t("readonly __typename: ");
+			t(this.selectionTypeName);
+			t("<T & {__typename: ImplementationType<'");
+			t(this.modelType.name);
+			t("'>}, TVariables>;\n");
+		}
+	}
+	writePositiveProp(field) {
+		const targetType = targetTypeOf(field.type);
+		if (targetType !== void 0) this.writeAssociationProp(field, targetType);
+		else {
+			this.writePositivePropImpl(field, "SIMPLEST");
+			this.writePositivePropImpl(field, "WITH_ARGS");
+		}
+	}
+	writeAssociationProp(field, targetType) {
+		if (field.args.length === 0) {
+			this.writeAssociationPropImpl(field, targetType, false);
+			return;
+		}
+		this.writeAssociationPropImpl(field, targetType, true);
+		this.writeAssociationPropImpl(field, targetType, false);
+	}
+	writeAssociationPropImpl(field, targetType, withArgs) {
+		const t = this.text.bind(this);
+		const nonNull = field.type instanceof graphql.GraphQLNonNull;
+		const isPlural = field.type instanceof graphql.GraphQLNonNull ? field.type.ofType instanceof graphql.GraphQLList : field.type instanceof graphql.GraphQLList;
+		const childSelectionType = this.selectionTypeNameForType(targetType);
+		t("\n");
+		this.writeFieldDocComment(field);
+		t(field.name);
+		this.scope({
+			type: "generic",
+			multiLines: true
+		}, () => {
+			if (withArgs) {
+				t(`XArgs extends AcceptableVariables<${this.modelType.name}Args['${field.name}']>`);
+				this.separator(", ");
+			}
+			t("X extends object");
+			this.separator(", ");
+			t("XVariables extends object");
+		});
+		this.scope({
+			type: "parameters",
+			multiLines: true
+		}, () => {
+			if (withArgs) {
+				t("args: XArgs");
+				this.separator(", ");
+			}
+			t("selection: ");
+			this.scope({
+				type: "parameters",
+				multiLines: false
+			}, () => {
+				t(`selection: ${childSelectionType}<{}, {}>`);
+			});
+			t(` => ${childSelectionType}<X, XVariables>`);
+		});
+		t(`: ${this.selectionTypeName}`);
+		this.scope({
+			type: "generic",
+			multiLines: true,
+			suffix: ";\n"
+		}, () => {
+			t("T & {");
+			if (!this.options.objectEditable) t("readonly ");
+			t(`"${field.name}"`);
+			if (!nonNull) t("?");
+			t(": ");
+			if (isPlural) t("ReadonlyArray<X>");
+			else t("X");
+			t("}");
+			this.separator(", ");
+			t("TVariables & XVariables");
+			if (withArgs) t(` & UnresolvedVariables<XArgs, ${this.modelType.name}Args['${field.name}']>`);
+			else if (field.args.length !== 0) t(` & ${this.modelType.name}Args["${field.name}"]`);
+			this.separator(", ");
+			t(`"${field.name}"`);
+		});
+	}
+	write$omit() {
+		const omittableFields = [];
+		for (const [fieldName, field] of Object.entries(this.fieldMap)) if (field.args.length === 0 && targetTypeOf(field.type) === void 0) omittableFields.push(fieldName);
+		if (omittableFields.length === 0) return;
+		const t = this.text.bind(this);
+		t("\n\n$omit<XOmit extends ");
+		t(omittableFields.map((f) => `"${f}"`).join(" | "));
+		t(">");
+		this.scope({
+			type: "parameters",
+			multiLines: false
+		}, () => {
+			t("...fields: XOmit[]");
+		});
+		t(": ");
+		t(this.selectionTypeName);
+		t("<Omit<T, XOmit>, TVariables>;\n");
+	}
+	write$alias() {
+		if (this.getScalarFieldNames().length === 0) return;
+		const t = this.text.bind(this);
+		t("\n$alias<XAlias extends string>");
+		t("(");
+		t("alias: XAlias");
+		t("): ");
+		t(this.selectionTypeName);
+		t("<TLastField extends keyof T ? Omit<T, TLastField> & {readonly [key in XAlias]: T[TLastField]} : T, TVariables>;\n");
+	}
+	getScalarFieldNames() {
+		const fields = [];
+		for (const [fieldName, field] of Object.entries(this.fieldMap)) if (field.args.length === 0 && targetTypeOf(field.type) === void 0) fields.push(fieldName);
+		return fields;
+	}
+	writePositivePropImpl(field, mode) {
+		const withArgs = mode === "WITH_ARGS";
+		if (withArgs && field.args.length === 0) return;
+		const targetType = targetTypeOf(field.type);
+		const renderAsField = field.args.length === 0 && targetType === void 0;
+		const nonNull = field.type instanceof graphql.GraphQLNonNull;
+		const t = this.text.bind(this);
+		t("\n");
+		this.writeFieldDocComment(field);
+		if (renderAsField) {
+			t("readonly ");
+			t(field.name);
+		} else {
+			t(field.name);
+			if (withArgs || targetType !== void 0) this.scope({
+				type: "generic",
+				multiLines: true
+			}, () => {
+				if (withArgs) {
+					this.separator(", ");
+					t(`XArgs extends AcceptableVariables<${this.modelType.name}Args['${field.name}']>`);
+				}
+				if (targetType !== void 0) {
+					this.separator(", ");
+					t("X extends object");
+					this.separator(", ");
+					t("XVariables extends object");
+				}
+			});
+			this.scope({
+				type: "parameters",
+				multiLines: true
+			}, () => {
+				if (withArgs) {
+					this.separator(", ");
+					t("args: XArgs");
+				}
+				if (targetType !== void 0) {
+					this.separator(", ");
+					t("child: ");
+					t(this.superSelectionTypeName(targetType));
+					t("<'");
+					t(targetType.name);
+					t("', X, XVariables>");
+				}
+			});
+		}
+		t(": ");
+		t(this.selectionTypeName);
+		this.scope({
+			type: "generic",
+			multiLines: !renderAsField,
+			suffix: ";\n"
+		}, () => {
+			t("T & ");
+			this.writePositivePropChangedDataType(field, false, !nonNull);
+			this.separator(", ");
+			t("TVariables");
+			if (targetType !== void 0) t(" & XVariables");
+			if (field.args.length !== 0) if (withArgs) t(` & UnresolvedVariables<XArgs, ${this.modelType.name}Args['${field.name}']>`);
+			else t(` & ${this.modelType.name}Args["${field.name}"]`);
+			this.separator(", ");
+			t(`"${field.name}"`);
+		});
+	}
+	writePositivePropChangedDataType(field, withOptions, nullable) {
+		const t = this.text.bind(this);
+		t("{");
+		if (!this.options.objectEditable) t("readonly ");
+		if (withOptions) t(`[key in XAlias]`);
+		else t(`"${field.name}"`);
+		if (nullable) t("?");
+		t(": ");
+		this.typeRef(field.type, targetTypeOf(field.type) !== void 0 ? "X" : void 0);
+		t("}");
+	}
+	writeFieldDocComment(field) {
+		const description = field.description?.trim();
+		const deprecationReason = field.deprecationReason?.trim();
+		if (!description && !deprecationReason) return;
+		const t = this.text.bind(this);
+		t("/**\n");
+		if (description) for (const line of this.escapeJsDoc(description).split("\n")) {
+			t(" * ");
+			t(line);
+			t("\n");
+		}
+		if (deprecationReason) {
+			t(" * @deprecated ");
+			t(this.escapeJsDoc(deprecationReason));
+			t("\n");
+		}
+		t(" */\n");
+	}
+	escapeJsDoc(value) {
+		return value.replaceAll("*/", "*\\/");
+	}
+	writeInstances() {
+		const t = this.text.bind(this);
+		t("\nregisterSchemaTypeFactory(");
+		this.str(this.modelType.name);
+		t(", () => ");
+		this.writeSchemaTypeForModelType();
+		t(");\n");
+		const emptySelectionName = this.emptySelectionName;
+		if (!emptySelectionName) return;
+		const itemTypes = this.modelType instanceof graphql.GraphQLUnionType ? this.modelType.getTypes() : [];
+		t("\nexport function ");
+		t(emptySelectionName);
+		t("<T extends object = {}, TVariables extends object = {}>(");
+		t(`builder: (it: ${this.selectionTypeName}<{}, {}>) => ${this.selectionTypeName}<T, TVariables>`);
+		t(", operationName?: string");
+		t("): ");
+		t(this.selectionTypeName);
+		t("<T, TVariables> ");
+		this.scope({
+			type: "block",
+			multiLines: true,
+			suffix: "\n"
+		}, () => {
+			t("const selection = builder(");
+			this.scope({
+				type: "blank",
+				multiLines: true
+			}, () => {
+				t("createSelection");
+				this.scope({
+					type: "parameters",
+					multiLines: true
+				}, () => {
+					t(`resolveRegisteredSchemaType("${this.modelType.name}")!`);
+					this.separator(", ");
+					this.text("ENUM_INPUT_METADATA");
+					this.separator(", ");
+					if (itemTypes.length === 0) t("undefined");
+					else this.scope({
+						type: "array",
+						multiLines: itemTypes.length >= 2
+					}, () => {
+						for (const itemType of itemTypes) {
+							this.separator(", ");
+							this.str(itemType.name);
+						}
+					});
+				});
+			});
+			t(");\n");
+			t("return withOperationName(selection, operationName);\n");
+		});
+		if (this.defaultSelectionName !== void 0) {
+			t("\nexport const ");
+			t(this.defaultSelectionName);
+			t(" = ");
+			this.enter("blank", true);
+			t(emptySelectionName);
+			this.enter("blank", true);
+			for (const propName of this.defaultSelectionProps) {
+				t(".");
+				t(propName);
+				t("\n");
+			}
+			this.leave();
+			this.leave(";\n");
+		}
+	}
+	writeSchemaTypeForModelType() {
+		const t = this.text.bind(this);
+		t("createSchemaType");
+		this.scope({
+			type: "parameters",
+			multiLines: true
+		}, () => {
+			t(`"${this.modelType.name}"`);
+			this.separator(", ");
+			t(this.schemaTypeCategory(this.modelType));
+			this.separator(", ");
+			this.scope({ type: "array" }, () => {
+				const upcastTypes = this.ctx.typeHierarchy.upcastTypeMap.get(this.modelType);
+				if (upcastTypes !== void 0) for (const upcastType of upcastTypes) {
+					this.separator(", ");
+					t(`resolveRegisteredSchemaType("${upcastType.name}")!`);
+				}
+			});
+			this.separator(", ");
+			this.scope({
+				type: "array",
+				multiLines: true
+			}, () => {
+				for (const fieldName of this.declaredFieldNames) {
+					this.separator(", ");
+					this.writeSchemaFieldDescriptor(this.fieldMap[fieldName]);
+				}
+			});
+		});
+	}
+	writeSchemaFieldDescriptor(field) {
+		const t = this.text.bind(this);
+		const args = this.fieldArgsMap.get(field.name);
+		const category = this.fieldCategoryMap.get(field.name);
+		const targetType = targetTypeOf(field.type);
+		if (args === void 0 && (category === void 0 || category === "SCALAR") && field.type instanceof graphql.GraphQLNonNull && targetType === void 0) {
+			t(`"${field.name}"`);
+			return;
+		}
+		this.scope({
+			type: "block",
+			multiLines: true
+		}, () => {
+			t(`category: "${category ?? "SCALAR"}"`);
+			this.separator(", ");
+			t(`name: "${field.name}"`);
+			if (args !== void 0) {
+				this.separator(", ");
+				t("argGraphQLTypeMap: ");
+				this.scope({
+					type: "block",
+					multiLines: args.length > 1
+				}, () => {
+					for (const arg of args) {
+						this.separator(", ");
+						t(arg.name);
+						t(": '");
+						this.gqlTypeRef(arg.type);
+						t("'");
+					}
+				});
+			}
+			if (targetType !== void 0) {
+				this.separator(", ");
+				t(`targetTypeName: "${targetType.name}"`);
+			}
+			if (!(field.type instanceof graphql.GraphQLNonNull)) {
+				this.separator(", ");
+				t("undefinable: true");
+			}
+		});
+	}
+	schemaTypeCategory(type) {
+		if (this.ctx.embeddedTypes.has(type)) return "\"EMBEDDED\"";
+		return "\"OBJECT\"";
+	}
+	writeArgsInterface() {
+		if (!this.hasArgs) return;
+		const t = this.text.bind(this);
+		t(`\nexport interface ${this.modelType.name}Args `);
+		this.scope({
+			type: "block",
+			multiLines: true,
+			suffix: "\n"
+		}, () => {
+			for (const field of Object.values(this.fieldMap)) if (field.args.length !== 0) {
+				this.separator(", ");
+				t(`\nreadonly ${field.name}: `);
+				this.scope({
+					type: "block",
+					multiLines: true
+				}, () => {
+					for (const arg of field.args) {
+						this.separator(", ");
+						t("readonly ");
+						t(arg.name);
+						if (!(arg.type instanceof graphql.GraphQLNonNull)) t("?");
+						t(": ");
+						this.typeRef(arg.type);
+					}
+				});
+			}
+		});
+	}
+	get declaredFieldNames() {
+		let set = this._declaredFieldNames;
+		if (set === void 0) this._declaredFieldNames = set = this.getDeclaredFieldNames();
+		return set;
+	}
+	getDeclaredFieldNames() {
+		const fields = /* @__PURE__ */ new Set();
+		if (this.modelType instanceof graphql.GraphQLObjectType || this.modelType instanceof graphql.GraphQLInterfaceType) {
+			for (const field of Object.values(this.fieldMap)) fields.add(field.name);
+			this.removeSuperFieldNames(fields, this.ctx.typeHierarchy.upcastTypeMap.get(this.modelType));
+		} else if (this.modelType instanceof graphql.GraphQLUnionType) for (const fieldName of Object.keys(this.fieldMap)) fields.add(fieldName);
+		return fields;
+	}
+	removeSuperFieldNames(fields, superTypes) {
+		if (superTypes !== void 0) for (const superType of superTypes) {
+			if (superType instanceof graphql.GraphQLObjectType || superType instanceof graphql.GraphQLInterfaceType) {
+				const superFieldMap = superType.getFields();
+				for (const superFieldName in superFieldMap) fields.delete(superFieldName);
+			}
+			this.removeSuperFieldNames(fields, this.ctx.typeHierarchy.upcastTypeMap.get(superType));
+		}
+	}
+	superSelectionTypeName(_graphQLType) {
+		return "Selection";
+	}
+	selectionTypeNameForType(graphQLType) {
+		return `${graphQLType.name}${this.options.selectionSuffix ?? "Selection"}`;
+	}
+};
+const isOperationRootTypeName = (name) => {
+	return name === "Query" || name === "Mutation" || name === "Subscription";
+};
+const COMMENT$1 = `/*
+ * Any instance of this interface is immutable,
+ * all the properties and functions can only be used to create new instances,
+ * they cannot modify the current instance.
+ * 
+ * So any instance of this interface is reuseable.
+ */
+`;
+
+//#endregion
+//#region src/codegen/writers/enum.ts
+var EnumWriter = class extends Writer {
+	constructor(enumType, stream, options) {
+		super(stream, options);
+		this.enumType = enumType;
+	}
+	writeCode() {
+		const t = this.text.bind(this);
+		const values = this.enumType.getValues();
+		if (this.options.tsEnum === true || this.options.tsEnum === "number" || this.options.tsEnum === "string") {
+			t("export enum ");
+			t(this.enumType.name);
+			this.scope({
+				type: "block",
+				prefix: " ",
+				suffix: "\n",
+				multiLines: values.length > 3
+			}, () => {
+				for (const value of values) {
+					this.separator(", ");
+					if (this.options.tsEnum === "string") {
+						t(value.name);
+						t(" = ");
+						t("'");
+						t(value.name);
+						t("'");
+					} else t(value.name);
+				}
+			});
+		} else {
+			t("export type ");
+			t(this.enumType.name);
+			t(" = ");
+			this.scope({
+				type: "blank",
+				suffix: ";\n",
+				multiLines: values.length > 3
+			}, () => {
+				for (const value of values) {
+					this.separator(" | ");
+					t("'");
+					t(value.name);
+					t("'");
+				}
+			});
+		}
+	}
+};
+
+//#endregion
+//#region src/codegen/writers/input.ts
+var InputWriter = class extends Writer {
+	constructor(inputType, stream, options) {
+		super(stream, options);
+		this.inputType = inputType;
+	}
+	prepareImports() {
+		for (const field of Object.values(this.inputType.getFields())) this.importType(field.type);
+	}
+	importingBehavior(type) {
+		if (type === this.inputType) return "self";
+		if (type instanceof graphql.GraphQLInputObjectType) return "same_dir";
+		return "other_dir";
+	}
+	writeCode() {
+		this.text(COMMENT);
+		this.text("export type ");
+		this.text(this.inputType.name);
+		this.text(" = ");
+		const fieldMap = this.inputType.getFields();
+		if (this.inputType.isOneOf) {
+			this.writeOneOfType(fieldMap);
+			return;
+		}
+		this.enter("block", true);
+		for (const field of Object.values(fieldMap)) this.writeRegularField(field);
+		this.leave("\n");
+	}
+	writeOneOfType(fieldMap) {
+		const fieldNames = Object.keys(fieldMap);
+		if (fieldNames.length === 0) {
+			this.text("{}\n");
+			return;
+		}
+		fieldNames.forEach((selectedFieldName, idx) => {
+			const selectedField = fieldMap[selectedFieldName];
+			if (idx > 0) this.text(" | ");
+			this.enter("block", true);
+			for (const fieldName of fieldNames) {
+				if (!this.options.objectEditable) this.text("readonly ");
+				const field = fieldMap[fieldName];
+				this.text(field.name);
+				if (fieldName === selectedFieldName) {
+					this.text(": Exclude<");
+					this.typeRef(selectedField.type);
+					this.text(", undefined>;\n");
+				} else this.text("?: never;\n");
+			}
+			this.leave();
+		});
+		this.text("\n");
+	}
+	writeRegularField(field) {
+		if (!this.options.objectEditable) this.text("readonly ");
+		this.text(field.name);
+		if (!(field.type instanceof graphql.GraphQLNonNull)) this.text("?");
+		this.text(": ");
+		this.typeRef(field.type);
+		this.text(";\n");
+	}
+};
+const COMMENT = `/*
+ * This input type is not interface, because interfaces 
+ * do not satisfy the constraint 'SerializableParam' of recoil
+ */
+`;
+
+//#endregion
+//#region src/codegen/writers/types.ts
+var TypeHierarchyWriter = class extends Writer {
+	constructor(_schema, typeHierarchy, stream, options) {
+		super(stream, options);
+		this.typeHierarchy = typeHierarchy;
+	}
+	writeCode() {
+		this.writeImplementationType();
+		this.writeCastMethod("up");
+		this.writeCastMethod("down");
+		this.writeWithTypeNameType();
+	}
+	writeWithTypeNameType() {
+		this.text(WITH_TYPE_NAME_DECLARATION);
+		this.text("\n");
+	}
+	writeImplementationType() {
+		const t = this.text.bind(this);
+		const entries = [...this.typeHierarchy.downcastTypeMap.entries()];
+		t(IMPLEMENTATION_TYPE_COMMENT);
+		t("export type ImplementationType<T> = ");
+		this.enter("blank", true);
+		for (const [type, castTypes] of entries) {
+			if (isExcludedTypeName(this.options, type.name)) continue;
+			t(`T extends '${type.name}' ? `);
+			this.enter("blank");
+			if (!(type instanceof graphql.GraphQLUnionType)) t(`'${type.name}'`);
+			for (const castType of castTypes) {
+				if (isExcludedTypeName(this.options, castType.name)) continue;
+				this.separator(" | ");
+				t(`ImplementationType<'${castType.name}'>`);
+			}
+			this.leave();
+			t(" :\n");
+		}
+		t("T\n");
+		this.leave();
+		t(";");
+	}
+	writeCastMethod(prefix) {
+		const t = this.text.bind(this);
+		const entries = [...(prefix === "up" ? this.typeHierarchy.upcastTypeMap : this.typeHierarchy.downcastTypeMap).entries()];
+		t(prefix === "up" ? UPCAST_FUNC_COMMENT : DOWNCAST_FUNC_COMMENT);
+		t(`\nexport function ${prefix}castTypes(typeName: string): string[] `);
+		this.scope({
+			type: "block",
+			multiLines: true,
+			suffix: "\n"
+		}, () => {
+			t("const typeNames: string[] = [];\n");
+			t(`${prefix}castTypes0(typeName, typeNames);\n`);
+			t("return typeNames;\n");
+		});
+		t(`\nfunction ${prefix}castTypes0(typeName: string, output: string[]) `);
+		this.scope({
+			type: "block",
+			multiLines: true,
+			suffix: "\n"
+		}, () => {
+			t("switch (typeName)");
+			this.scope({
+				type: "block",
+				multiLines: true,
+				suffix: "\n"
+			}, () => {
+				for (const [type, castTypes] of entries) {
+					if (isExcludedTypeName(this.options, type.name)) continue;
+					t(`case '${type.name}':`);
+					this.scope({
+						type: "blank",
+						multiLines: true
+					}, () => {
+						if (!(type instanceof graphql.GraphQLUnionType)) t(`output.push('${type.name}');\n`);
+						for (const castType of castTypes) {
+							if (isExcludedTypeName(this.options, castType.name)) continue;
+							t(`${prefix}castTypes0('${castType.name}', output);\n`);
+						}
+						t("break;\n");
+					});
+				}
+				t("default:");
+				this.scope({
+					type: "blank",
+					multiLines: true
+				}, () => {
+					t(`output.push(typeName);\n`);
+					t("break;\n");
+				});
+			});
+		});
+	}
+};
+const IMPLEMENTATION_TYPE_COMMENT = `
+/**
+ * This 'ImplementationType' is used for type hierarchy resolution.
+ */
+`;
+const UPCAST_FUNC_COMMENT = `
+/**
+ * This 'upcastTypes' resolves parent types in the type hierarchy.
+ */
+`;
+const DOWNCAST_FUNC_COMMENT = `
+/**
+ * This 'downcastTypes' resolves child types in the type hierarchy.
+ */
+`;
+const WITH_TYPE_NAME_DECLARATION = `
+export type WithTypeName<T, TypeName extends string> =
+    T extends {readonly __typename: string} ?
+    T :
+    T & {readonly __typename: TypeName};
+;
+`;
+
+//#endregion
+//#region src/codegen/type-hierarchy-graph.ts
+/** Get-or-create a Set in a Map, then add a value to it. */
+function addToSetMap(map, key, value) {
+	let set = map.get(key);
+	if (!set) {
+		set = /* @__PURE__ */ new Set();
+		map.set(key, set);
+	}
+	set.add(value);
+}
+/**
+* Remove transitive (indirect) entries from the downcast map so that
+* each parent only lists its *direct* children.
+*
+* For example given A → B → C, the entry for A should only contain B,
+* not C (because C is reachable through B).
+*/
+function pruneTransitive(map) {
+	for (const [, children] of map) removeReachable(children, children, map);
+}
+function removeReachable(target, current, map) {
+	for (const type of current) {
+		if (target !== current) target.delete(type);
+		const deeper = map.get(type);
+		if (deeper) removeReachable(target, deeper, map);
+	}
+}
+/** Invert a parent→children map into a child→parents map. */
+function invertMap(map) {
+	const inverted = /* @__PURE__ */ new Map();
+	for (const [parent, children] of map) for (const child of children) addToSetMap(inverted, child, parent);
+	return inverted;
+}
+var TypeHierarchyGraph = class {
+	/** parent → direct children (interface → implementors, union → members) */
+	downcastTypeMap;
+	/** child → direct parents */
+	upcastTypeMap;
+	constructor(schema) {
+		const downcast = /* @__PURE__ */ new Map();
+		const typeMap = schema.getTypeMap();
+		for (const typeName in typeMap) {
+			if (typeName.startsWith("__")) continue;
+			const type = typeMap[typeName];
+			if (type instanceof graphql.GraphQLObjectType || type instanceof graphql.GraphQLInterfaceType) for (const iface of type.getInterfaces()) addToSetMap(downcast, iface, type);
+			if (type instanceof graphql.GraphQLUnionType) for (const member of type.getTypes()) addToSetMap(downcast, type, member);
+		}
+		pruneTransitive(downcast);
+		this.downcastTypeMap = downcast;
+		this.upcastTypeMap = invertMap(downcast);
+	}
+	/** Walk ancestor types recursively, calling `callback` for each. */
+	visitUpcastTypesRecursively(type, callback) {
+		const parents = this.upcastTypeMap.get(type);
+		if (!parents) return;
+		for (const parent of parents) {
+			callback(parent);
+			this.visitUpcastTypesRecursively(parent, callback);
+		}
+	}
+};
+
+//#endregion
+//#region src/codegen/writers/enum-input-metadata.ts
+var EnumInputMetadataWriter = class EnumInputMetadataWriter extends Writer {
+	constructor(schema, stream, options) {
+		super(stream, options);
+		this.schema = schema;
+	}
+	prepareImports() {
+		const imports = new JSImportCollector((stmt) => this.importStatement(stmt), CODEGEN_IMPORT_SOURCE_MAP);
+		imports.useMapped("EnumInputMetadataBuilder");
+		imports.emit();
+	}
+	writeCode() {
+		const processedTypeNames = /* @__PURE__ */ new Set();
+		const enumInputMetaTypeMap = /* @__PURE__ */ new Map();
+		for (const type of Object.values(this.schema.getTypeMap())) {
+			if (!(type instanceof graphql.GraphQLEnumType) && !(type instanceof graphql.GraphQLInputObjectType)) continue;
+			this.collectEnumMetaTypes(type, processedTypeNames, enumInputMetaTypeMap);
+		}
+		this.text("const builder = new EnumInputMetadataBuilder();\n");
+		for (const [typeName, fields] of enumInputMetaTypeMap) {
+			this.text(`\nbuilder.add("${typeName}"`);
+			if (fields !== void 0) {
+				this.text(", ");
+				this.scope({
+					type: "array",
+					multiLines: true
+				}, () => {
+					for (const field of fields) {
+						this.separator(", ");
+						this.scope({ type: "block" }, () => {
+							this.text(`name: "${field.name}", typeName: "${EnumInputMetadataWriter.inputTypeName(field.type)}", graphqlTypeName: "${EnumInputMetadataWriter.graphqlTypeName(field.type)}"`);
+							if (EnumInputMetadataWriter.isLeafInputType(field.type)) this.text(", isLeaf: true");
+						});
+					}
+				});
+			}
+			this.text(");\n");
+		}
+		this.text("\nexport const ENUM_INPUT_METADATA = builder.build();\n");
+	}
+	collectEnumMetaTypes(type, processedTypeNames, outMap) {
+		if (type instanceof graphql.GraphQLScalarType) return false;
+		if (type instanceof graphql.GraphQLList || type instanceof graphql.GraphQLNonNull) return this.collectEnumMetaTypes(type.ofType, processedTypeNames, outMap);
+		if (type.name.startsWith("__")) return false;
+		if (outMap.has(type.name)) return true;
+		if (processedTypeNames.has(type.name)) return false;
+		if (type instanceof graphql.GraphQLEnumType) {
+			outMap.set(type.name, void 0);
+			return true;
+		}
+		processedTypeNames.add(type.name);
+		const fieldMap = type.getFields();
+		const fields = [];
+		for (const field of Object.values(fieldMap)) {
+			this.collectEnumMetaTypes(field.type, processedTypeNames, outMap);
+			fields.push(field);
+		}
+		outMap.set(type.name, fields);
+		return true;
+	}
+	static inputTypeName(type) {
+		if (type instanceof graphql.GraphQLList) return EnumInputMetadataWriter.inputTypeName(type.ofType);
+		if (type instanceof graphql.GraphQLNonNull) return EnumInputMetadataWriter.inputTypeName(type.ofType);
+		return type.name;
+	}
+	static graphqlTypeName(type) {
+		if (type instanceof graphql.GraphQLList) return `[${EnumInputMetadataWriter.graphqlTypeName(type.ofType)}]`;
+		if (type instanceof graphql.GraphQLNonNull) return `${EnumInputMetadataWriter.graphqlTypeName(type.ofType)}!`;
+		return type.name;
+	}
+	static isLeafInputType(type) {
+		if (type instanceof graphql.GraphQLList || type instanceof graphql.GraphQLNonNull) return EnumInputMetadataWriter.isLeafInputType(type.ofType);
+		return type instanceof graphql.GraphQLScalarType;
+	}
+};
+
+//#endregion
+//#region \0raw:/Users/ashen/Projects/typedgql/src/codegen/templates/async-runtime.template
+var async_runtime_default = "import type { Selection } from \"../dist/index.mjs\";\nimport { TextBuilder, runtimeOf } from \"../dist/index.mjs\";\n\nexport type GraphQLExecutor = (\n  request: string,\n  variables: Record<string, unknown>,\n) => Promise<any>;\n\nexport type GraphQLSubscriber = (\n  request: string,\n  variables: Record<string, unknown>,\n) => AsyncIterable<any> | Promise<AsyncIterable<any>>;\n\n// Set global fallback executor used by `execute(...)`.\nexport function setGraphQLExecutor(executor: GraphQLExecutor) {\n  graphQLExecutor = executor;\n}\n\n// Set global fallback subscriber used by `subscribe(...)`.\nexport function setGraphQLSubscriber(subscriber: GraphQLSubscriber) {\n  graphQLSubscriber = subscriber;\n}\nexport type Simplify<T> = SimplifyDepth<T>;\ntype Primitive = string | number | boolean | bigint | symbol | null | undefined;\ntype Dec = [0,0,1,2,3,4,5,6,7,8,9];\nexport type SimplifyDepth<T, D extends number = 5> =\n  D extends 0 ? T :\n  T extends Primitive | Function ? T :\n  T extends readonly (infer U)[] ? readonly SimplifyDepth<U, Dec[D]>[] :\n  T extends object ? { [K in keyof T]: SimplifyDepth<T[K], Dec[D]> } & {} :\n  T;\n\nexport async function execute<\n  TData extends object,\n  TVariables extends Record<string, unknown>,\n>(\n  selection: Selection<\"Query\" | \"Mutation\", TData, TVariables>,\n  options?: {\n    readonly operationName?: string;\n    readonly variables?: TVariables;\n    readonly executor?: GraphQLExecutor;\n  },\n): Promise<Simplify<TData>> {\n  // Per-call override has priority over the globally registered executor.\n  const executor = options?.executor ?? graphQLExecutor;\n  if (executor === undefined) {\n    throw new Error(\n      \"Executor not set. Call 'setGraphQLExecutor' first or pass executor in options.\",\n    );\n  }\n\n  const request = buildRequest(selection, options?.operationName);\n  const rawResponse = exceptNullValues(\n    await executor(request, options?.variables ?? {}),\n  );\n  // GraphQL transport errors are surfaced as exceptions.\n  if (rawResponse.errors) {\n    throw new GraphQLError(rawResponse.errors);\n  }\n  return rawResponse.data as unknown as Simplify<TData>;\n}\n\nexport async function* subscribe<\n  TData extends object,\n  TVariables extends Record<string, unknown>,\n>(\n  selection: Selection<\"Subscription\", TData, TVariables>,\n  options?: {\n    readonly operationName?: string;\n    readonly variables?: TVariables;\n    readonly subscriber?: GraphQLSubscriber;\n  },\n): AsyncIterable<Simplify<TData>> {\n  // Per-call override has priority over the globally registered subscriber.\n  const subscriber = options?.subscriber ?? graphQLSubscriber;\n  if (subscriber === undefined) {\n    throw new Error(\n      \"Subscriber not set. Call 'setGraphQLSubscriber' first or pass subscriber in options.\",\n    );\n  }\n\n  const request = buildRequest(selection, options?.operationName);\n  const stream = await subscriber(request, options?.variables ?? {});\n  // Stream payloads follow standard GraphQL response shape.\n  for await (const payload of stream) {\n    const rawResponse = exceptNullValues(payload);\n    if (rawResponse.errors) {\n      throw new GraphQLError(rawResponse.errors);\n    }\n    yield rawResponse.data as unknown as Simplify<TData>;\n  }\n}\n\nexport interface Response<TData> {\n  readonly data?: TData;\n  readonly error?: Error;\n}\n\nexport class GraphQLError extends Error {\n  readonly errors: readonly GraphQLSubError[];\n\n  constructor(errors: any) {\n    super();\n    this.errors = errors;\n  }\n}\n\nexport interface GraphQLSubError {\n  readonly message: string;\n  readonly path: string[];\n}\n\nlet graphQLExecutor: GraphQLExecutor | undefined = undefined;\nlet graphQLSubscriber: GraphQLSubscriber | undefined = undefined;\n\n// Build GraphQL document from selection tree and inferred variable declarations.\nfunction buildRequest<\n  TData extends object,\n  TVariables extends Record<string, unknown>,\n>(\n  selection: Selection<\"Query\" | \"Mutation\" | \"Subscription\", TData, TVariables>,\n  operationName?: string,\n): string {\n  const runtime = runtimeOf(selection);\n  const writer = new TextBuilder();\n  writer.text(`${runtime.schemaType.name.toLowerCase()} ${operationName ?? runtime.operationName ?? \"\"}`);\n  if (runtime.variableTypeMap.size !== 0) {\n    writer.scope(\n      {\n        type: \"arguments\",\n        multiLines: runtime.variableTypeMap.size > 2,\n        suffix: \" \",\n      },\n      () => {\n        for (const [name, type] of runtime.variableTypeMap) {\n          writer.separator();\n          writer.text(`$${name}: ${type}`);\n        }\n      },\n    );\n  }\n  writer.text(selection.toString());\n  writer.text(selection.toFragmentString());\n  return writer.toString();\n}\n\n// Convert all nullable fields to `undefined` for easier TS optional-field ergonomics.\nfunction exceptNullValues<T>(value: T): T {\n  if (value == null) return undefined as any;\n  if (typeof value !== \"object\") return value;\n  if (Array.isArray(value)) {\n    return value.map((el) => el == null ? undefined : exceptNullValues(el)) as any;\n  }\n  const out: any = {};\n  for (const k in value) {\n    const v = value[k];\n    out[k] = v != null ? exceptNullValues(v) : undefined;\n  }\n  return out;\n}\n";
+
+//#endregion
+//#region src/codegen/generator.ts
+/** Default output directory: node_modules/@ptdgrp/typedgql/__generated */
+const DEFAULT_TARGET_DIR = (0, path.resolve)(process.cwd(), "node_modules/@ptdgrp/typedgql/__generated");
+/** Parent package dir: node_modules/@ptdgrp/typedgql */
+const PACKAGE_DIR = (0, path.resolve)(process.cwd(), "node_modules/@ptdgrp/typedgql");
+/** Field names reserved by the runtime SelectionNode implementation. */
+const RESERVED_FIELDS = new Set([
+	"constructor",
+	"addField",
+	"removeField",
+	"addEmbeddable",
+	"addDirective",
+	"fieldMap",
+	"directiveMap",
+	"findField",
+	"findFieldsByName",
+	"findFieldByName",
+	"schemaType",
+	"variableTypeMap",
+	"toString",
+	"toJSON",
+	"toFragmentString"
+]);
+var Generator = class {
+	constructor(options) {
+		this.options = options;
+	}
+	/** Resolved output directory (uses default if not configured) */
+	get targetDir() {
+		return this.options.targetDir ?? DEFAULT_TARGET_DIR;
+	}
+	async generate() {
+		const schema = await this.options.schemaLoader();
+		this.validateSchema(schema);
+		await (0, fs_promises.rm)(this.targetDir, {
+			recursive: true,
+			force: true
+		});
+		await (0, fs_promises.mkdir)(this.targetDir, { recursive: true });
+		const typeHierarchy = new TypeHierarchyGraph(schema);
+		const selectionTypes = [];
+		const inputTypes = [];
+		const enumTypes = [];
+		const typeMap = schema.getTypeMap();
+		for (const typeName in typeMap) {
+			if (typeName.startsWith("__")) continue;
+			const type = typeMap[typeName];
+			if (isExcludedTypeName(this.options, type.name)) continue;
+			if (type instanceof graphql.GraphQLObjectType || type instanceof graphql.GraphQLInterfaceType || type instanceof graphql.GraphQLUnionType) selectionTypes.push(type);
+			else if (type instanceof graphql.GraphQLInputObjectType) inputTypes.push(type);
+			else if (type instanceof graphql.GraphQLEnumType) enumTypes.push(type);
+		}
+		const configuredIdFieldMap = this.options.idFieldMap ?? {};
+		const entityTypes = /* @__PURE__ */ new Set();
+		const embeddedTypes = /* @__PURE__ */ new Set();
+		const idFieldMap = /* @__PURE__ */ new Map();
+		const triggerableTypes = /* @__PURE__ */ new Set();
+		const typesWithParameterizedField = /* @__PURE__ */ new Set();
+		for (const selectionType of selectionTypes) {
+			if (!(selectionType instanceof graphql.GraphQLObjectType) && !(selectionType instanceof graphql.GraphQLInterfaceType)) continue;
+			const fieldMap = selectionType.getFields();
+			if (selectionType.name === "Query") {
+				if (Object.keys(fieldMap).length !== 0) triggerableTypes.add(selectionType);
+			} else {
+				let idFieldName = configuredIdFieldMap[selectionType.name];
+				if (idFieldName === void 0) {
+					let configuredUpcastType = void 0;
+					typeHierarchy.visitUpcastTypesRecursively(selectionType, (upcastType) => {
+						const newIdFieldName = configuredIdFieldMap[upcastType.name];
+						if (idFieldName === void 0) {
+							configuredUpcastType = upcastType;
+							idFieldName = newIdFieldName;
+						} else if (idFieldName !== newIdFieldName) throw new Error(`Conflict id property configuration: ${configuredUpcastType.name}.${idFieldName} and ${selectionType.name}.${newIdFieldName}`);
+					});
+				}
+				const idField = fieldMap[idFieldName ?? "id"];
+				if (idField != null) {
+					idFieldMap.set(selectionType, idField);
+					entityTypes.add(selectionType);
+					if (Object.keys(fieldMap).length !== 1) triggerableTypes.add(selectionType);
+				} else embeddedTypes.add(selectionType);
+			}
+			for (const fieldName in fieldMap) if (fieldMap[fieldName].args.length !== 0) {
+				typesWithParameterizedField.add(selectionType);
+				break;
+			}
+		}
+		const ctx = {
+			schema,
+			typeHierarchy,
+			selectionTypes,
+			entityTypes,
+			embeddedTypes,
+			triggerableTypes,
+			idFieldMap,
+			typesWithParameterizedField
+		};
+		const promises = [];
+		if (selectionTypes.length !== 0) {
+			await (0, fs_promises.mkdir)((0, path.join)(this.targetDir, "selections"), { recursive: true });
+			promises.push(this.generateSelectionTypes(ctx));
+		}
+		if (inputTypes.length !== 0) {
+			await (0, fs_promises.mkdir)((0, path.join)(this.targetDir, "inputs"), { recursive: true });
+			promises.push(this.generateInputTypes(inputTypes));
+		}
+		if (enumTypes.length !== 0) {
+			await (0, fs_promises.mkdir)((0, path.join)(this.targetDir, "enums"), { recursive: true });
+			promises.push(this.generateEnumTypes(enumTypes));
+		}
+		promises.push(this.generateTypeHierarchy(schema, typeHierarchy));
+		promises.push(this.generateEnumInputMetadata(schema));
+		promises.push(this.generateAsyncRuntime());
+		promises.push(this.writeIndex(schema, ctx));
+		await Promise.all(promises);
+		if (this.options.targetDir === void 0) await this.writePackageEntrypoint(schema, ctx);
+	}
+	createSelectionWriter(modelType, ctx, stream, options) {
+		return new SelectionWriter(modelType, ctx, stream, options);
+	}
+	additionalExportedTypeNamesForSelection(_modelType, _ctx) {
+		return [];
+	}
+	async generateSelectionTypes(ctx) {
+		const dir = (0, path.join)(this.targetDir, "selections");
+		const emptySelectionNameMap = /* @__PURE__ */ new Map();
+		const defaultSelectionNameMap = /* @__PURE__ */ new Map();
+		const suffix = this.options?.selectionSuffix ?? "Selection";
+		const promises = ctx.selectionTypes.map(async (type) => {
+			const stream = createStream((0, path.join)(dir, `${toKebabCase(`${type.name}${suffix}`)}.ts`));
+			const writer = this.createSelectionWriter(type, ctx, stream, this.options);
+			emptySelectionNameMap.set(type, writer.emptySelectionName);
+			if (writer.defaultSelectionName !== void 0) defaultSelectionNameMap.set(type, writer.defaultSelectionName);
+			writer.write();
+			await endStream(stream);
+		});
+		await Promise.all([...promises, (async () => {
+			const stream = createStream((0, path.join)(dir, "index.ts"));
+			for (const type of ctx.selectionTypes) {
+				const selectionTypeName = `${type.name}${suffix}`;
+				const selectionFileName = toKebabCase(selectionTypeName);
+				const typeExports = [
+					selectionTypeName,
+					(type instanceof graphql.GraphQLObjectType || type instanceof graphql.GraphQLInterfaceType) && ctx.typesWithParameterizedField.has(type) ? `${type.name}Args` : void 0,
+					...this.additionalExportedTypeNamesForSelection(type, ctx)
+				].filter(Boolean).join(", ");
+				stream.write(`export type {${typeExports}} from './${selectionFileName}';\n`);
+				const defaultSelectionName = defaultSelectionNameMap.get(type);
+				const valueExports = [emptySelectionNameMap.get(type), defaultSelectionName].filter(Boolean).join(", ");
+				if (valueExports.length !== 0) stream.write(`export {${valueExports}} from './${selectionFileName}';\n`);
+			}
+			await stream.end();
+		})()]);
+	}
+	async generateInputTypes(inputTypes) {
+		const dir = (0, path.join)(this.targetDir, "inputs");
+		const promises = inputTypes.map(async (type) => {
+			const stream = createStream((0, path.join)(dir, `${toKebabCase(type.name)}.ts`));
+			new InputWriter(type, stream, this.options).write();
+			await stream.end();
+		});
+		await Promise.all([...promises, this.writeSimpleIndex(dir, inputTypes)]);
+	}
+	async generateEnumTypes(enumTypes) {
+		const dir = (0, path.join)(this.targetDir, "enums");
+		const promises = enumTypes.map(async (type) => {
+			const stream = createStream((0, path.join)(dir, `${toKebabCase(type.name)}.ts`));
+			new EnumWriter(type, stream, this.options).write();
+			await stream.end();
+		});
+		await Promise.all([...promises, this.writeSimpleIndex(dir, enumTypes, true)]);
+	}
+	async generateTypeHierarchy(schema, typeHierarchy) {
+		const stream = createStream((0, path.join)(this.targetDir, "type-hierarchy.ts"));
+		new TypeHierarchyWriter(schema, typeHierarchy, stream, this.options).write();
+		await endStream(stream);
+	}
+	async generateEnumInputMetadata(schema) {
+		const stream = createStream((0, path.join)(this.targetDir, "enum-input-metadata.ts"));
+		new EnumInputMetadataWriter(schema, stream, this.options).write();
+		await endStream(stream);
+	}
+	async writeSimpleIndex(dir, types, typeOnly = true) {
+		const stream = createStream((0, path.join)(dir, "index.ts"));
+		const keyword = typeOnly ? "export type" : "export";
+		for (const type of types) stream.write(`${keyword} {${type.name}} from './${toKebabCase(type.name)}';\n`);
+		await stream.end();
+	}
+	async generateAsyncRuntime() {
+		const stream = createStream((0, path.join)(this.targetDir, "client-runtime.ts"));
+		stream.write(async_runtime_default);
+		await endStream(stream);
+	}
+	async writeIndex(schema, ctx) {
+		const stream = createStream((0, path.join)(this.targetDir, "index.ts"));
+		const selectionSuffix = this.options.selectionSuffix ?? "Selection";
+		stream.write(`import type { Selection, ExecutableSelection, SchemaType, ShapeOf, VariablesOf } from "../dist/index.mjs";\n`);
+		stream.write(`import { FragmentRef, createSelection, resolveRegisteredSchemaType } from "../dist/index.mjs";\n`);
+		for (const type of ctx.selectionTypes) {
+			const selectionTypeName = `${type.name}${selectionSuffix}`;
+			stream.write(`import type { ${selectionTypeName} } from "./selections/${toKebabCase(selectionTypeName)}";\n`);
+		}
+		stream.write(`import { ENUM_INPUT_METADATA } from "./enum-input-metadata";\n\n`);
+		stream.write(`export type { GraphQLExecutor, GraphQLSubscriber, Simplify } from "./client-runtime";\n`);
+		stream.write(`export { setGraphQLExecutor, setGraphQLSubscriber, execute, subscribe } from "./client-runtime";\n`);
+		stream.write("export type { ImplementationType } from './type-hierarchy';\n");
+		stream.write("export { upcastTypes, downcastTypes } from './type-hierarchy';\n");
+		stream.write(`export interface FragmentSelectionMap<T extends object = {}, TVariables extends object = {}> {\n`);
+		for (const type of ctx.selectionTypes) {
+			const selectionTypeName = `${type.name}${selectionSuffix}`;
+			stream.write(`  '${type.name}': ${selectionTypeName}<T, TVariables>;\n`);
+		}
+		stream.write("}\n");
+		stream.write(`export type FragmentTypeName = keyof FragmentSelectionMap;\n`);
+		stream.write(`export type FragmentSelectionFor<E extends FragmentTypeName, T extends object = {}, TVariables extends object = {}> = FragmentSelectionMap<T, TVariables>[E];\n`);
+		stream.write(`\nexport function fragment$<const E extends FragmentTypeName, S extends FragmentSelectionFor<E, object, object>>(\n`);
+		stream.write(`  typeName: E,\n`);
+		stream.write(`  builder: (it: FragmentSelectionFor<E, {}, {}>) => S,\n`);
+		stream.write(`  fragmentName?: string,\n`);
+		stream.write(`): FragmentRef<string, E, ShapeOf<S>, VariablesOf<S>> {\n`);
+		stream.write(`  const schemaType = resolveRegisteredSchemaType(typeName);\n`);
+		stream.write(`  if (!schemaType) {\n`);
+		stream.write(`    throw new Error(\`Cannot resolve schema type \"\${typeName}\" for fragment$\`);\n`);
+		stream.write(`  }\n`);
+		stream.write(`  const base = createSelection<E, Selection<E, {}, {}>>(\n`);
+		stream.write(`    schemaType as SchemaType<E>,\n`);
+		stream.write(`    ENUM_INPUT_METADATA,\n`);
+		stream.write(`    undefined,\n`);
+		stream.write(`  );\n`);
+		stream.write(`  const selection = builder(base as unknown as FragmentSelectionFor<E, {}, {}>);\n`);
+		stream.write(`  return new FragmentRef(\n`);
+		stream.write(`    fragmentName ?? \`\${typeName}Fragment\`,\n`);
+		stream.write(`    selection as unknown as ExecutableSelection<E, ShapeOf<S>, VariablesOf<S>>,\n`);
+		stream.write(`  );\n`);
+		stream.write(`}\n`);
+		await endStream(stream);
+	}
+	/**
+	* Creates node_modules/@ptdgrp/typedgql/index.ts
+	* so users can import generated types and the root gateway via `import { G } from '@ptdgrp/typedgql'`.
+	* Also patches package.json exports for ESM/type resolution to point to the generated entry.
+	*/
+	async writePackageEntrypoint(schema, ctx) {
+		await (0, fs_promises.mkdir)(PACKAGE_DIR, { recursive: true });
+		const indexStream = createStream((0, path.join)(PACKAGE_DIR, "index.ts"));
+		this.writePackageIndexCode(indexStream, schema, ctx);
+		await endStream(indexStream);
+		await this.patchPackageJsonForGeneratedEntrypoint();
+	}
+	async patchPackageJsonForGeneratedEntrypoint() {
+		const packageJsonPath = (0, path.join)(PACKAGE_DIR, "package.json");
+		const raw = await (0, fs_promises.readFile)(packageJsonPath, "utf8");
+		const pkg = JSON.parse(raw);
+		const exportsMap = typeof pkg.exports === "object" && pkg.exports !== null ? pkg.exports : {};
+		const rootExportRaw = exportsMap["."];
+		const rootExport = typeof rootExportRaw === "object" && rootExportRaw !== null ? rootExportRaw : {};
+		const importExportRaw = rootExport.import;
+		const importExport = typeof importExportRaw === "object" && importExportRaw !== null ? importExportRaw : {};
+		importExport.types = "./index.ts";
+		importExport.default = "./index.ts";
+		rootExport.import = importExport;
+		exportsMap["."] = rootExport;
+		pkg.exports = exportsMap;
+		pkg.types = "./index.ts";
+		await (0, fs_promises.writeFile)(packageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, "utf8");
+	}
+	writePackageIndexCode(stream, schema, _ctx) {
+		const typeMap = schema.getTypeMap();
+		const queryType = typeMap["Query"];
+		const mutationType = typeMap["Mutation"];
+		const subscriptionType = typeMap["Subscription"];
+		stream.write(`export * from './__generated/index';\n`);
+		stream.write(`export type { Selection, ExecutableSelection, ShapeOf, VariablesOf, Expand, FieldSelection, DirectiveArgs, EnumInputMetadata, EnumInputMetaType, AcceptableVariables, UnresolvedVariables, ValueOrThunk, SchemaType, SchemaField, SchemaTypeCategory, SchemaFieldCategory, FieldOptions } from './dist/index.mjs';\n`);
+		stream.write(`export { FragmentSpread, FragmentRef, StringValue, runtimeOf, createSchemaType, resolveRegisteredSchemaType, registerSchemaTypeFactory, SelectionNode, createSelection, ParameterRef, EnumInputMetadataBuilder, TextBuilder, cyrb53 } from './dist/index.mjs';\n`);
+		stream.write(`import { fragment$ } from './__generated/index';\n`);
+		if (queryType instanceof graphql.GraphQLObjectType) stream.write(`import { query$ } from './__generated/selections/${toKebabCase("QuerySelection")}';\n`);
+		if (mutationType instanceof graphql.GraphQLObjectType) stream.write(`import { mutation$ } from './__generated/selections/${toKebabCase("MutationSelection")}';\n`);
+		if (subscriptionType instanceof graphql.GraphQLObjectType) stream.write(`import { subscription$ } from './__generated/selections/${toKebabCase("SubscriptionSelection")}';\n`);
+		stream.write("\n");
+		if (queryType instanceof graphql.GraphQLObjectType) stream.write("export { query$ };\n");
+		if (mutationType instanceof graphql.GraphQLObjectType) stream.write("export { mutation$ };\n");
+		if (subscriptionType instanceof graphql.GraphQLObjectType) stream.write("export { subscription$ };\n");
+		stream.write("\n");
+		stream.write("export const G = {\n");
+		if (queryType instanceof graphql.GraphQLObjectType) stream.write("  query: query$,\n");
+		if (mutationType instanceof graphql.GraphQLObjectType) stream.write("  mutation: mutation$,\n");
+		if (subscriptionType instanceof graphql.GraphQLObjectType) stream.write("  subscription: subscription$,\n");
+		stream.write("  fragment: fragment$,\n");
+		stream.write("} as const;\n");
+		if (this.hasGeneratedEnums(schema)) stream.write(`export * from './__generated/enums';\n`);
+		if (this.hasGeneratedInputs(schema)) stream.write(`export * from './__generated/inputs';\n`);
+		stream.write(`export type * from './__generated/selections';\n`);
+		stream.write(`export type * from './__generated/type-hierarchy';\n`);
+	}
+	hasGeneratedEnums(schema) {
+		const typeMap = schema.getTypeMap();
+		for (const typeName in typeMap) {
+			if (typeName.startsWith("__")) continue;
+			const type = typeMap[typeName];
+			if (type instanceof graphql.GraphQLEnumType && !isExcludedTypeName(this.options, type.name)) return true;
+		}
+		return false;
+	}
+	hasGeneratedInputs(schema) {
+		const typeMap = schema.getTypeMap();
+		for (const typeName in typeMap) {
+			if (typeName.startsWith("__")) continue;
+			const type = typeMap[typeName];
+			if (type instanceof graphql.GraphQLInputObjectType && !isExcludedTypeName(this.options, type.name)) return true;
+		}
+		return false;
+	}
+	validateSchema(schema) {
+		const typeMap = schema.getTypeMap();
+		for (const typeName in typeMap) {
+			const type = typeMap[typeName];
+			if (type instanceof graphql.GraphQLObjectType || type instanceof graphql.GraphQLInterfaceType) {
+				for (const fieldName in type.getFields()) if (RESERVED_FIELDS.has(fieldName)) throw new Error(`Illegal field '${fieldName}' of type '${typeName}', it's name is protected by '@ptdgrp/typedgql', please change the server-side app`);
+			}
+		}
+		const { idFieldMap } = this.options;
+		if (idFieldMap) for (const typeName in idFieldMap) {
+			const type = typeMap[typeName];
+			if (!(type instanceof graphql.GraphQLObjectType) && !(type instanceof graphql.GraphQLInterfaceType)) throw new Error(`config.idFieldMap contains an illegal key '${typeName}', that is neither a graphql object type nor graphql interface type`);
+			const idField = type.getFields()[idFieldMap[typeName]];
+			if (!idField) throw new Error(`config.idFieldMap['${typeName}'] is illegal, there is no field named '${idFieldMap[typeName]}' in the type '${typeName}'`);
+			if (targetTypeOf(idField.type) !== void 0) throw new Error(`config.idFieldMap['${typeName}'] is illegal, the field '${idFieldMap[typeName]}' of the type '${typeName}' is not scalar`);
+		}
+		const { defaultSelectionExcludeMap: excludeMap } = this.options;
+		if (excludeMap) for (const typeName in excludeMap) {
+			const type = typeMap[typeName];
+			if (!(type instanceof graphql.GraphQLObjectType) && !(type instanceof graphql.GraphQLInterfaceType)) throw new Error(`config.defaultSelectionExcludeMap contains an illegal key '${typeName}' that is neither a graphql object type nor graphql interface type`);
+			const fieldMap = type.getFields();
+			const fieldNames = excludeMap[typeName];
+			if (!Array.isArray(fieldNames)) throw new Error(`config.defaultSelectionExcludeMap['${typeName}'] is not array`);
+			for (let i = 0; i < fieldNames.length; i++) {
+				const fieldName = fieldNames[i];
+				if (fieldMap[fieldName] === void 0) throw new Error(`config.defaultSelectionExcludeMap['${typeName}'][${i}] is illegal, its value '${fieldName}' is not a field of graphql type '${typeName}'`);
+			}
+		}
+	}
+};
+function createStream(path$1) {
+	return (0, fs.createWriteStream)(path$1);
+}
+function endStream(stream) {
+	return new Promise((resolve, reject) => {
+		stream.end(() => resolve());
+		stream.on("error", reject);
+	});
+}
+
+//#endregion
+//#region src/codegen/schema-loader.ts
+async function loadRemoteSchema(endpoint, headers) {
+	const body = JSON.stringify({ query: (0, graphql.getIntrospectionQuery)({ oneOf: true }) });
+	const { data, errors } = await (await fetch(endpoint, {
+		method: "POST",
+		body,
+		headers: {
+			Accept: "application/json",
+			"Content-Type": "application/json",
+			...headers
+		}
+	})).json();
+	if (errors !== void 0) throw new Error(JSON.stringify(errors));
+	return (0, graphql.buildClientSchema)(data);
+}
+async function loadLocalSchema(location) {
+	return (0, graphql.buildSchema)(await (0, fs_promises.readFile)(location, { encoding: "utf8" }));
+}
+
+//#endregion
+Object.defineProperty(exports, 'Generator', {
+  enumerable: true,
+  get: function () {
+    return Generator;
+  }
+});
+Object.defineProperty(exports, 'loadLocalSchema', {
+  enumerable: true,
+  get: function () {
+    return loadLocalSchema;
+  }
+});
+Object.defineProperty(exports, 'loadRemoteSchema', {
+  enumerable: true,
+  get: function () {
+    return loadRemoteSchema;
+  }
+});