@znight/graphql 0.2.0 → 0.2.2

package/dist/compiler.mjs

@@ -1,4 +1,5 @@
 import { a as SPECIFIED_SCALARS, c as printTypeRef, i as ROOT_TYPE_NAMES, n as DEFAULT_DEPRECATION_REASON, o as isGraphQLName, r as RESERVED_ENUM_VALUES, s as parseTypeRef, t as BUILTIN_SCALARS } from "./names-BlzDM5cF.mjs";
+import { createRequire } from "node:module";
 import { createHash } from "node:crypto";
 import { effectiveRouteMeta, readRouteMeta, requiredRouteGroups } from "@znight/http/compiler";
 // src/compiler/ids.ts
@@ -75,7 +76,9 @@ const Codes = Object.freeze({
 	InvalidResolver: "ZNIGHT062",
 	InvalidInput: "ZNIGHT063",
 	UnresolvableAbstractType: "ZNIGHT064",
-	InvalidLoader: "ZNIGHT065"
+	InvalidLoader: "ZNIGHT065",
+	InvalidSdl: "ZNIGHT067",
+	SchemaMismatch: "ZNIGHT068"
 });
 /** Root reason given to `AnalyzeContext.addRoot()`. */
 const ROOT_REASON = "GraphQL resolver";
@@ -120,12 +123,17 @@ const LOADER_SHAPE = Object.freeze({
 	keep: Object.freeze([GraphQLIds.Loader]),
 	jsdoc: false
 });
-/** Analyses a class carrying at least one graphql decorator (class, method or parameter). */
-function analyzeGraphQLClass(cls, ctx) {
+/**
+* Analyses a class carrying at least one graphql decorator (class, method or parameter). In
+* schema-first mode (RFC 0007), `@Resolver('Type')` names the SDL type of the field resolvers and
+* `@Parent()` is optional.
+*/
+function analyzeGraphQLClass(cls, ctx, options) {
 	const resolvers = cls.decorators.filter((decorator) => decorator.identity === GraphQLIds.Resolver);
 	const resolver = resolvers[0];
 	if (resolver === void 0) {
 		reportOutsideResolver(cls, ctx);
+		storeClaims(ctx, cls, void 0, options);
 		return;
 	}
 	for (const extra of resolvers.slice(1)) error(ctx, Codes.InvalidDecorator, extra.location, `@Resolver is applied twice to ${cls.displayName}`, ["Apply it once"]);
@@ -135,17 +143,20 @@ function analyzeGraphQLClass(cls, ctx) {
 			message: "@Controller is applied here",
 			location: controller.location
 		}]);
+		storeClaims(ctx, cls, resolver, options);
 		return;
 	}
 	if (ctx.options.library) {
 		error(ctx, Codes.InvalidResolver, resolver.location, `${cls.displayName} is a @Resolver in a compiled provider library: the schema is derived from the sources`, ["Publish the package as a source library (without library: true), so that applications compile its resolvers"]);
+		storeClaims(ctx, cls, resolver, options);
 		return;
 	}
 	if (cls.abstract || cls.typeParameters.length > 0) {
 		error(ctx, Codes.InvalidDecorator, resolver.location, cls.abstract ? `@Resolver cannot be applied to the abstract class ${cls.displayName}` : `@Resolver cannot be applied to the generic class ${cls.displayName}<${cls.typeParameters.join(", ")}>`, [cls.abstract ? "Resolvers are instantiated: remove `abstract`" : "Remove the type parameters of the resolver"]);
+		storeClaims(ctx, cls, resolver, options);
 		return;
 	}
-	const scope = resolverScope(ctx, resolver);
+	const { scope, typeName } = resolverArguments(ctx, resolver, options.schema !== false);
 	ctx.registerProvider(cls, { scope });
 	ctx.addRoot(cls, {
 		reason: ROOT_REASON,
@@ -160,15 +171,60 @@ function analyzeGraphQLClass(cls, ctx) {
 			reportStrayMethodDecorators(cls, method, ctx);
 			continue;
 		}
-		fields.push(...analyzeMethod(ctx, cls, method, decorators, classMeta));
+		fields.push(...analyzeMethod(ctx, cls, method, decorators, classMeta, options.schema !== false));
 	}
-	ctx.store({
+	const data = {
 		kind: "resolver",
 		host: cls,
 		scope,
 		location: resolver.location,
 		guards: classGuards,
-		fields
+		fields,
+		...typeName === void 0 ? {} : { typeName }
+	};
+	if (options.schema !== false && typeName === void 0) for (const field of fields) {
+		if (field.operation !== "field") continue;
+		error(ctx, Codes.InvalidResolver, field.location, `@ResolveField ${cls.displayName}.${field.method} needs the type it resolves a field of: name it in @Resolver (schema-first)`, [`@Resolver('Event') on ${cls.displayName}, where Event is the object type of the SDL declaring '${field.name}'`]);
+	}
+	ctx.store(data);
+}
+/**
+* Schema-first: a class rejected above (no `@Resolver`, abstract, a controller...) still names the
+* fields its methods resolve, stored as an `invalid` resolver, so that these fields are not also
+* reported as missing a resolver (one diagnostic per mistake).
+*/
+function storeClaims(ctx, cls, resolver, options) {
+	if (options.schema === false) return;
+	const typeArg = resolver?.args[0];
+	const typeName = typeArg?.evaluated === true && typeof typeArg.value === "string" ? {
+		name: typeArg.value,
+		location: typeArg.location
+	} : void 0;
+	const fields = [];
+	for (const method of cls.methods) for (const decorator of method.decorators.filter(isFieldDecorator)) {
+		const arg = decorator.args[0];
+		fields.push({
+			method: method.name,
+			operation: FIELD_DECORATORS.get(decorator.identity),
+			name: arg?.evaluated === true && typeof arg.value === "string" ? arg.value : method.name,
+			location: decorator.location,
+			methodLocation: method.location,
+			guards: [],
+			meta: [],
+			params: [],
+			complete: false
+		});
+	}
+	if (fields.length === 0) return;
+	ctx.store({
+		kind: "resolver",
+		host: cls,
+		scope: "singleton",
+		location: resolver?.location ?? cls.location,
+		guards: [],
+		fields,
+		invalid: true,
+		...typeName === void 0 ? {} : { typeName }
 	});
 }
 function isFieldDecorator(decorator) {
@@ -177,9 +233,33 @@ function isFieldDecorator(decorator) {
 function isParameterDecorator(decorator) {
 	return decorator.identity !== void 0 && PARAMETER_DECORATORS.has(decorator.identity);
 }
-/** `@Resolver({ scope })`. */
-function resolverScope(ctx, decorator) {
-	const arg = decorator.args[0];
+/** `@Resolver()`, `@Resolver({ scope })`, `@Resolver('Event')`, `@Resolver('Event', { scope })` (schema-first). */
+function resolverArguments(ctx, decorator, schemaFirst) {
+	const [first, second] = decorator.args;
+	if (first?.evaluated !== true || typeof first.value !== "string") {
+		if (second !== void 0) error(ctx, Codes.InvalidDecorator, second.location, "@Resolver takes the options as its only argument here", ["@Resolver({ scope: 'request' }), or @Resolver('Event', { scope: 'request' }) in schema-first mode"]);
+		return { scope: resolverScope(ctx, first) };
+	}
+	const scope = resolverScope(ctx, second);
+	const name = first.value;
+	if (!schemaFirst) {
+		error(ctx, Codes.InvalidDecorator, first.location, `@Resolver('${name}'): naming the type is schema-first only, the code-first schema is derived from the types`, ["Remove the type name: @ResolveField methods add fields to the type of their @Parent() parameter", "Or switch to schema-first: graphql.configure({ schema: 'src/**/*.graphql' }) in znight.config.ts"]);
+		return { scope };
+	}
+	if (!isGraphQLName(name)) {
+		error(ctx, Codes.NameConflict, first.location, `'${name}' is not a valid GraphQL type name (@Resolver)`, ["GraphQL names match /^[_A-Za-z][_0-9A-Za-z]*$/ and do not start with __"]);
+		return { scope };
+	}
+	return {
+		scope,
+		typeName: {
+			name,
+			location: first.location
+		}
+	};
+}
+/** The `{ scope }` options of `@Resolver`. */
+function resolverScope(ctx, arg) {
 	if (arg === void 0 || !arg.evaluated || arg.value === void 0) return "singleton";
 	const value = arg.value;
 	if (!isRecord(value)) {
@@ -209,7 +289,7 @@ function guardsOf(ctx, cls, decorators) {
 	}
 	return guards;
 }
-function analyzeMethod(ctx, cls, method, decorators, classMeta) {
+function analyzeMethod(ctx, cls, method, decorators, classMeta, schemaFirst) {
 	const where = `${cls.displayName}.${method.name}`;
 	const primary = decorators[0];
 	let complete = checkMethodShape(ctx, method, primary, where);
@@ -240,7 +320,7 @@ function analyzeMethod(ctx, cls, method, decorators, classMeta) {
 		}
 		seen.add(key);
 		let fieldComplete = complete && explicit !== void 0;
-		if (operation === "field" && parents.length === 0) {
+		if (operation === "field" && parents.length === 0 && !schemaFirst) {
 			error(ctx, Codes.InvalidResolver, decorator.location, `@ResolveField ${where} has no @Parent() parameter`, [`Declare the parent object first: ${method.name}(@Parent() parent: ParentType, ...)`]);
 			fieldComplete = false;
 		} else if (operation !== "field" && parents.length > 0) {
@@ -542,7 +622,8 @@ var SdlPrinter = class {
 	type(type) {
 		const head = printDescription(type.description, "", true);
 		switch (type.kind) {
-			case "object": return `${head}type ${type.name}${printBlock(type.fields.map((field, i) => this.#field(type.name, field, i)))}`;
+			case "object":
+			case "interface": return `${head}${type.kind === "object" ? "type" : "interface"} ${type.name}${printImplements(type.interfaces)}${printBlock(type.fields.map((field, i) => this.#field(type.name, field, i)))}`;
 			case "input": return `${head}input ${type.name}${printBlock(type.fields.map((field, i) => `${printDescription(field.description, "  ", i === 0)}  ${this.#inputValue(field, `${type.name}.${field.name}`)}`))}`;
 			case "enum": return `${head}enum ${type.name}${printBlock(type.values.map((value, i) => `${printDescription(value.description, "  ", i === 0)}  ${value.name}${printDeprecated(value.deprecationReason)}`))}`;
 			case "union": return `${head}union ${type.name}${type.members.length === 0 ? "" : ` = ${type.members.join(" | ")}`}`;
@@ -621,6 +702,10 @@ var SdlPrinter = class {
 		};
 	}
 };
+/** graphql-js `printImplementedInterfaces`. */
+function printImplements(interfaces) {
+	return interfaces === void 0 || interfaces.length === 0 ? "" : ` implements ${interfaces.join(" & ")}`;
+}
 /** The `valueToLiteral` of the specified scalars, and graphql-js' default one for the others. */
 function scalarLiteral(value, name) {
 	switch (name) {
@@ -841,6 +926,74 @@ function printBlockString(value) {
 	if (printAsMultipleLines || forceTrailingNewline) result += "\n";
 	return `"""${result}"""`;
 }
+// src/compiler/checks.ts
+/** `Loader<L>`: `L` must be a loader provider, implementing `BatchLoad<K, V>` (ZNIGHT065). */
+function checkLoaders(ctx, resolvers, report) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const resolver of resolvers) for (const field of resolver.fields) for (const param of field.params) {
+		if (param?.kind !== "loader" || seen.has(param.binding.id)) continue;
+		seen.add(param.binding.id);
+		const token = tokenOfRef(ctx.binding(param.binding));
+		const provider = token === void 0 ? void 0 : ctx.provider(token);
+		if (provider === void 0 || provider.heritage.some((type) => type.identity === GraphQLIds.BatchLoad)) continue;
+		if (provider.kind !== "class" || hasLoadMethod(ctx, provider.classIdentity)) continue;
+		report({
+			code: Codes.InvalidLoader,
+			severity: "error",
+			message: `${provider.displayName} is not a loader: Loader<${provider.displayName}> needs a provider implementing BatchLoad<K, V> (${resolver.host.displayName}.${field.method})`,
+			location: param.location,
+			hints: [`export class ${provider.displayName} implements BatchLoad<ID, Value> { async load(keys: readonly ID[]): Promise<readonly (Value | Error)[]> { ... } }`]
+		});
+	}
+}
+/**
+* RFC 0001: every root field decides every required route decorator group (ZNIGHT023). `roots`
+* names the root types (`schema { query: RootQuery }` in schema-first).
+*/
+function checkDecisions(ctx, resolvers, report, roots = ROOT_TYPE_NAMES) {
+	const applied = [];
+	for (const resolver of resolvers) for (const field of resolver.fields) applied.push(...field.meta);
+	const required = requiredRouteGroups(ctx, applied);
+	if (required.length === 0) return;
+	for (const resolver of resolvers) for (const field of resolver.fields) {
+		if (field.operation === "field") continue;
+		const decided = new Set(field.meta.map((entry) => entry.group));
+		for (const group of required) {
+			if (decided.has(group.group)) continue;
+			const root = roots[field.operation] ?? ROOT_TYPE_NAMES[field.operation];
+			report({
+				code: Codes.MissingRouteDecision,
+				severity: "error",
+				message: `Root field ${root}.${field.name} (${resolver.host.displayName}.${field.method}) has no "${group.group}" decision`,
+				location: field.methodLocation,
+				hints: [`Add ${group.suggestion} to the method or to ${resolver.host.displayName}`],
+				related: [{
+					message: `The "${group.group}" group is required`,
+					location: group.decorators[0].definition
+				}]
+			});
+		}
+	}
+}
+/** The class (or one of its base classes) declares an instance `load` method. */
+function hasLoadMethod(ctx, identity) {
+	const seen = /* @__PURE__ */ new Set();
+	let current = identity;
+	while (current !== void 0 && !seen.has(current)) {
+		seen.add(current);
+		const cls = ctx.classInfo(current);
+		if (cls === void 0) return true;
+		if (cls.methods.some((method) => method.name === "load" && method.kind === "method" && !method.static)) return true;
+		if (cls.properties.some((property) => property.name === "load" && !property.static)) return true;
+		current = cls.superClass?.identity;
+	}
+	return false;
+}
+/** The token of a binding result (`undefined` when binding failed). */
+function tokenOfRef(ref) {
+	if (typeof ref === "string") return ref;
+	return ref !== void 0 && "token" in ref ? ref.token : void 0;
+}
 // src/compiler/defaults.ts
 const GRAPHQL_INT_MAX = 2147483647;
 const GRAPHQL_INT_MIN = -2147483648;
@@ -1030,6 +1183,46 @@ function annotationLocation(project, member) {
 		end
 	}) : member;
 }
+/**
+* The return type annotation of a method, from the location of its name: after the parameter list
+* (balanced brackets), `: T` up to the body; `undefined` when it cannot be found.
+*/
+function returnTypeLocation(project, method) {
+	const file = project.getFile(method.location.file);
+	if (file === void 0) return void 0;
+	const text = file.text;
+	let index = text.indexOf("(", method.location.end);
+	if (index === -1) return void 0;
+	let depth = 0;
+	for (; index < text.length; index++) {
+		const char = text[index];
+		if (OPENING.has(char)) depth++;
+		else if (CLOSING.has(char) && --depth === 0) break;
+	}
+	const head = /^\s*:\s*/.exec(text.slice(index + 1, index + 64));
+	if (head === null) return void 0;
+	const start = index + 1 + head[0].length;
+	let end = start;
+	depth = 0;
+	for (let cursor = start; cursor < text.length; cursor++) {
+		const char = text[cursor];
+		if (char === "=" && text[cursor + 1] === ">") {
+			cursor++;
+			continue;
+		}
+		if (depth === 0 && (char === "{" || char === ";") && end > start) break;
+		if (OPENING.has(char)) depth++;
+		else if (CLOSING.has(char)) {
+			if (depth === 0) break;
+			depth--;
+		}
+		if (!/\s/.test(char)) end = cursor + 1;
+	}
+	return end > start ? file.location({
+		start,
+		end
+	}) : void 0;
+}
 // src/compiler/scalars.ts
 /** Valid declarations by the identity of their type; invalid ones are reported. */
 function readScalars(ctx, report) {
@@ -1143,10 +1336,12 @@ function staticProperty(ctx, arg, key) {
 function sdlType(model) {
 	const base = model.description === void 0 ? {} : { description: model.description };
 	switch (model.kind) {
-		case "object": return {
-			kind: "object",
+		case "object":
+		case "interface": return {
+			kind: model.kind,
 			name: model.name,
 			...base,
+			...model.interfaces.length === 0 ? {} : { interfaces: model.interfaces },
 			fields: model.fields.map((field) => ({
 				name: field.name,
 				type: field.type,
@@ -1238,7 +1433,7 @@ var SchemaBuilder = class {
 		});
 	}
 	build(resolvers) {
-		this.#checkLoaders(resolvers);
+		checkLoaders(this.#ctx, resolvers, (diagnostic) => this.#report(diagnostic));
 		this.#indexFieldResolvers(resolvers);
 		const roots = /* @__PURE__ */ new Map();
 		const rootFields = /* @__PURE__ */ new Map();
@@ -1285,7 +1480,7 @@ var SchemaBuilder = class {
 		this.#reportUnreachableFieldResolvers();
 		this.#checkDefaults();
 		this.#checkInputCycles();
-		this.#checkDecisions(resolvers);
+		checkDecisions(this.#ctx, resolvers, (diagnostic) => this.#report(diagnostic));
 		if (this.#errors > 0 || !hasQuery) return void 0;
 		return this.#assemble(roots, resolvers);
 	}
@@ -1337,7 +1532,8 @@ var SchemaBuilder = class {
 				trail: name,
 				root: void 0,
 				classIdentity: void 0,
-				properties: []
+				properties: [],
+				interfaces: []
 			};
 			roots.set(operation, root);
 			this.#claim(root, void 0);
@@ -1552,25 +1748,6 @@ var SchemaBuilder = class {
 		if (arg.deprecationReason === void 0 || !arg.ref.nonNull || hasDefault) return;
 		this.#fail(Codes.InvalidInput, use, `${use.coordinate} is required and cannot be deprecated`, ["Make it optional (?: T or T | undefined) or give it a default value before deprecating it"]);
 	}
-	/** `Loader<L>`: `L` must be a loader provider, implementing `BatchLoad<K, V>` (ZNIGHT065). */
-	#checkLoaders(resolvers) {
-		const seen = /* @__PURE__ */ new Set();
-		for (const resolver of resolvers) for (const field of resolver.fields) for (const param of field.params) {
-			if (param?.kind !== "loader" || seen.has(param.binding.id)) continue;
-			seen.add(param.binding.id);
-			const token = tokenOfRef(this.#ctx.binding(param.binding));
-			const provider = token === void 0 ? void 0 : this.#ctx.provider(token);
-			if (provider === void 0 || provider.heritage.some((type) => type.identity === GraphQLIds.BatchLoad)) continue;
-			if (provider.kind !== "class" || hasLoadMethod(this.#ctx, provider.classIdentity)) continue;
-			this.#report({
-				code: Codes.InvalidLoader,
-				severity: "error",
-				message: `${provider.displayName} is not a loader: Loader<${provider.displayName}> needs a provider implementing BatchLoad<K, V> (${resolver.host.displayName}.${field.method})`,
-				location: param.location,
-				hints: [`export class ${provider.displayName} implements BatchLoad<ID, Value> { async load(keys: readonly ID[]): Promise<readonly (Value | Error)[]> { ... } }`]
-			});
-		}
-	}
 	#indexFieldResolvers(resolvers) {
 		for (const resolver of resolvers) for (const field of resolver.fields) {
 			if (field.operation !== "field" || !field.complete) continue;
@@ -1945,7 +2122,8 @@ var SchemaBuilder = class {
 			trail,
 			root: use.root,
 			classIdentity: structure.declaration === "class" && structure.typeArgs.length === 0 && structure === named ? structure.identity : void 0,
-			properties: properties.map((property) => this.#discriminant(property))
+			properties: properties.map((property) => this.#discriminant(property)),
+			interfaces: []
 		};
 		this.#models.set(key, model);
 		if (!this.#claim(model, use)) return void 0;
@@ -2352,32 +2530,6 @@ var SchemaBuilder = class {
 		};
 		for (const model of inputs) if (!state.has(model.name)) visit(model);
 	}
-	/** RFC 0001: every root field decides every required route decorator group (ZNIGHT023). */
-	#checkDecisions(resolvers) {
-		const applied = [];
-		for (const resolver of resolvers) for (const field of resolver.fields) applied.push(...field.meta);
-		const required = requiredRouteGroups(this.#ctx, applied);
-		if (required.length === 0) return;
-		for (const resolver of resolvers) for (const field of resolver.fields) {
-			if (field.operation === "field") continue;
-			const decided = new Set(field.meta.map((entry) => entry.group));
-			for (const group of required) {
-				if (decided.has(group.group)) continue;
-				const root = ROOT_TYPE_NAMES[field.operation];
-				this.#report({
-					code: Codes.MissingRouteDecision,
-					severity: "error",
-					message: `Root field ${root}.${field.name} (${resolver.host.displayName}.${field.method}) has no "${group.group}" decision`,
-					location: field.methodLocation,
-					hints: [`Add ${group.suggestion} to the method or to ${resolver.host.displayName}`],
-					related: [{
-						message: `The "${group.group}" group is required`,
-						location: group.decorators[0].definition
-					}]
-				});
-			}
-		}
-	}
 	#assemble(roots, resolvers) {
 		const types = [...this.#types.values()].sort((a, b) => compareStrings(a.name, b.name));
 		const meta = [];
@@ -2400,20 +2552,6 @@ var SchemaBuilder = class {
 		};
 	}
 };
-/** The class (or one of its base classes) declares an instance `load` method. */
-function hasLoadMethod(ctx, identity) {
-	const seen = /* @__PURE__ */ new Set();
-	let current = identity;
-	while (current !== void 0 && !seen.has(current)) {
-		seen.add(current);
-		const cls = ctx.classInfo(current);
-		if (cls === void 0) return true;
-		if (cls.methods.some((method) => method.name === "load" && method.kind === "method" && !method.static)) return true;
-		if (cls.properties.some((property) => property.name === "load" && !property.static)) return true;
-		current = cls.superClass?.identity;
-	}
-	return false;
-}
 /** A (nullable, until `#convert` decides) reference to a named type. */
 function refTo(name) {
 	return {
@@ -2434,11 +2572,6 @@ function reachedFrom(use) {
 function decoratorName(operation) {
 	return ROOT_TYPE_NAMES[operation];
 }
-/** The token of a binding result (`undefined` when binding failed). */
-function tokenOfRef(ref) {
-	if (typeof ref === "string") return ref;
-	return ref !== void 0 && "token" in ref ? ref.token : void 0;
-}
 function describeKey(model) {
 	return model.key.startsWith("#") ? `the ${model.kind} ${model.name}` : model.key;
 }
@@ -2532,7 +2665,14 @@ function typeNode(ctx, imports, type) {
 	const head = [["kind", type.kind], ["name", type.name]];
 	if (type.description !== void 0 && type.kind !== "scalar") head.push(["description", type.description]);
 	switch (type.kind) {
-		case "object": return ctx.obj([...head, ["fields", ctx.arr(type.fields.map((field) => fieldNode(ctx, imports, field)))]]);
+		case "object":
+		case "interface": {
+			const entries = [...head];
+			if (type.interfaces.length > 0) entries.push(["interfaces", ctx.lit([...type.interfaces])]);
+			entries.push(["fields", ctx.arr(type.fields.map((field) => fieldNode(ctx, imports, field)))]);
+			if (type.kind === "interface") entries.push(["discriminator", discriminatorNode(ctx, type.discriminator)]);
+			return ctx.obj(entries);
+		}
 		case "input": return ctx.obj([...head, ["fields", ctx.arr(type.fields.map((field) => inputValueNode(ctx, field)))]]);
 		case "enum": return ctx.obj([...head, ["values", ctx.arr(type.values.map((value) => {
 			const entries = [["name", value.name], ["value", value.value]];
@@ -2540,25 +2680,33 @@ function typeNode(ctx, imports, type) {
 			if (value.deprecationReason !== void 0) entries.push(["deprecationReason", value.deprecationReason]);
 			return ctx.obj(entries);
 		}))]]);
-		case "union": {
-			const discriminator = type.discriminator;
-			let node;
-			if (discriminator === void 0 || discriminator.by === "typename") node = ctx.obj([["by", "typename"]]);
-			else if (discriminator.by === "property") node = ctx.obj([
-				["by", "property"],
-				["property", discriminator.property],
-				["values", ctx.obj(Object.entries(discriminator.values))]
-			]);
-			else node = ctx.obj([["by", "class"], ["classes", ctx.arr(discriminator.classes.map((entry) => ctx.arr([ctx.importValue(entry.identity), entry.name])))]]);
-			return ctx.obj([
-				...head,
-				["members", ctx.lit([...type.members])],
-				["discriminator", node]
-			]);
-		}
-		case "scalar": return type.definition === void 0 ? ctx.obj([...head, ["builtin", ctx.lit(true)]]) : ctx.obj([...head, ["scalar", ctx.importValue(type.definition)]]);
+		case "union": return ctx.obj([
+			...head,
+			["members", ctx.lit([...type.members])],
+			["discriminator", discriminatorNode(ctx, type.discriminator)]
+		]);
+		case "scalar": {
+			if (type.definition === void 0) return ctx.obj([...head, ["builtin", ctx.lit(true)]]);
+			const entries = [...head, ["scalar", ctx.importValue(type.definition)]];
+			if (type.fromSdl === true) {
+				if (type.description !== void 0) entries.push(["description", type.description]);
+				if (type.specifiedByURL !== void 0) entries.push(["specifiedByURL", type.specifiedByURL]);
+				entries.push(["sdl", ctx.lit(true)]);
+			}
+			return ctx.obj(entries);
+		}
 	}
 }
+/** How the runtime tells the members of a union or the implementations of an interface apart. */
+function discriminatorNode(ctx, discriminator) {
+	if (discriminator === void 0 || discriminator.by === "typename") return ctx.obj([["by", "typename"]]);
+	if (discriminator.by === "property") return ctx.obj([
+		["by", "property"],
+		["property", discriminator.property],
+		["values", ctx.obj(Object.entries(discriminator.values))]
+	]);
+	return ctx.obj([["by", "class"], ["classes", ctx.arr(discriminator.classes.map((entry) => ctx.arr([ctx.importValue(entry.identity), entry.name])))]]);
+}
 function fieldNode(ctx, imports, field) {
 	const entries = [["name", field.name], ["type", field.type]];
 	if (field.description !== void 0) entries.push(["description", field.description]);
@@ -2749,25 +2897,1643 @@ function groupsNode(ctx, meta) {
 /** The defaults. */
 const DEFAULT_OPTIONS = Object.freeze({
 	sdl: false,
-	number: "Float"
+	number: "Float",
+	schema: false
 });
-const KNOWN = /* @__PURE__ */ new Set(["sdl", "number"]);
+const KNOWN = /* @__PURE__ */ new Set([
+	"sdl",
+	"number",
+	"schema"
+]);
 /**
 * Merges `options` onto `base`. Throws a `TypeError` naming the option on an invalid value: options
 * are written in `znight.config.ts`, the error surfaces when the configuration is loaded.
 */
 function resolveOptions(base, options) {
-	if (typeof options !== "object" || options === null || Array.isArray(options)) throw new TypeError("[znight] graphql.configure() expects an options object: { sdl?, number? }");
-	for (const key of Object.keys(options)) if (!KNOWN.has(key)) throw new TypeError(`[znight] graphql.configure(): unknown option "${key}" (options: sdl, number)`);
+	if (typeof options !== "object" || options === null || Array.isArray(options)) throw new TypeError("[znight] graphql.configure() expects an options object: { sdl?, number?, schema? }");
+	for (const key of Object.keys(options)) if (!KNOWN.has(key)) throw new TypeError(`[znight] graphql.configure(): unknown option "${key}" (options: sdl, number, schema)`);
 	const sdl = options.sdl === void 0 ? base.sdl : options.sdl;
 	if (sdl !== false && (typeof sdl !== "string" || sdl.trim() === "")) throw new TypeError("[znight] graphql.configure(): \"sdl\" must be a path relative to the project root ('schema.graphql') or false");
 	const number = options.number === void 0 ? base.number : options.number;
 	if (number !== "Float" && number !== "Int") throw new TypeError(`[znight] graphql.configure(): "number" must be 'Float' or 'Int'`);
 	return Object.freeze({
 		sdl,
-		number
+		number,
+		schema: resolveSchema(base.schema, options.schema)
 	});
 }
+function resolveSchema(base, schema) {
+	if (schema === void 0) return base;
+	if (schema === false) return false;
+	const globs = typeof schema === "string" ? [schema] : schema;
+	if (!Array.isArray(globs) || globs.length === 0 || globs.some((glob) => typeof glob !== "string" || glob.trim() === "")) throw new TypeError("[znight] graphql.configure(): \"schema\" must be a glob or a non-empty list of globs relative to the project root ('src/**/*.graphql'), or false");
+	return Object.freeze([...globs]);
+}
+Object.freeze([
+	"graphql/language",
+	"graphql/type",
+	"graphql/utilities"
+]);
+let loaded;
+/** The graphql-js modules, loaded on first use. */
+function graphqlModules() {
+	if (loaded === void 0) {
+		const load = createRequire(import.meta.url);
+		loaded = Object.freeze({
+			language: load("graphql/language"),
+			type: load("graphql/type"),
+			utilities: load("graphql/utilities")
+		});
+	}
+	return loaded;
+}
+// src/compiler/conformance.ts
+const MAX_DEPTH = 64;
+/** Walks every binding; reports the mismatches. */
+function checkConformance(input) {
+	return new Conformance(input).run();
+}
+var Conformance = class {
+	#config;
+	#ctx;
+	#options;
+	#named = /* @__PURE__ */ new Map();
+	#visited = /* @__PURE__ */ new Set();
+	#anonymous = /* @__PURE__ */ new WeakMap();
+	#reported = /* @__PURE__ */ new Set();
+	#votes = /* @__PURE__ */ new Map();
+	/** Abstract type → member object type → class identities (`''`: not an exported class) returned for it. */
+	#members = /* @__PURE__ */ new Map();
+	/** TypeScript members of abstract types that cannot be told apart (ZNIGHT064 unless every member is a class). */
+	#untellable = /* @__PURE__ */ new Map();
+	#predicates = graphqlModules().type;
+	/** Identities of the `T` of the `scalar<T>()` declarations. */
+	#scalarTypes;
+	constructor(input) {
+		this.#config = input;
+		this.#ctx = input.ctx;
+		const keep = new Set(BASE_KEEP);
+		for (const scalar of input.scalars.values()) keep.add(scalar.type);
+		this.#scalarTypes = new Set([...input.scalars.values()].map((scalar) => scalar.type));
+		this.#options = Object.freeze({
+			keep: Object.freeze([...keep].sort(compareStrings)),
+			members: "instance",
+			jsdoc: false
+		});
+	}
+	run() {
+		for (const binding of this.#config.bindings) this.#binding(binding);
+		const nullAsUndefined = /* @__PURE__ */ new Set();
+		for (const [coordinate, vote] of [...this.#votes].sort(([a], [b]) => compareStrings(a, b))) {
+			if (vote.rejects.length === 0) continue;
+			if (vote.accepts === 0) {
+				nullAsUndefined.add(coordinate);
+				continue;
+			}
+			for (const site of vote.rejects) this.#mismatch(site, `${site.label} does not accept null, but another use of ${coordinate} does: null is passed as is`, ["Accept null (| null) in every TypeScript type of the value, or none of them"]);
+		}
+		return {
+			nullAsUndefined,
+			discriminators: this.#discriminators()
+		};
+	}
+	#binding(binding) {
+		const { resolver, field, method, type, sdlField } = binding;
+		const where = `${resolver.host.displayName}.${method.name}`;
+		const coordinate = `${type.name}.${sdlField.name}`;
+		const sdl = this.#config.locate(sdlField.astNode);
+		if (method.returnType !== void 0) {
+			const result = this.#shape({ returnOf: method });
+			const site = {
+				label: `${where} returns`,
+				origin: `returned by ${where}`,
+				coordinate,
+				locate: () => returnTypeLocation(this.#ctx.project, method) ?? method.location,
+				sdl,
+				optional: false
+			};
+			const root = result.root;
+			const iterable = root.kind === "reference" && ASYNC_ITERABLES.has(root.identity) ? root : void 0;
+			if (field.operation === "subscription") {
+				if (iterable !== void 0) this.#output(sdlField.type, iterable.typeArgs[0] ?? { kind: "unknown" }, site);
+				else if (!this.#parts(root).unchecked) this.#report({
+					code: Codes.InvalidResolver,
+					severity: "error",
+					message: `@Subscription ${where} must return an async iterable (${coordinate})`,
+					location: site.locate() ?? method.location,
+					hints: [`Declare it as an async generator (async *${method.name}(): AsyncGenerator<Event>) or return pubsub.subscribe(...) (AsyncIterable<Event>)`]
+				});
+			} else if (iterable === void 0) this.#output(sdlField.type, root, site);
+			else this.#mismatch(site, `${where} returns an async iterable: only Subscription fields stream values`, [`Use @Subscription() for a stream of events, or return the value of ${coordinate}`]);
+		}
+		field.params.forEach((data, index) => {
+			const param = method.params[index];
+			if (param === void 0) return;
+			if (data?.kind === "args" && data.schema === void 0) this.#arguments(binding, data.name, param, where);
+			else if (data?.kind === "parent") this.#parent(type, param, where);
+		});
+	}
+	/** `@Args('name')` (one argument) or `@Args()` (every argument, an object type). */
+	#arguments(binding, name, param, where) {
+		const { type, sdlField } = binding;
+		const coordinate = `${type.name}.${sdlField.name}`;
+		const result = this.#shape({ parameter: param });
+		if (name !== void 0) {
+			const arg = sdlField.args.find((candidate) => candidate.name === name);
+			if (arg === void 0) return;
+			this.#input(arg.type, result.root, {
+				optional: param.optional || param.hasDefault,
+				sdlDefault: arg.default !== void 0,
+				vote: `${coordinate}(${name}:)`
+			}, {
+				label: `parameter '${param.name}' of ${where}`,
+				origin: `parameter '${param.name}' of ${where}`,
+				coordinate: `${coordinate}(${name}:)`,
+				locate: () => param.typeLocation,
+				sdl: this.#config.locate(arg.astNode),
+				optional: false
+			});
+			return;
+		}
+		const site = {
+			label: `@Args() parameter '${param.name}' of ${where}`,
+			origin: `@Args() parameter '${param.name}' of ${where}`,
+			coordinate,
+			locate: () => param.typeLocation,
+			sdl: this.#config.locate(sdlField.astNode),
+			optional: false
+		};
+		const parts = this.#parts(result.root);
+		if (parts.unchecked) return;
+		const object = parts.members.length === 1 ? parts.members[0] : void 0;
+		const properties = object === void 0 ? void 0 : this.#propertiesOf(object);
+		if (properties === "record") return;
+		if (properties === void 0) {
+			this.#mismatch(site, `${site.label} must be an object type: it receives every argument of ${coordinate}`, [`@Args('name') receives one argument`]);
+			return;
+		}
+		for (const property of properties) {
+			const arg = sdlField.args.find((candidate) => candidate.name === property.name);
+			const propertySite = {
+				label: `property '${property.name}' of the @Args() parameter of ${where}`,
+				origin: site.origin,
+				coordinate: `${coordinate}(${property.name}:)`,
+				locate: () => annotationLocation(this.#ctx.project, property.location) ?? param.typeLocation,
+				sdl: this.#config.locate(arg?.astNode ?? sdlField.astNode),
+				optional: false
+			};
+			if (arg === void 0) {
+				const names = sdlField.args.map((candidate) => candidate.name);
+				this.#mismatch({
+					...propertySite,
+					locate: () => property.location ?? param.typeLocation
+				}, `${coordinate} has no argument '${property.name}' (${propertySite.label})`, [names.length === 0 ? `${coordinate} takes no argument` : `Its arguments: ${names.join(", ")}`]);
+				continue;
+			}
+			this.#input(arg.type, property.shape, {
+				optional: property.optional,
+				sdlDefault: arg.default !== void 0,
+				vote: propertySite.coordinate
+			}, propertySite);
+		}
+	}
+	/** `@Parent()`: its properties named like the unbound fields of the type conform to them. */
+	#parent(type, param, where) {
+		const result = this.#shape({ parameter: param });
+		const site = {
+			label: `@Parent() parameter '${param.name}' of ${where}`,
+			origin: `@Parent() parameter of ${where}`,
+			coordinate: type.name,
+			locate: () => param.typeLocation,
+			sdl: this.#config.locate(type.astNode),
+			optional: false
+		};
+		const parts = this.#parts(result.root);
+		if (parts.unchecked) return;
+		for (const member of parts.members) {
+			const properties = this.#propertiesOf(member);
+			if (properties === "record") continue;
+			if (properties === void 0) {
+				this.#mismatch(site, `${site.label} is ${this.#describe(member)}, not an object type (${type.name})`, [`Type it with the TypeScript type of ${type.name}`]);
+				continue;
+			}
+			const fields = type.getFields();
+			for (const property of properties) {
+				const field = fields[property.name];
+				if (field === void 0 || this.#config.bound.has(`${type.name}.${field.name}`)) continue;
+				this.#output(field.type, property.shape, this.#propertySite(site, type, field, property, member));
+			}
+		}
+	}
+	#output(type, shape, site, depth = 0) {
+		if (depth > MAX_DEPTH) return;
+		const parts = this.#parts(shape);
+		if (parts.unchecked) return;
+		const { isNonNullType, isListType, isScalarType, isEnumType, isObjectType } = this.#predicates;
+		let inner = type;
+		if (isNonNullType(inner)) {
+			if (parts.hasNull || parts.hasUndefined || site.optional) {
+				const what = parts.hasNull ? "null" : "undefined";
+				const described = `${site.label} ${this.#describeParts(parts, site.optional)}, which may be ${what}`;
+				if (site.list === void 0) this.#mismatch(site, `${described}, but ${site.coordinate} is ${String(type)} (non-null)`, [`Return a value in every case, or make ${site.coordinate} nullable in the SDL (${String(inner.ofType)})`]);
+				else this.#mismatch(site, `${described}, but the items of ${site.coordinate} (${site.list}) are ${String(type)} (non-null)`, [`Return non-null items, or make the items of ${site.coordinate} nullable in the SDL`]);
+			}
+			inner = inner.ofType;
+		}
+		if (parts.members.length === 0) return;
+		if (isListType(inner)) {
+			for (const member of parts.members) {
+				const item = this.#listItem(member, "output");
+				if (item === void 0) {
+					this.#mismatch(site, `${site.label} ${this.#describe(member)}, not a list, but ${site.coordinate} is ${String(type)}`, ["Return an array (readonly T[]), a Set or an Iterable"]);
+					continue;
+				}
+				for (const shape of item) this.#output(inner.ofType, shape, {
+					...site,
+					label: `${site.label} a list of`,
+					optional: false,
+					list: site.list ?? String(type)
+				}, depth + 1);
+			}
+			return;
+		}
+		if (isScalarType(inner)) {
+			for (const member of parts.members) {
+				if (this.#scalarAccepts(inner.name, member, "output")) continue;
+				this.#mismatch(site, `${site.label} ${this.#describe(member)}, which does not conform to ${inner.name} (${site.coordinate})`, [this.#scalarHint(inner.name)]);
+			}
+			return;
+		}
+		if (isEnumType(inner)) {
+			const values = new Set(inner.getValues().map((value) => value.name));
+			for (const member of parts.members) {
+				const literals = this.#literals(member);
+				if (literals === void 0) {
+					this.#mismatch(site, `${site.label} ${this.#describe(member)}, wider than the enum ${inner.name} (${site.coordinate})`, [`Return the values of ${inner.name}: ${[...values].join(", ")} (a TypeScript enum or a union of literals)`]);
+					continue;
+				}
+				const unknown = literals.filter((literal) => !values.has(String(literal)));
+				if (unknown.length > 0) this.#mismatch(site, `${site.label} ${unknown.map((literal) => JSON.stringify(literal)).join(", ")}, not ${unknown.length === 1 ? "a value" : "values"} of the enum ${inner.name} (${site.coordinate})`, [`Enum values are compared by value: ${[...values].join(", ")}`]);
+			}
+			return;
+		}
+		if (isObjectType(inner)) {
+			for (const member of parts.members) this.#object(inner, member, site, depth);
+			return;
+		}
+		this.#abstract(inner, parts.members, site, depth);
+	}
+	/** An object type returned as `shape`: every field without resolver is a conforming property. */
+	#object(type, shape, site, depth) {
+		const properties = this.#propertiesOf(shape);
+		if (properties === "record") return;
+		if (properties === void 0) {
+			this.#mismatch(site, `${site.label} ${this.#describe(shape)}, not an object type, but ${site.coordinate} is ${type.name}`, [`Return the TypeScript type of ${type.name} (an interface, a class or an object type)`]);
+			return;
+		}
+		if (!this.#visit(`output\0${type.name}`, shape)) return;
+		const named = shape.kind === "named" ? this.#named.get(shape.key) : void 0;
+		const tsName = named?.name ?? "the returned object type";
+		const byName = new Map(properties.map((property) => [property.name, property]));
+		for (const field of Object.values(type.getFields())) {
+			const coordinate = `${type.name}.${field.name}`;
+			if (this.#config.bound.has(coordinate)) continue;
+			const property = byName.get(field.name);
+			if (property === void 0) {
+				const location = this.#config.locate(field.astNode);
+				const declaration = named?.location ?? site.locate();
+				this.#reportOnce(`provide\0${coordinate}\0${named?.key ?? site.label}`, {
+					code: Codes.SchemaMismatch,
+					severity: "error",
+					message: `${coordinate} has no resolver, and ${tsName} (${site.origin}) has no property '${field.name}'`,
+					...location === void 0 ? {} : { location },
+					hints: [`Add a field resolver: @ResolveField('${field.name}') in a @Resolver('${type.name}') class`, `Or add '${field.name}' to ${tsName}`],
+					...declaration === void 0 ? {} : { related: [{
+						message: `${tsName} is declared here`,
+						location: declaration
+					}] }
+				});
+				continue;
+			}
+			this.#output(field.type, property.shape, this.#propertySite(site, type, field, property, shape), depth + 1);
+		}
+	}
+	/** A union or an interface: each TypeScript member is matched to a possible type. */
+	#abstract(type, members, site, depth) {
+		const names = this.#config.schema.getPossibleTypes(type).map((object) => object.name);
+		for (const member of members) {
+			const named = member.kind === "named" ? this.#named.get(member.key) : void 0;
+			const properties = this.#propertiesOf(member);
+			if (properties === void 0) {
+				this.#mismatch(site, `${site.label} ${this.#describe(member)}, not an object type, but ${site.coordinate} is ${type.name}`, [`Return one of ${names.join(", ")}`]);
+				continue;
+			}
+			if (properties === "record") continue;
+			if (named?.name === type.name && this.#predicates.isInterfaceType(type)) {
+				if (!this.#visit(`interface\0${type.name}`, member)) continue;
+				const byName = new Map(properties.map((property) => [property.name, property]));
+				for (const field of Object.values(type.getFields())) {
+					const property = byName.get(field.name);
+					if (property !== void 0) this.#output(field.type, property.shape, this.#propertySite(site, type, field, property, member), depth + 1);
+				}
+				continue;
+			}
+			const typename = properties.find((property) => property.name === "__typename");
+			const literal = typename?.shape.kind === "literal" ? typename.shape.value : void 0;
+			let target = typeof literal === "string" ? literal : void 0;
+			if (target === void 0 && named !== void 0 && names.includes(named.name)) target = named.name;
+			if (target === void 0 || !names.includes(target)) {
+				const what = named?.name ?? this.#describe(member);
+				if (names.length === 0) {
+					this.#mismatch(site, `${site.label} ${what}, but no object type implements ${type.name} in the SDL`, [`Declare an implementation: type ${what} implements ${type.name} { ... }`]);
+					continue;
+				}
+				this.#mismatch(site, `${site.label} ${what}, which is not ${names.length === 1 ? "the member" : "a member"} of ${type.name} (${names.join(", ")})`, [`Return ${names.join(" | ")}: a member is recognised by its __typename literal (__typename: '${names[0] ?? "Member"}'), else by its name`]);
+				continue;
+			}
+			const object = this.#config.schema.getType(target);
+			this.#object(object, member, site, depth + 1);
+			const identity = named?.declaration === "class" && named.typeArgs.length === 0 && this.#ctx.classInfo(named.identity)?.exported === true ? named.identity : "";
+			let byMember = this.#members.get(type.name);
+			if (byMember === void 0) {
+				byMember = /* @__PURE__ */ new Map();
+				this.#members.set(type.name, byMember);
+			}
+			let identities = byMember.get(target);
+			if (identities === void 0) {
+				identities = /* @__PURE__ */ new Set();
+				byMember.set(target, identities);
+			}
+			identities.add(identity);
+			if (typename === void 0 && identity === "") {
+				let list = this.#untellable.get(type.name);
+				if (list === void 0) {
+					list = [];
+					this.#untellable.set(type.name, list);
+				}
+				list.push({
+					name: named?.name ?? target,
+					site,
+					...named === void 0 ? {} : { location: named.location }
+				});
+			}
+		}
+	}
+	#input(type, shape, position, site, depth = 0) {
+		if (depth > MAX_DEPTH) return;
+		const parts = this.#parts(shape);
+		const { isNonNullType, isListType, isScalarType, isEnumType } = this.#predicates;
+		let inner = type;
+		if (isNonNullType(inner)) inner = inner.ofType;
+		else {
+			const acceptsNull = parts.hasNull || parts.unchecked;
+			const acceptsUndefined = position.item !== true && (parts.hasUndefined || position.optional || parts.unchecked);
+			if (position.item === true) {
+				if (!acceptsNull) this.#mismatch(site, `${site.label} does not accept null, but the items of ${site.coordinate} (${site.list ?? String(type)}) may be null`, [`Accept null items ((T | null)[]), or make the items non-null in the SDL (${String(type)}!)`]);
+			} else if (!position.sdlDefault && !acceptsUndefined) this.#mismatch(site, `${site.label} does not accept undefined, but ${site.coordinate} (${String(type)}) may be omitted`, ["Make it optional (?: or | undefined), or make the SDL argument non-null or give it a default value"]);
+			else if (!acceptsNull && !acceptsUndefined) this.#mismatch(site, `${site.label} does not accept null, but ${site.coordinate} (${String(type)}) may be null`, [`Accept null (| null) or undefined, or make it non-null in the SDL (${String(type)}!)`]);
+			if (position.vote !== void 0 && !parts.unchecked) {
+				let vote = this.#votes.get(position.vote);
+				if (vote === void 0) {
+					vote = {
+						accepts: 0,
+						rejects: []
+					};
+					this.#votes.set(position.vote, vote);
+				}
+				if (acceptsNull) vote.accepts++;
+				else if (acceptsUndefined) vote.rejects.push(site);
+			}
+		}
+		if (parts.unchecked) return;
+		if (parts.members.length === 0) {
+			this.#mismatch(site, `${site.label} accepts no ${String(inner)} value (${site.coordinate})`, [`Type it with the TypeScript type of ${String(inner)}`]);
+			return;
+		}
+		if (isListType(inner)) {
+			const lists = parts.members.map((member) => this.#listItem(member, "input")).filter((item) => item !== void 0);
+			if (lists.length === 0) {
+				this.#mismatch(site, `${site.label} is ${this.#describeParts(parts, false)}, not an array, but ${site.coordinate} is ${String(type)}`, ["Accept an array (readonly T[]): graphql-js always passes lists as arrays"]);
+				return;
+			}
+			for (const items of lists) for (const item of items) this.#input(inner.ofType, item, {
+				optional: false,
+				sdlDefault: true,
+				item: true
+			}, {
+				...site,
+				label: `${site.label} (items)`,
+				list: site.list ?? String(type)
+			}, depth + 1);
+			return;
+		}
+		if (isScalarType(inner)) {
+			if (parts.members.some((member) => this.#scalarAccepts(inner.name, member, "input"))) return;
+			this.#mismatch(site, `${site.label} is ${this.#describeParts(parts, false)}, which does not accept every ${inner.name} (${site.coordinate})`, [this.#scalarHint(inner.name)]);
+			return;
+		}
+		if (isEnumType(inner)) {
+			const accepted = /* @__PURE__ */ new Set();
+			for (const member of parts.members) {
+				if (member.kind === "string") return;
+				for (const literal of this.#literals(member) ?? []) accepted.add(String(literal));
+			}
+			const missing = inner.getValues().filter((value) => !accepted.has(value.name));
+			if (missing.length > 0) this.#mismatch(site, `${site.label} is ${this.#describeParts(parts, false)}, which does not accept ${missing.map((value) => value.name).join(", ")} of the enum ${inner.name} (${site.coordinate})`, [`Accept every value of ${inner.name} (graphql-codegen's enum type, or a union of every value)`]);
+			return;
+		}
+		const objects = parts.members.filter((member) => this.#propertiesOf(member) !== void 0);
+		if (objects.length === 0) {
+			this.#mismatch(site, `${site.label} is ${this.#describeParts(parts, false)}, not an object type, but ${site.coordinate} is ${inner.name}`, [`Type it with the TypeScript type of the input ${inner.name}`]);
+			return;
+		}
+		for (const object of objects) this.#inputObject(inner, object, site, depth);
+	}
+	/** An input object received as `shape`: each property is a field of the input, accepting its values. */
+	#inputObject(type, shape, site, depth) {
+		const properties = this.#propertiesOf(shape);
+		if (properties === void 0 || properties === "record") return;
+		if (!this.#visit(`input\0${type.name}`, shape)) return;
+		const fields = type.getFields();
+		for (const property of properties) {
+			if (property.name === "__typename") continue;
+			const field = fields[property.name];
+			const propertySite = {
+				label: this.#tsName(shape) === void 0 ? `property '${property.name}'` : `${this.#tsName(shape)}.${property.name}`,
+				origin: site.origin,
+				coordinate: `${type.name}.${property.name}`,
+				locate: () => annotationLocation(this.#ctx.project, property.location) ?? site.locate(),
+				sdl: this.#config.locate(field?.astNode ?? type.astNode),
+				optional: false
+			};
+			if (field === void 0) {
+				this.#mismatch({
+					...propertySite,
+					locate: () => property.location ?? site.locate()
+				}, `${propertySite.label} is not a field of the input ${type.name}: it is always undefined`, [`Remove it, or declare it in the SDL (input ${type.name} { ${property.name}: ... })`]);
+				continue;
+			}
+			this.#input(field.type, property.shape, {
+				optional: property.optional,
+				sdlDefault: field.default !== void 0,
+				vote: propertySite.coordinate
+			}, propertySite, depth + 1);
+		}
+	}
+	/** A member (not nullish, not a union) conforms to a scalar: output, or accepts every value: input. */
+	#scalarAccepts(name, shape, position) {
+		const custom = this.#config.scalars.get(name);
+		if (custom !== void 0) return this.#hasReference(shape, custom.type);
+		if ((name === "String" || name === "ID") && shape.kind === "reference" && this.#scalarTypes.has(shape.identity)) return true;
+		const output = position === "output";
+		switch (name) {
+			case "String": return this.#isString(shape, output);
+			case "ID": return this.#isString(shape, output) || output && this.#isNumber(shape, true);
+			case "Int":
+			case "Float": return this.#isNumber(shape, output);
+			case "Boolean": return shape.kind === "boolean" || output && shape.kind === "literal" && typeof shape.value === "boolean";
+			case "DateTime": return shape.kind === "date";
+			case "BigInt": return shape.kind === "bigint" || output && this.#isNumber(shape, true);
+			default: return true;
+		}
+	}
+	#scalarHint(name) {
+		const custom = this.#config.scalars.get(name);
+		if (custom !== void 0) return `${name} is declared with scalar<${custom.type.slice(custom.type.indexOf("#") + 1)}>(): use that type (graphql-codegen: scalars: { ${name}: '...' })`;
+		switch (name) {
+			case "Int":
+			case "Float": return "Use number (or the Int / Float aliases of @znight/graphql)";
+			case "Boolean": return "Use boolean";
+			case "DateTime": return "The built-in DateTime scalar is a Date";
+			case "BigInt": return "The built-in BigInt scalar is a bigint";
+			default: return "Use string (string literals, string enums and branded strings conform in output positions)";
+		}
+	}
+	/** `string`, a branded string, the `ID` alias; output: also string literals and string enums. */
+	#isString(shape, output) {
+		switch (shape.kind) {
+			case "string": return true;
+			case "literal": return output && typeof shape.value === "string";
+			case "reference": return shape.identity === GraphQLIds.ID;
+			case "intersection": return shape.members.some((member) => member.kind === "string" || member.kind === "reference" && member.identity === GraphQLIds.ID);
+			case "named": {
+				const named = this.#named.get(shape.key);
+				return output && named?.declaration === "enum" && (this.#literals(shape) ?? []).every((value) => typeof value === "string");
+			}
+			default: return false;
+		}
+	}
+	/** `number`, a branded number, the `Int` / `Float` aliases; output: also number literals and numeric enums. */
+	#isNumber(shape, output) {
+		const alias = (candidate) => candidate.kind === "reference" && (candidate.identity === GraphQLIds.Int || candidate.identity === GraphQLIds.Float);
+		switch (shape.kind) {
+			case "number": return true;
+			case "literal": return output && typeof shape.value === "number";
+			case "reference": return alias(shape);
+			case "intersection": return shape.members.some((member) => member.kind === "number" || alias(member));
+			case "named": {
+				const named = this.#named.get(shape.key);
+				return output && named?.declaration === "enum" && (this.#literals(shape) ?? []).every((value) => typeof value === "number");
+			}
+			default: return false;
+		}
+	}
+	#hasReference(shape, identity) {
+		if (shape.kind === "reference") return shape.identity === identity;
+		if (shape.kind === "intersection") return shape.members.some((member) => this.#hasReference(member, identity));
+		return false;
+	}
+	#shape(target) {
+		const result = this.#ctx.types.shape(target, this.#options);
+		for (const named of result.named.values()) this.#named.set(named.key, named);
+		return result;
+	}
+	/** The non-nullish members of a shape, through unions and aliases (object aliases stay named). */
+	#parts(shape) {
+		const parts = {
+			members: [],
+			hasNull: false,
+			hasUndefined: false,
+			unchecked: false
+		};
+		const visit = (current, depth) => {
+			if (depth > MAX_DEPTH) return;
+			switch (current.kind) {
+				case "null":
+					parts.hasNull = true;
+					return;
+				case "undefined":
+					parts.hasUndefined = true;
+					return;
+				case "unknown":
+				case "opaque":
+				case "schema":
+					parts.unchecked = true;
+					return;
+				case "never": return;
+				case "union":
+					for (const member of current.members) visit(member, depth + 1);
+					return;
+				case "named": {
+					const named = this.#named.get(current.key);
+					if (named === void 0) {
+						parts.unchecked = true;
+						return;
+					}
+					const target = named.shape;
+					const isObject = target.kind === "object" || target.kind === "intersection" && this.#propertiesOf(target) !== void 0 || target.kind === "named" && this.#named.get(target.key)?.declaration !== "alias";
+					if (named.declaration !== "alias" || isObject) parts.members.push(current);
+					else visit(target, depth + 1);
+					return;
+				}
+				default: parts.members.push(current);
+			}
+		};
+		visit(shape, 0);
+		return parts;
+	}
+	/** The item shapes of a list member (array, tuple, iterable); `undefined`: not a list. */
+	#listItem(shape, position) {
+		if (shape.kind === "array") return [shape.items];
+		if (shape.kind === "tuple") return position === "output" ? [...shape.items, ...shape.rest === void 0 ? [] : [shape.rest]] : void 0;
+		if (shape.kind === "reference" && position === "output" && OUTPUT_ITERABLES.has(shape.identity)) return [shape.typeArgs[0] ?? { kind: "unknown" }];
+	}
+	/** The literal values of a member: a literal, an enum; `undefined`: not literals. */
+	#literals(shape) {
+		if (shape.kind === "literal") return [shape.value];
+		if (shape.kind !== "named") return void 0;
+		const named = this.#named.get(shape.key);
+		if (named?.declaration !== "enum") return void 0;
+		if (named.enumMembers !== void 0) return named.enumMembers.map((member) => member.value);
+		const target = named.shape;
+		if (target.kind === "literal") return [target.value];
+		if (target.kind === "union" && target.members.every((member) => member.kind === "literal")) return target.members.map((member) => member.value);
+	}
+	/** The properties of an object structure (intersections merged, later members win), `'record'` for index signatures. */
+	#propertiesOf(shape, depth = 0) {
+		if (depth > MAX_DEPTH) return void 0;
+		switch (shape.kind) {
+			case "object": return shape.additional === void 0 ? shape.properties : "record";
+			case "named": {
+				const named = this.#named.get(shape.key);
+				return named === void 0 || named.declaration === "enum" ? void 0 : this.#propertiesOf(named.shape, depth + 1);
+			}
+			case "intersection": {
+				const merged = /* @__PURE__ */ new Map();
+				for (const member of shape.members) {
+					const properties = this.#propertiesOf(member, depth + 1);
+					if (properties === void 0 || properties === "record") return properties;
+					for (const property of properties) {
+						merged.delete(property.name);
+						merged.set(property.name, property);
+					}
+				}
+				return [...merged.values()];
+			}
+			default: return;
+		}
+	}
+	/** `true` the first time `(namespace, shape)` is visited: named shapes by key, anonymous ones by identity. */
+	#visit(namespace, shape) {
+		if (shape.kind === "named") {
+			const key = `${namespace}\0${shape.key}`;
+			if (this.#visited.has(key)) return false;
+			this.#visited.add(key);
+			return true;
+		}
+		let seen = this.#anonymous.get(shape);
+		if (seen === void 0) {
+			seen = /* @__PURE__ */ new Set();
+			this.#anonymous.set(shape, seen);
+		}
+		if (seen.has(namespace)) return false;
+		seen.add(namespace);
+		return true;
+	}
+	#propertySite(site, type, field, property, owner) {
+		const name = this.#tsName(owner);
+		return {
+			label: `${name === void 0 ? `property '${property.name}'` : `${name}.${property.name}`} is`,
+			origin: `type of ${name === void 0 ? `property '${property.name}'` : `${name}.${property.name}`}, ${site.origin}`,
+			coordinate: `${type.name}.${field.name}`,
+			locate: () => annotationLocation(this.#ctx.project, property.location) ?? site.locate(),
+			sdl: this.#config.locate(field.astNode),
+			optional: property.optional
+		};
+	}
+	#tsName(shape) {
+		return shape.kind === "named" ? this.#named.get(shape.key)?.name : void 0;
+	}
+	/**
+	* `instanceof` when every TypeScript member returned for an abstract type is an exported class
+	* (one per member), else `__typename`; members that are neither are ZNIGHT064.
+	*/
+	#discriminators() {
+		const result = /* @__PURE__ */ new Map();
+		for (const [name, byMember] of [...this.#members].sort(([a], [b]) => compareStrings(a, b))) {
+			const classes = [];
+			for (const [member, identities] of byMember) for (const identity of identities) if (identity !== "") classes.push({
+				identity,
+				name: member,
+				depth: this.#classDepth(identity)
+			});
+			if (classes.length > 0) {
+				classes.sort((a, b) => b.depth - a.depth || compareStrings(a.name, b.name) || compareStrings(a.identity, b.identity));
+				result.set(name, {
+					by: "class",
+					classes: classes.map(({ identity, name: member }) => ({
+						identity,
+						name: member
+					}))
+				});
+			}
+			for (const entry of this.#untellable.get(name) ?? []) {
+				const location = entry.site.locate();
+				this.#reportOnce(`untellable\0${name}\0${entry.name}`, {
+					code: Codes.UnresolvableAbstractType,
+					severity: "error",
+					message: `${entry.name} cannot be told apart among the members of ${name} at runtime: it declares no __typename and is not an exported class`,
+					...location === void 0 ? {} : { location },
+					hints: [`Return objects carrying __typename (declare __typename: '${entry.name}' in the TypeScript type; graphql-codegen declares it), or return exported class instances`],
+					...entry.location === void 0 ? {} : { related: [{
+						message: `${entry.name} is declared here`,
+						location: entry.location
+					}] }
+				});
+			}
+		}
+		return result;
+	}
+	#classDepth(identity) {
+		let depth = 0;
+		let current = this.#ctx.classInfo(identity)?.superClass?.identity;
+		const seen = /* @__PURE__ */ new Set();
+		while (current !== void 0 && !seen.has(current) && depth < MAX_DEPTH) {
+			seen.add(current);
+			depth++;
+			current = this.#ctx.classInfo(current)?.superClass?.identity;
+		}
+		return depth;
+	}
+	#report(diagnostic) {
+		this.#config.report(diagnostic);
+	}
+	#reportOnce(key, diagnostic) {
+		if (this.#reported.has(key)) return;
+		this.#reported.add(key);
+		this.#report(diagnostic);
+	}
+	#mismatch(site, message, hints) {
+		const location = site.locate();
+		const key = `${location?.file}:${location?.start}\0${message}`;
+		this.#reportOnce(key, {
+			code: Codes.SchemaMismatch,
+			severity: "error",
+			message,
+			...location === void 0 ? {} : { location },
+			...hints.length === 0 ? {} : { hints },
+			...site.sdl === void 0 ? {} : { related: [{
+				message: `${site.coordinate} is declared here`,
+				location: site.sdl
+			}] }
+		});
+	}
+	#describeParts(parts, optional) {
+		const members = parts.members.map((member) => this.#describe(member));
+		if (parts.hasNull) members.push("null");
+		if (parts.hasUndefined || optional) members.push("undefined");
+		return members.join(" | ");
+	}
+	/** Short description of a shape for messages (`string`, `Book`, `'a'`, `Book[]`). */
+	#describe(shape) {
+		switch (shape.kind) {
+			case "literal": return JSON.stringify(shape.value);
+			case "named": return this.#named.get(shape.key)?.name ?? shape.key.slice(shape.key.indexOf("#") + 1);
+			case "reference": return shape.name;
+			case "opaque": return shape.text;
+			case "array": return `${this.#describe(shape.items)}[]`;
+			case "union":
+			case "intersection": return shape.members.map((member) => this.#describe(member)).join(shape.kind === "union" ? " | " : " & ");
+			case "object": return "an object literal type";
+			case "tuple": return "a tuple";
+			default: return shape.kind;
+		}
+	}
+};
+// src/compiler/suggest.ts
+/**
+* "Did you mean" suggestions of the schema-first diagnostics (RFC 0007 §5.3). Import-free.
+*/
+/**
+* The candidate closest to `name` (Levenshtein distance, case differences counting half), when it
+* is close enough to be a typo: at most a third of the name's length, at least 1. Ties keep the
+* first candidate, so callers pass them sorted.
+*/
+function closest(name, candidates) {
+	const limit = Math.max(1, Math.floor(name.length / 3));
+	let best;
+	let bestDistance = Number.POSITIVE_INFINITY;
+	for (const candidate of candidates) {
+		if (candidate === name) continue;
+		const distance = candidate.toLowerCase() === name.toLowerCase() ? .5 : levenshtein(name, candidate);
+		if (distance <= limit && distance < bestDistance) {
+			best = candidate;
+			bestDistance = distance;
+		}
+	}
+	return best;
+}
+function levenshtein(a, b) {
+	if (Math.abs(a.length - b.length) > Math.max(a.length, b.length) / 2) return Number.POSITIVE_INFINITY;
+	let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+	for (let i = 1; i <= a.length; i++) {
+		const current = [i];
+		for (let j = 1; j <= b.length; j++) {
+			const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
+			current.push(Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + cost));
+		}
+		previous = current;
+	}
+	return previous[b.length];
+}
+// src/compiler/sdl-source.ts
+/** Directives graphql-js knows (specified, or `@defer`/`@stream` of graphql 17). */
+const KNOWN_DIRECTIVES = /* @__PURE__ */ new Set([
+	"deprecated",
+	"specifiedBy",
+	"oneOf",
+	"include",
+	"skip",
+	"defer",
+	"stream"
+]);
+/** The built-in directives allowed in an SDL (the others are executable directives). */
+const SDL_DIRECTIVES = /* @__PURE__ */ new Map([
+	["deprecated", {
+		locations: /* @__PURE__ */ new Set([
+			"FIELD_DEFINITION",
+			"ARGUMENT_DEFINITION",
+			"INPUT_FIELD_DEFINITION",
+			"ENUM_VALUE"
+		]),
+		args: /* @__PURE__ */ new Map([["reason", false]]),
+		repeatable: false
+	}],
+	["specifiedBy", {
+		locations: /* @__PURE__ */ new Set(["SCALAR"]),
+		args: /* @__PURE__ */ new Map([["url", true]]),
+		repeatable: false
+	}],
+	["oneOf", {
+		locations: /* @__PURE__ */ new Set(["INPUT_OBJECT"]),
+		args: /* @__PURE__ */ new Map(),
+		repeatable: false
+	}]
+]);
+/** The directive location of each kind of type definition and extension. */
+const TYPE_LOCATIONS = {
+	type: "OBJECT",
+	interface: "INTERFACE",
+	union: "UNION",
+	enum: "ENUM",
+	input: "INPUT_OBJECT",
+	scalar: "SCALAR"
+};
+/** Names of the types graphql-js always provides. */
+const PROVIDED_TYPES = /* @__PURE__ */ new Set([
+	"String",
+	"Int",
+	"Float",
+	"Boolean",
+	"ID"
+]);
+/** Directive locations in messages. */
+const LOCATION_NAMES = {
+	SCHEMA: "the schema",
+	SCALAR: "scalars",
+	OBJECT: "object types",
+	FIELD_DEFINITION: "fields",
+	ARGUMENT_DEFINITION: "arguments",
+	INTERFACE: "interfaces",
+	UNION: "unions",
+	ENUM: "enums",
+	ENUM_VALUE: "enum values",
+	INPUT_OBJECT: "input objects",
+	INPUT_FIELD_DEFINITION: "input fields"
+};
+const TYPE_KINDS = {
+	ObjectTypeDefinition: "type",
+	ObjectTypeExtension: "type",
+	InterfaceTypeDefinition: "interface",
+	InterfaceTypeExtension: "interface",
+	UnionTypeDefinition: "union",
+	UnionTypeExtension: "union",
+	EnumTypeDefinition: "enum",
+	EnumTypeExtension: "enum",
+	InputObjectTypeDefinition: "input",
+	InputObjectTypeExtension: "input",
+	ScalarTypeDefinition: "scalar",
+	ScalarTypeExtension: "scalar"
+};
+/**
+* Reads, parses and validates the SDL; `undefined` after an error (reported). Warnings (custom
+* directives) do not stop the build.
+*/
+function loadSdl(ctx, patterns, report) {
+	const files = ctx.inputFiles(patterns);
+	if (files.length === 0) {
+		report({
+			code: Codes.InvalidSdl,
+			severity: "error",
+			message: `No GraphQL schema file matches ${patterns.map((pattern) => `'${pattern}'`).join(", ")} (schema-first)`,
+			hints: ["The globs of graphql.configure({ schema }) are relative to the project root: 'src/**/*.graphql'", "Remove the schema option to derive the schema from the TypeScript types (code-first)"]
+		});
+		return;
+	}
+	const { language, type, utilities } = graphqlModules();
+	const locator = new Locator(new Map(files.map((file) => [file.file, file.text])));
+	let errors = 0;
+	const fail = (message, node, hints = [], related) => {
+		errors++;
+		const location = locator.locate(node);
+		const other = related === void 0 ? void 0 : locator.locate(related);
+		report({
+			code: Codes.InvalidSdl,
+			severity: "error",
+			message,
+			...location === void 0 ? {} : { location },
+			...hints.length === 0 ? {} : { hints },
+			...other === void 0 ? {} : { related: [{
+				message: "first declared here",
+				location: other
+			}] }
+		});
+	};
+	const documents = [];
+	for (const file of files) {
+		if (/^(?:\s|,|#[^\n\r]*)*$/.test(file.text.replace(/^\uFEFF/, ""))) continue;
+		try {
+			documents.push(language.parse(new language.Source(file.text, file.file)));
+		} catch (error) {
+			const position = error.positions?.[0];
+			errors++;
+			const location = position === void 0 ? void 0 : locator.at(file.file, position, position + 1);
+			report({
+				code: Codes.InvalidSdl,
+				severity: "error",
+				message: `${error.message} (${file.relativeFile})`,
+				...location === void 0 ? {} : { location }
+			});
+		}
+	}
+	if (errors > 0) return void 0;
+	if (documents.length === 0) {
+		report({
+			code: Codes.InvalidSdl,
+			severity: "error",
+			message: `The GraphQL schema files matching ${patterns.map((pattern) => `'${pattern}'`).join(", ")} define nothing (schema-first)`,
+			hints: ["Declare the types of the schema, starting with type Query { ... }"]
+		});
+		return;
+	}
+	const document = utilities.concatAST(documents);
+	const customDirectives = checkStructure(document, fail, (message, node) => {
+		const location = locator.locate(node);
+		report({
+			code: Codes.InvalidSdl,
+			severity: "warning",
+			message,
+			...location === void 0 ? {} : { location },
+			hints: ["Znight serves the schema without custom directives (and so does the SDL artifact): remove it, or keep it for other tools"]
+		});
+	});
+	if (errors > 0) return void 0;
+	let schema;
+	try {
+		schema = utilities.buildASTSchema(document, { assumeValidSDL: true });
+	} catch (error) {
+		fail(`Invalid schema: ${error.message}`, error.nodes?.[0]);
+		return;
+	}
+	for (const problem of type.validateSchema(schema)) {
+		const [node, ...others] = (problem.nodes ?? []).filter((candidate) => candidate.loc !== void 0);
+		errors++;
+		const location = locator.locate(node);
+		const related = others.flatMap((other) => {
+			const at = locator.locate(other);
+			return at === void 0 ? [] : [{
+				message: "see also",
+				location: at
+			}];
+		});
+		report({
+			code: Codes.InvalidSdl,
+			severity: "error",
+			message: `Invalid schema: ${problem.message}`,
+			...location === void 0 ? {} : { location },
+			...related.length === 0 ? {} : { related },
+			...node === void 0 && schema.getQueryType() == null ? { hints: ["Declare the query root type in one of the files: type Query { ... }"] } : {}
+		});
+	}
+	if (errors > 0) return void 0;
+	return {
+		schema,
+		customDirectives,
+		locate: (node) => locator.locate(node)
+	};
+}
+/**
+* The checks graphql-js leaves to its SDL validation (not exported): unique type, field, value and
+* argument names, known types and directives, extensions of existing types of the same kind, one
+* schema definition. Returns the names of the custom directives (each reported as a warning).
+*/
+function checkStructure(document, fail, warn) {
+	const definitions = /* @__PURE__ */ new Map();
+	const directives = /* @__PURE__ */ new Map();
+	const specs = new Map(SDL_DIRECTIVES);
+	let schemaDefinition;
+	for (const definition of document.definitions) {
+		if (definition.kind === "SchemaDefinition") {
+			if (schemaDefinition === void 0) schemaDefinition = definition;
+			else fail("The schema is defined twice (schema { ... })", definition, ["Keep one schema definition"], schemaDefinition);
+			continue;
+		}
+		if (definition.kind === "DirectiveDefinition") {
+			const name = definition.name.value;
+			const previous = directives.get(name);
+			if (previous !== void 0) fail(`The directive @${name} is defined twice`, definition.name, [], previous);
+			else if (KNOWN_DIRECTIVES.has(name)) fail(`@${name} is a built-in directive: it cannot be redefined`, definition.name);
+			else {
+				directives.set(name, definition.name);
+				specs.set(name, {
+					locations: new Set(definition.locations.map((location) => location.value)),
+					args: new Map((definition.arguments ?? []).map((arg) => [arg.name.value, arg.type.kind === "NonNullType" && arg.defaultValue === void 0])),
+					repeatable: definition.repeatable
+				});
+				warn(`The custom directive @${name} is ignored`, definition.name);
+			}
+			continue;
+		}
+		const kind = TYPE_KINDS[definition.kind];
+		if (kind === void 0 || definition.kind.endsWith("Extension")) continue;
+		const node = definition;
+		const previous = definitions.get(node.name.value);
+		if (previous !== void 0) {
+			fail(`The type ${node.name.value} is defined twice`, node.name, [kind === "scalar" ? "Keep one of them, or rename one" : `Extend it instead (${declaration(`extend ${kind}`, kind, node.name.value)}), or rename one of them`], previous.name);
+			continue;
+		}
+		definitions.set(node.name.value, node);
+	}
+	const typeNames = [...definitions.keys(), ...PROVIDED_TYPES].sort(compareStrings);
+	const known = (name, where) => {
+		const value = name.name.value;
+		if (definitions.has(value) || PROVIDED_TYPES.has(value)) return;
+		const suggestion = closest(value, typeNames);
+		fail(`Unknown type ${value} (${where})`, name, suggestion === void 0 ? ["Define it, or fix the name"] : [`Did you mean ${suggestion}?`]);
+	};
+	/** The directives applied at `location`: known, allowed there, once unless repeatable, valid arguments. */
+	const directivesOf = (nodes, location) => {
+		const seen = /* @__PURE__ */ new Map();
+		for (const directive of nodes ?? []) {
+			const name = directive.name.value;
+			const spec = specs.get(name);
+			if (spec === void 0) {
+				fail(KNOWN_DIRECTIVES.has(name) ? `@${name} is an executable directive: it cannot be used in a schema` : `Unknown directive @${name}`, directive.name, KNOWN_DIRECTIVES.has(name) ? ["Remove it"] : [`Define it (directive @${name} on ${location}), or remove it`]);
+				continue;
+			}
+			if (!spec.locations.has(location)) fail(`@${name} cannot be used on ${LOCATION_NAMES[location] ?? location}`, directive.name, [`@${name} applies to ${[...spec.locations].map((where) => LOCATION_NAMES[where] ?? where).join(", ")}`]);
+			const previous = seen.get(name);
+			if (previous !== void 0 && !spec.repeatable) fail(`@${name} is applied twice`, directive.name, ["Apply it once"], previous);
+			seen.set(name, directive.name);
+			const given = /* @__PURE__ */ new Set();
+			for (const arg of directive.arguments ?? []) {
+				given.add(arg.name.value);
+				if (!spec.args.has(arg.name.value)) {
+					const names = [...spec.args.keys()];
+					fail(`@${name} has no argument '${arg.name.value}'`, arg.name, [names.length === 0 ? `@${name} takes no argument` : `Its arguments: ${names.join(", ")}`]);
+				}
+			}
+			for (const [arg, required] of spec.args) if (required && !given.has(arg)) fail(`@${name} needs its argument '${arg}'`, directive.name, [`@${name}(${arg}: ...)`]);
+		}
+	};
+	/** Members of a type: its definition and extensions, by name (fields, values, input fields). */
+	const members = /* @__PURE__ */ new Map();
+	const member = (typeName, kind, name) => {
+		let seen = members.get(typeName);
+		if (seen === void 0) {
+			seen = /* @__PURE__ */ new Map();
+			members.set(typeName, seen);
+		}
+		const previous = seen.get(name.value);
+		if (previous !== void 0) {
+			fail(`${typeName}.${name.value} is declared twice`, name, [`Keep one ${kind} named ${name.value}`], previous);
+			return;
+		}
+		seen.set(name.value, name);
+	};
+	const inputValues = (owner, values) => {
+		const seen = /* @__PURE__ */ new Map();
+		for (const value of values ?? []) {
+			const previous = seen.get(value.name.value);
+			if (previous !== void 0) fail(`Argument ${owner}(${value.name.value}:) is declared twice`, value.name, [], previous);
+			seen.set(value.name.value, value.name);
+			known(namedType(value.type), `${owner}(${value.name.value}:)`);
+			directivesOf(value.directives, "ARGUMENT_DEFINITION");
+		}
+	};
+	const fields = (owner, list) => {
+		for (const field of list ?? []) {
+			member(owner, "field", field.name);
+			known(namedType(field.type), `${owner}.${field.name.value}`);
+			inputValues(`${owner}.${field.name.value}`, field.arguments);
+			directivesOf(field.directives, "FIELD_DEFINITION");
+		}
+	};
+	const operations = /* @__PURE__ */ new Map();
+	for (const definition of document.definitions) {
+		if (definition.kind === "SchemaDefinition" || definition.kind === "SchemaExtension") {
+			for (const operation of definition.operationTypes ?? []) {
+				known(operation.type, `schema ${operation.operation}`);
+				const previous = operations.get(operation.operation);
+				if (previous !== void 0) fail(`The ${operation.operation} root type is declared twice`, operation, ["Keep one"], previous);
+				operations.set(operation.operation, operation);
+			}
+			directivesOf(definition.directives, "SCHEMA");
+			continue;
+		}
+		if (definition.kind === "DirectiveDefinition") {
+			inputValues(`@${definition.name.value}`, definition.arguments);
+			continue;
+		}
+		const kind = TYPE_KINDS[definition.kind];
+		if (kind === void 0) continue;
+		const node = definition;
+		const name = node.name.value;
+		if (definition.kind.endsWith("Extension")) {
+			const base = definitions.get(name);
+			if (base === void 0) {
+				if (!PROVIDED_TYPES.has(name)) {
+					const suggestion = closest(name, typeNames);
+					fail(`Cannot extend ${kind} ${name}: it is not defined`, node.name, [suggestion === void 0 ? `Define it: ${declaration(kind, kind, name)}` : `Did you mean ${suggestion}?`]);
+				}
+				continue;
+			}
+			if (TYPE_KINDS[base.kind] !== kind) {
+				const actual = TYPE_KINDS[base.kind];
+				fail(`Cannot extend ${name} as ${article(kind)} ${kind}: it is ${article(actual)} ${actual}`, node.name, [`Use ${declaration(`extend ${actual}`, actual, name)}`], base.name);
+				continue;
+			}
+		}
+		directivesOf(node.directives, TYPE_LOCATIONS[kind]);
+		for (const implemented of node.interfaces ?? []) known(implemented, `${name} implements`);
+		for (const target of node.types ?? []) known(target, `union ${name}`);
+		for (const value of node.values ?? []) {
+			member(name, "value", value.name);
+			directivesOf(value.directives, "ENUM_VALUE");
+		}
+		if (kind === "input") for (const field of node.fields ?? []) {
+			member(name, "field", field.name);
+			known(namedType(field.type), `${name}.${field.name.value}`);
+			directivesOf(field.directives, "INPUT_FIELD_DEFINITION");
+		}
+		else fields(name, node.fields);
+	}
+	return new Set(directives.keys());
+}
+/** `extend type Book { ... }`, `union Hit = ...`, `scalar Url`: valid SDL for a hint. */
+function declaration(keyword, kind, name) {
+	if (kind === "scalar") return `${keyword} ${name}`;
+	if (kind === "union") return `${keyword} ${name} = ...`;
+	return `${keyword} ${name} { ... }`;
+}
+function article(word) {
+	return /^[aeiou]/.test(word) ? "an" : "a";
+}
+function namedType(type) {
+	let current = type;
+	while (current.kind !== "NamedType") current = current.type;
+	return current;
+}
+/** Source locations of AST nodes (graphql-js `Source.name` is the absolute path of the file). */
+var Locator = class {
+	#texts;
+	#lines = /* @__PURE__ */ new Map();
+	constructor(texts) {
+		this.#texts = texts;
+	}
+	locate(node) {
+		if (node === null || node === void 0) return void 0;
+		const loc = ("name" in node && node.name !== void 0 && typeof node.name === "object" ? node.name : node).loc ?? node.loc;
+		if (loc === void 0) return void 0;
+		return this.at(loc.source.name, loc.start, loc.end);
+	}
+	at(file, start, end) {
+		const text = this.#texts.get(file);
+		if (text === void 0) return void 0;
+		const lines = this.#lineStarts(file, text);
+		const first = position(lines, start);
+		const last = position(lines, Math.min(end, text.length));
+		return {
+			file,
+			line: first.line,
+			column: first.column,
+			endLine: last.line,
+			endColumn: last.column,
+			start,
+			end
+		};
+	}
+	#lineStarts(file, text) {
+		let lines = this.#lines.get(file);
+		if (lines === void 0) {
+			lines = [0];
+			for (let index = 0; index < text.length; index++) {
+				const code = text.charCodeAt(index);
+				if (code === 10) lines.push(index + 1);
+				else if (code === 13) {
+					if (text.charCodeAt(index + 1) === 10) index++;
+					lines.push(index + 1);
+				}
+			}
+			this.#lines.set(file, lines);
+		}
+		return lines;
+	}
+};
+/** 1-based line and column (UTF-16 code units) of an offset. */
+function position(lines, offset) {
+	let low = 0;
+	let high = lines.length - 1;
+	while (low < high) {
+		const middle = low + high + 1 >> 1;
+		if (lines[middle] <= offset) low = middle;
+		else high = middle - 1;
+	}
+	return {
+		line: low + 1,
+		column: offset - lines[low] + 1
+	};
+}
+// src/compiler/schema-first.ts
+const DECORATORS = {
+	query: "@Query",
+	mutation: "@Mutation",
+	subscription: "@Subscription",
+	field: "@ResolveField"
+};
+/**
+* Builds the model from the SDL files matching `patterns`; `undefined` after an error. `artifact`:
+* the path of the SDL artifact (option `sdl`), never read back as an input.
+*/
+function buildSchemaFirstModel(ctx, patterns, artifact) {
+	return new SchemaFirstBuilder(ctx).build(artifact === false ? patterns : [...patterns, `!${artifact}`]);
+}
+var SchemaFirstBuilder = class {
+	#ctx;
+	#errors = 0;
+	#methods = /* @__PURE__ */ new Map();
+	constructor(ctx) {
+		this.#ctx = ctx;
+	}
+	build(patterns) {
+		const report = (diagnostic) => this.#report(diagnostic);
+		const stored = [...this.#ctx.stored].sort((a, b) => compareStrings(a.host.identity, b.host.identity));
+		const resolvers = stored.filter((resolver) => resolver.invalid !== true);
+		const rejected = stored.filter((resolver) => resolver.invalid === true);
+		checkLoaders(this.#ctx, resolvers, report);
+		const scalarDeclarations = readScalars(this.#ctx, report);
+		const sdl = loadSdl(this.#ctx, patterns, report);
+		if (sdl === void 0) {
+			checkDecisions(this.#ctx, resolvers, report);
+			return;
+		}
+		const schema = sdl.schema;
+		const roots = {
+			query: schema.getQueryType().name,
+			...schema.getMutationType() ? { mutation: schema.getMutationType().name } : {},
+			...schema.getSubscriptionType() ? { subscription: schema.getSubscriptionType().name } : {}
+		};
+		checkDecisions(this.#ctx, resolvers, report, roots);
+		const types = Object.values(schema.getTypeMap()).filter((type) => !type.name.startsWith("__") && !SPECIFIED_SCALARS.has(type.name)).sort((a, b) => compareStrings(a.name, b.name));
+		this.#checkUnsupported(sdl, types);
+		const scalars = this.#scalars(sdl, types, scalarDeclarations);
+		const { bindings, claimed: bound } = this.#bind(sdl, resolvers, rejected);
+		const conformance = checkConformance({
+			ctx: this.#ctx,
+			schema,
+			locate: (node) => sdl.locate(node),
+			scalars: new Map([...scalarDeclarations.values()].map((declaration) => [declaration.name, declaration])),
+			bindings,
+			bound,
+			report
+		});
+		if (this.#errors > 0) return void 0;
+		const byCoordinate = new Map(bindings.map((binding) => [`${binding.type.name}.${binding.sdlField.name}`, binding]));
+		const models = [];
+		for (const type of types) {
+			const model = this.#model(sdl, type, byCoordinate, scalars, conformance);
+			if (model !== void 0) models.push(model);
+		}
+		const meta = resolvers.flatMap((resolver) => resolver.fields.flatMap((field) => field.meta));
+		const printed = printSdl({
+			roots,
+			types: models.map(sdlType)
+		});
+		return {
+			roots,
+			types: models,
+			meta,
+			sdl: printed,
+			schemaHash: schemaHash(printed)
+		};
+	}
+	#report(diagnostic) {
+		if (diagnostic.severity === "error") this.#errors++;
+		this.#ctx.report(diagnostic);
+	}
+	#mismatch(location, message, hints, related) {
+		this.#report({
+			code: Codes.SchemaMismatch,
+			severity: "error",
+			message,
+			...location === void 0 ? {} : { location },
+			...hints.length === 0 ? {} : { hints },
+			...related === void 0 || related.length === 0 ? {} : { related }
+		});
+	}
+	/** `@oneOf` input objects (the runtime does not model them). */
+	#checkUnsupported(sdl, types) {
+		const { isInputObjectType } = graphqlModules().type;
+		for (const type of types) {
+			if (!isInputObjectType(type) || !type.isOneOf) continue;
+			const location = sdl.locate(type.astNode);
+			this.#report({
+				code: Codes.InvalidSdl,
+				severity: "error",
+				message: `@oneOf input objects are not supported yet (${type.name})`,
+				...location === void 0 ? {} : { location },
+				hints: ["Declare one optional field per case and check that exactly one is set in the resolver"]
+			});
+		}
+	}
+	/** The scalar models: `scalar<T>()` declarations by name, the built-in scalars, else ZNIGHT067. */
+	#scalars(sdl, types, declarations) {
+		const { isScalarType } = graphqlModules().type;
+		const byName = new Map([...declarations.values()].map((declaration) => [declaration.name, declaration]));
+		const models = /* @__PURE__ */ new Map();
+		for (const type of types) {
+			if (!isScalarType(type)) continue;
+			const location = sdl.locate(type.astNode);
+			const declaration = byName.get(type.name);
+			const description = type.description ?? void 0;
+			const specifiedByURL = type.specifiedByURL ?? void 0;
+			if (declaration !== void 0) {
+				models.set(type.name, {
+					kind: "scalar",
+					name: type.name,
+					key: `#scalar:${declaration.identity}`,
+					description,
+					location,
+					definition: declaration.identity,
+					specifiedByURL,
+					fromSdl: true
+				});
+				continue;
+			}
+			const builtin = BUILTIN_SCALARS.get(type.name);
+			if (builtin !== void 0) {
+				if (description !== void 0 || specifiedByURL !== void 0 && specifiedByURL !== builtin.specifiedByURL) this.#report({
+					code: Codes.InvalidSdl,
+					severity: "warning",
+					message: `scalar ${type.name} is the built-in scalar of @znight/graphql: its description and @specifiedBy in the SDL are ignored`,
+					...location === void 0 ? {} : { location },
+					hints: [`Remove them, or implement the scalar yourself: export const ${type.name}Scalar = scalar<T>('${type.name}', { ... })`]
+				});
+				models.set(type.name, {
+					kind: "scalar",
+					name: type.name,
+					key: `#builtin:${type.name}`,
+					description: void 0,
+					location,
+					definition: void 0,
+					specifiedByURL: void 0
+				});
+				continue;
+			}
+			this.#report({
+				code: Codes.InvalidSdl,
+				severity: "error",
+				message: `scalar ${type.name} has no implementation: declare it with scalar<T>('${type.name}', ...)`,
+				...location === void 0 ? {} : { location },
+				hints: [`export const ${type.name}Scalar = scalar<${type.name}>('${type.name}', { serialize: value => value as ${type.name}, parseValue: value => value as ${type.name} }), with ${type.name} the TypeScript type of its values (the one graphql-codegen maps it to)`]
+			});
+		}
+		return models;
+	}
+	/**
+	* Binds every resolver method to its SDL field (coverage, RFC 0007 §5.3). `claimed`: the
+	* coordinates a resolver method names, bound or not (a method with an analysis error already
+	* reported), so that their fields are never also reported as missing a resolver.
+	*/
+	#bind(sdl, resolvers, rejected) {
+		const schema = sdl.schema;
+		const bindings = [];
+		const claimed = /* @__PURE__ */ new Set();
+		for (const resolver of rejected) for (const field of resolver.fields) {
+			const owner = field.operation === "field" ? resolver.typeName?.name : rootType(schema, field.operation)?.name;
+			if (owner !== void 0) claimed.add(`${owner}.${field.name}`);
+		}
+		const byCoordinate = /* @__PURE__ */ new Map();
+		for (const resolver of resolvers) {
+			const target = this.#resolverType(sdl, resolver);
+			for (const field of resolver.fields) {
+				const owner = field.operation === "field" ? resolver.typeName?.name : rootType(schema, field.operation)?.name;
+				if (owner !== void 0) claimed.add(`${owner}.${field.name}`);
+				if (!field.complete) continue;
+				const method = this.#method(resolver, field);
+				if (method === void 0) continue;
+				const where = `${resolver.host.displayName}.${field.method}`;
+				let type;
+				if (field.operation === "field") {
+					type = target;
+					if (type === void 0) continue;
+				} else {
+					type = rootType(schema, field.operation);
+					if (type === void 0) {
+						const name = ROOTS[field.operation];
+						this.#mismatch(field.location, `${DECORATORS[field.operation]} ${where}: the schema has no ${name} type`, [`Declare it in the SDL: type ${name} { ${field.name}: ... }`]);
+						continue;
+					}
+				}
+				const sdlField = type.getFields()[field.name];
+				if (sdlField === void 0) {
+					this.#unknownField(schema, type, field, where);
+					continue;
+				}
+				const coordinate = `${type.name}.${field.name}`;
+				const previous = byCoordinate.get(coordinate);
+				if (previous !== void 0) {
+					this.#report({
+						code: Codes.NameConflict,
+						severity: "error",
+						message: `Two resolvers bind ${coordinate}: ${where} and ${previous.resolver.host.displayName}.${previous.field.method}`,
+						location: field.location,
+						related: [{
+							message: "the other resolver",
+							location: previous.field.location
+						}],
+						hints: ["Keep one of them"]
+					});
+					continue;
+				}
+				this.#checkArguments(sdl, field, method, sdlField, coordinate, where);
+				const binding = {
+					resolver,
+					field,
+					method,
+					type,
+					sdlField
+				};
+				byCoordinate.set(coordinate, binding);
+				bindings.push(binding);
+			}
+		}
+		for (const operation of [
+			"query",
+			"mutation",
+			"subscription"
+		]) {
+			const root = rootType(schema, operation);
+			if (root === void 0) continue;
+			for (const field of Object.values(root.getFields())) {
+				if (claimed.has(`${root.name}.${field.name}`)) continue;
+				this.#mismatch(sdl.locate(field.astNode), `Root field ${root.name}.${field.name} has no resolver`, [`Add a method to a @Resolver() class: ${DECORATORS[operation]}() ${field.name}(...) (or ${DECORATORS[operation]}('${field.name}') on another method)`]);
+			}
+		}
+		return {
+			bindings,
+			claimed
+		};
+	}
+	/** The object type of `@Resolver('Type')`, reported when it is not one. */
+	#resolverType(sdl, resolver) {
+		const typeName = resolver.typeName;
+		if (typeName === void 0) return void 0;
+		const { isObjectType, isInterfaceType } = graphqlModules().type;
+		const schema = sdl.schema;
+		const type = schema.getType(typeName.name);
+		const owner = resolver.host.displayName;
+		if (type === void 0) {
+			const objects = Object.values(schema.getTypeMap()).filter((candidate) => isObjectType(candidate) && !candidate.name.startsWith("__")).map((candidate) => candidate.name).sort(compareStrings);
+			const suggestion = closest(typeName.name, objects);
+			this.#mismatch(typeName.location, `@Resolver('${typeName.name}') of ${owner}: the schema has no type ${typeName.name}`, [suggestion === void 0 ? `Declare it in the SDL: type ${typeName.name} { ... }` : `Did you mean '${suggestion}'?`]);
+			return;
+		}
+		const declared = sdl.locate(type.astNode);
+		const related = declared === void 0 ? [] : [{
+			message: `${type.name} is declared here`,
+			location: declared
+		}];
+		if (isInterfaceType(type)) {
+			const implementations = schema.getPossibleTypes(type).map((object) => object.name);
+			this.#mismatch(typeName.location, `@Resolver('${type.name}') of ${owner}: ${type.name} is an interface, field resolvers bind the fields of object types`, [implementations.length === 0 ? `Declare an object type implementing ${type.name} and bind the field on it` : `Bind the field on each implementation: @Resolver('${implementations[0]}')${implementations.length > 1 ? ` (and ${implementations.slice(1).join(", ")})` : ""}`], related);
+			return;
+		}
+		if (!isObjectType(type)) {
+			this.#mismatch(typeName.location, `@Resolver('${type.name}') of ${owner}: ${type.name} is not an object type, it has no field to resolve`, ["Name an object type of the SDL (type ... { ... })"], related);
+			return;
+		}
+		const operation = [
+			"query",
+			"mutation",
+			"subscription"
+		].find((candidate) => rootType(sdl.schema, candidate) === type);
+		if (operation !== void 0 && resolver.fields.some((field) => field.operation === "field")) {
+			this.#mismatch(typeName.location, `@Resolver('${type.name}') of ${owner}: ${type.name} is the ${operation} root type, its fields are bound with ${DECORATORS[operation]}()`, [`Replace @ResolveField() with ${DECORATORS[operation]}() and use @Resolver()`], related);
+			return;
+		}
+		return type;
+	}
+	#unknownField(schema, type, field, where) {
+		const hints = [];
+		if (field.operation !== "field") {
+			const elsewhere = [
+				"query",
+				"mutation",
+				"subscription"
+			].find((operation) => operation !== field.operation && rootType(schema, operation)?.getFields()[field.name] !== void 0);
+			if (elsewhere !== void 0) hints.push(`${ROOTS[elsewhere]}.${field.name} exists: use ${DECORATORS[elsewhere]}()`);
+		}
+		if (hints.length === 0) {
+			const suggestion = closest(field.name, Object.keys(type.getFields()).sort(compareStrings));
+			if (suggestion !== void 0) hints.push(`Did you mean '${suggestion}'? ${DECORATORS[field.operation]}('${suggestion}')`);
+		}
+		hints.push(`Declare it in the SDL (${field.operation === "field" ? `extend type ${type.name}` : `extend type ${type.name}`} { ${field.name}: ... }), or remove the method`);
+		this.#mismatch(field.location, `${DECORATORS[field.operation]} ${where}: ${type.name} has no field '${field.name}'`, hints);
+	}
+	/** `@Args('name')`: the argument must exist. */
+	#checkArguments(sdl, field, method, sdlField, coordinate, where) {
+		const names = sdlField.args.map((arg) => arg.name);
+		field.params.forEach((param, index) => {
+			if (param?.kind !== "args" || param.name === void 0 || names.includes(param.name)) return;
+			const suggestion = closest(param.name, [...names].sort(compareStrings));
+			const declared = sdl.locate(sdlField.astNode);
+			let hint = `Its arguments: ${names.join(", ")}`;
+			if (suggestion !== void 0) hint = `Did you mean '${suggestion}'?`;
+			else if (names.length === 0) hint = `${coordinate} takes no argument: declare it in the SDL, or remove the parameter`;
+			this.#mismatch(param.location, `@Args('${param.name}') on parameter '${method.params[index]?.name ?? param.name}' of ${where}: ${coordinate} has no argument '${param.name}'`, [hint], declared === void 0 ? [] : [{
+				message: `${coordinate} is declared here`,
+				location: declared
+			}]);
+		});
+	}
+	#method(resolver, field) {
+		const key = `${resolver.host.identity}#${field.method}`;
+		if (!this.#methods.has(key)) {
+			const cls = this.#ctx.classInfo(resolver.host.identity);
+			this.#methods.set(key, cls?.methods.find((method) => method.name === field.method && method.kind === "method"));
+		}
+		return this.#methods.get(key);
+	}
+	#model(sdl, type, bindings, scalars, conformance) {
+		const { isObjectType, isInterfaceType, isInputObjectType, isEnumType, isUnionType } = graphqlModules().type;
+		const base = {
+			name: type.name,
+			key: `#sdl:${type.name}`,
+			description: type.description ?? void 0,
+			location: sdl.locate(type.astNode)
+		};
+		const nulls = conformance.nullAsUndefined;
+		if (isObjectType(type) || isInterfaceType(type)) {
+			const fields = Object.values(type.getFields()).map((field) => this.#field(sdl, type, field, bindings.get(`${type.name}.${field.name}`), nulls));
+			const interfaces = type.getInterfaces().map((implemented) => implemented.name);
+			if (isInterfaceType(type)) return {
+				...base,
+				kind: "interface",
+				fields,
+				interfaces,
+				discriminator: conformance.discriminators.get(type.name)
+			};
+			return {
+				...base,
+				kind: "object",
+				fields,
+				trail: type.name,
+				root: void 0,
+				classIdentity: void 0,
+				properties: [],
+				interfaces
+			};
+		}
+		if (isInputObjectType(type)) return {
+			...base,
+			kind: "input",
+			fields: Object.values(type.getFields()).map((field) => inputValue(sdl, field, `${type.name}.${field.name}`, nulls))
+		};
+		if (isEnumType(type)) return {
+			...base,
+			kind: "enum",
+			values: type.getValues().map((value) => ({
+				name: value.name,
+				value: value.name,
+				description: value.description ?? void 0,
+				deprecationReason: value.deprecationReason ?? void 0
+			}))
+		};
+		if (isUnionType(type)) return {
+			...base,
+			kind: "union",
+			members: type.getTypes().map((member) => member.name).sort(compareStrings),
+			discriminator: conformance.discriminators.get(type.name)
+		};
+		return scalars.get(type.name);
+	}
+	#field(sdl, type, field, binding, nulls) {
+		const coordinate = `${type.name}.${field.name}`;
+		return {
+			name: field.name,
+			type: String(field.type),
+			description: field.description ?? void 0,
+			deprecationReason: field.deprecationReason ?? void 0,
+			args: field.args.map((arg) => inputValue(sdl, arg, `${coordinate}(${arg.name}:)`, nulls)),
+			binding: binding === void 0 ? void 0 : {
+				resolver: binding.resolver,
+				field: binding.field
+			},
+			location: sdl.locate(field.astNode)
+		};
+	}
+};
+const ROOTS = {
+	query: "Query",
+	mutation: "Mutation",
+	subscription: "Subscription"
+};
+function rootType(schema, operation) {
+	switch (operation) {
+		case "query": return schema.getQueryType() ?? void 0;
+		case "mutation": return schema.getMutationType() ?? void 0;
+		default: return schema.getSubscriptionType() ?? void 0;
+	}
+}
+/** An argument or an input field: its default as an external value (enum values by name). */
+function inputValue(sdl, value, coordinate, nulls) {
+	const type = String(value.type);
+	const ref = parseTypeRef(type);
+	const defaultInput = value.default;
+	let defaultValue;
+	if (defaultInput !== void 0) defaultValue = defaultInput.literal === void 0 ? defaultInput.value : graphqlModules().utilities.valueFromASTUntyped(defaultInput.literal);
+	return {
+		name: value.name,
+		type,
+		ref,
+		description: value.description ?? void 0,
+		deprecationReason: value.deprecationReason ?? void 0,
+		defaultValue,
+		nullAsUndefined: !ref.nonNull && nulls.has(coordinate),
+		location: sdl.locate(value.astNode)
+	};
+}
 // src/compiler/index.ts
 const FIELD = {
 	targets: ["method"],
@@ -2781,7 +4547,7 @@ const NO_ARGUMENT = {
 const decorators = Object.freeze({
 	[GraphQLIds.Resolver]: {
 		targets: ["class"],
-		params: ["static"]
+		params: ["static", "static"]
 	},
 	[GraphQLIds.Query]: FIELD,
 	[GraphQLIds.Mutation]: FIELD,
@@ -2813,9 +4579,10 @@ function createExtension(options) {
 		name: EXTENSION_NAME,
 		decorators,
 		options,
-		analyzeClass: analyzeGraphQLClass,
+		analyzeClass: (cls, ctx) => analyzeGraphQLClass(cls, ctx, options),
 		validate(ctx) {
-			models.set(ctx.graph.extensions, buildModel(ctx, options));
+			const schema = options.schema;
+			models.set(ctx.graph.extensions, schema === false ? buildModel(ctx, options) : buildSchemaFirstModel(ctx, schema, options.sdl));
 		},
 		generate(ctx) {
 			return generateGraphQL(ctx, modelOf(ctx.graph), options);