@znight/graphql 0.0.0 → 0.2.1

package/dist/compiler.mjs

@@ -0,0 +1,4599 @@
+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
+/** Name of the extension, also the key of `metadata.extensions.graphql`. */
+const EXTENSION_NAME = "graphql";
+/** Module the generated code imports its runtime helpers and types from. */
+const RUNTIME_MODULE = "@znight/graphql";
+/** Canonical identities of the exports of `@znight/graphql` the compiler reads. */
+const GraphQLIds = Object.freeze({
+	Resolver: "@znight/graphql#Resolver",
+	Query: "@znight/graphql#Query",
+	Mutation: "@znight/graphql#Mutation",
+	Subscription: "@znight/graphql#Subscription",
+	ResolveField: "@znight/graphql#ResolveField",
+	Args: "@znight/graphql#Args",
+	Parent: "@znight/graphql#Parent",
+	Ctx: "@znight/graphql#Ctx",
+	Info: "@znight/graphql#Info",
+	Loader: "@znight/graphql#Loader",
+	UseGuard: "@znight/graphql#UseGuard",
+	scalar: "@znight/graphql#scalar",
+	ID: "@znight/graphql#ID",
+	Int: "@znight/graphql#Int",
+	Float: "@znight/graphql#Float",
+	JSONValue: "@znight/graphql#JSONValue",
+	BatchLoad: "@znight/graphql#BatchLoad",
+	GraphQLContext: "@znight/graphql#GraphQLContext",
+	ResolverContext: "@znight/graphql#ResolverContext",
+	PubSub: "@znight/graphql#PubSub",
+	GraphQLPlugin: "@znight/graphql#GraphQLPlugin"
+});
+/** Field decorators → the kind of field they declare (`GraphQLResolverBinding.operation`). */
+const FIELD_DECORATORS = /* @__PURE__ */ new Map([
+	[GraphQLIds.Query, "query"],
+	[GraphQLIds.Mutation, "mutation"],
+	[GraphQLIds.Subscription, "subscription"],
+	[GraphQLIds.ResolveField, "field"]
+]);
+/** Parameter decorators → what the generated `invoke` passes (§7.3). */
+const PARAMETER_DECORATORS = /* @__PURE__ */ new Map([
+	[GraphQLIds.Args, "args"],
+	[GraphQLIds.Parent, "parent"],
+	[GraphQLIds.Ctx, "ctx"],
+	[GraphQLIds.Info, "info"],
+	[GraphQLIds.Loader, "loader"]
+]);
+/** Scalar aliases of `@znight/graphql` → their GraphQL scalar (§6.2). */
+const SCALAR_ALIASES = /* @__PURE__ */ new Map([
+	[GraphQLIds.ID, "ID"],
+	[GraphQLIds.Int, "Int"],
+	[GraphQLIds.Float, "Float"],
+	[GraphQLIds.JSONValue, "JSON"]
+]);
+/**
+* Decorators of `@znight/http` that look like GraphQL ones, on a resolver: ZNIGHT005 with the
+* `@znight/graphql` decorator to import instead (§6.5).
+*/
+const HTTP_LOOK_ALIKES = /* @__PURE__ */ new Map([
+	["@znight/http#Ctx", GraphQLIds.Ctx],
+	["@znight/http#Query", GraphQLIds.Args],
+	["@znight/http#Param", GraphQLIds.Args],
+	["@znight/http#Body", GraphQLIds.Args],
+	["@znight/http#UseGuard", GraphQLIds.UseGuard]
+]);
+/** `@Controller` of `@znight/http`: a class cannot be both a controller and a resolver (ZNIGHT005). */
+const HTTP_CONTROLLER = "@znight/http#Controller";
+// src/compiler/constants.ts
+/** Diagnostic codes the extension reports (RFC 0005 §6.6 and the reused framework codes). */
+const Codes = Object.freeze({
+	InvalidDecorator: "ZNIGHT005",
+	MissingRouteDecision: "ZNIGHT023",
+	InvalidType: "ZNIGHT060",
+	NameConflict: "ZNIGHT061",
+	InvalidResolver: "ZNIGHT062",
+	InvalidInput: "ZNIGHT063",
+	UnresolvableAbstractType: "ZNIGHT064",
+	InvalidLoader: "ZNIGHT065",
+	InvalidSdl: "ZNIGHT067",
+	SchemaMismatch: "ZNIGHT068"
+});
+/** Root reason given to `AnalyzeContext.addRoot()`. */
+const ROOT_REASON = "GraphQL resolver";
+/** Async iterables: the return type of `@Subscription` methods (§6.2). */
+const ASYNC_ITERABLES = /* @__PURE__ */ new Set([
+	"globalThis#AsyncIterable",
+	"globalThis#AsyncIterableIterator",
+	"globalThis#AsyncGenerator"
+]);
+/** Iterables mapped to lists in output position (§6.2). */
+const OUTPUT_ITERABLES = /* @__PURE__ */ new Set([
+	"globalThis#Set",
+	"globalThis#ReadonlySet",
+	"globalThis#Iterable"
+]);
+/**
+* Identities the shapes keep as references (`ShapeOptions.keep`), before the identities of the
+* `scalar<T>()` declarations of the application.
+*/
+const BASE_KEEP = Object.freeze([
+	...ASYNC_ITERABLES,
+	...OUTPUT_ITERABLES,
+	GraphQLIds.ID,
+	GraphQLIds.Int,
+	GraphQLIds.Float,
+	GraphQLIds.JSONValue,
+	GraphQLIds.Loader
+]);
+/** Deterministic string comparison (code-unit order, never `localeCompare`). */
+function compareStrings(a, b) {
+	if (a === b) return 0;
+	return a < b ? -1 : 1;
+}
+// src/compiler/analyze.ts
+const SCOPES = [
+	"singleton",
+	"request",
+	"transient"
+];
+/** Shape options reading `Loader<L>` parameters: the alias is kept, `L` stays a named shape. */
+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). 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"]);
+	const controller = cls.decorators.find((decorator) => decorator.identity === HTTP_CONTROLLER);
+	if (controller !== void 0) {
+		error(ctx, Codes.InvalidDecorator, resolver.location, `${cls.displayName} cannot be both a @Resolver and a @Controller`, ["A class is the provider of one extension: move the GraphQL fields to their own @Resolver() class (both may call the same service)"], [{
+			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, typeName } = resolverArguments(ctx, resolver, options.schema !== false);
+	ctx.registerProvider(cls, { scope });
+	ctx.addRoot(cls, {
+		reason: ROOT_REASON,
+		location: resolver.location
+	});
+	const classGuards = guardsOf(ctx, cls, cls.decorators);
+	const classMeta = readRouteMeta(ctx, cls);
+	const fields = [];
+	for (const method of cls.methods) {
+		const decorators = method.decorators.filter(isFieldDecorator);
+		if (decorators.length === 0) {
+			reportStrayMethodDecorators(cls, method, ctx);
+			continue;
+		}
+		fields.push(...analyzeMethod(ctx, cls, method, decorators, classMeta, options.schema !== false));
+	}
+	const data = {
+		kind: "resolver",
+		host: cls,
+		scope,
+		location: resolver.location,
+		guards: classGuards,
+		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) {
+	return decorator.identity !== void 0 && FIELD_DECORATORS.has(decorator.identity);
+}
+function isParameterDecorator(decorator) {
+	return decorator.identity !== void 0 && PARAMETER_DECORATORS.has(decorator.identity);
+}
+/** `@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)) {
+		error(ctx, Codes.InvalidDecorator, arg.location, `@Resolver expects { scope? }, got ${describe$1(value)}`, ["@Resolver() or @Resolver({ scope: 'request' })"]);
+		return "singleton";
+	}
+	let scope = "singleton";
+	for (const [key, option] of Object.entries(value)) if (key !== "scope") error(ctx, Codes.InvalidDecorator, arg.location, `@Resolver: unknown option "${key}"`, ["Options: { scope? }"]);
+	else if (SCOPES.includes(option)) scope = option;
+	else if (option !== void 0) error(ctx, Codes.InvalidDecorator, arg.location, `@Resolver: invalid scope ${describe$1(option)}`, [`Use one of ${SCOPES.map((candidate) => `'${candidate}'`).join(", ")}`]);
+	return scope;
+}
+/** `@UseGuard(A, B)` decorators of a target: guard classes bound with lazy edges (C3). */
+function guardsOf(ctx, cls, decorators) {
+	const guards = [];
+	for (const decorator of decorators) {
+		if (decorator.identity !== GraphQLIds.UseGuard) continue;
+		if (decorator.args.length === 0) error(ctx, Codes.InvalidDecorator, decorator.location, "@UseGuard needs at least one guard class", ["@UseGuard(AccessGuard)"]);
+		for (const arg of decorator.args) {
+			const ref = ctx.resolveClassRef(arg, {
+				from: cls,
+				role: "guard",
+				lazy: true
+			});
+			if (ref !== void 0) guards.push(ref);
+		}
+	}
+	return guards;
+}
+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);
+	complete = checkForeignHandler(ctx, method, primary, where) && complete;
+	const params = [];
+	for (const param of method.params) {
+		const data = analyzeParameter(ctx, cls, param, where);
+		params.push(data);
+		if (data === void 0) complete = false;
+	}
+	const parents = params.filter((param) => param?.kind === "parent");
+	for (const extra of parents.slice(1)) {
+		error(ctx, Codes.InvalidResolver, extra.location, `${where} has several @Parent() parameters`, ["Declare the parent object once"]);
+		complete = false;
+	}
+	const guards = guardsOf(ctx, cls, method.decorators);
+	const meta = effectiveRouteMeta(classMeta, readRouteMeta(ctx, cls, method));
+	const fields = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const decorator of decorators) {
+		const operation = FIELD_DECORATORS.get(decorator.identity);
+		const explicit = fieldName(ctx, decorator, method, where);
+		const name = explicit ?? method.name;
+		const key = `${operation}\0${name}`;
+		if (seen.has(key)) {
+			error(ctx, Codes.InvalidDecorator, decorator.location, `@${decorator.name}('${name}') is applied twice to ${where}`, ["Apply each field decorator once"]);
+			continue;
+		}
+		seen.add(key);
+		let fieldComplete = complete && explicit !== void 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) {
+			error(ctx, Codes.InvalidResolver, parents[0].location, `@Parent() is only available in @ResolveField methods, not in the @${decorator.name} ${where}`, ["Root fields have no parent object: remove the parameter"]);
+			fieldComplete = false;
+		}
+		fields.push({
+			method: method.name,
+			operation,
+			name,
+			location: decorator.location,
+			methodLocation: method.location,
+			guards,
+			meta,
+			params,
+			complete: fieldComplete
+		});
+	}
+	return fields;
+}
+/** The field name: the static decorator argument, or the method name. */
+function fieldName(ctx, decorator, method, where) {
+	const arg = decorator.args[0];
+	if (arg === void 0 || arg.evaluated && arg.value === void 0) {
+		if (isGraphQLName(method.name)) return method.name;
+		error(ctx, Codes.NameConflict, decorator.location, `'${method.name}' is not a valid GraphQL field name (${where}): name the field in the decorator`, ["GraphQL names match /^[_A-Za-z][_0-9A-Za-z]*$/ and do not start with __", `@${decorator.name}('validName')`]);
+		return;
+	}
+	if (!arg.evaluated) return void 0;
+	const value = arg.value;
+	if (typeof value !== "string") {
+		error(ctx, Codes.InvalidDecorator, arg.location, `@${decorator.name} on ${where} expects a field name, got ${describe$1(value)}`, [`@${decorator.name}('${method.name}') or @${decorator.name}()`]);
+		return;
+	}
+	if (!isGraphQLName(value)) {
+		error(ctx, Codes.NameConflict, arg.location, `'${value}' is not a valid GraphQL field name (${where})`, ["GraphQL names match /^[_A-Za-z][_0-9A-Za-z]*$/ and do not start with __"]);
+		return;
+	}
+	return value;
+}
+/** Resolver methods are called by the generated code: `resolver.method(...)`. */
+function checkMethodShape(ctx, method, decorator, where) {
+	const name = `@${decorator.name}`;
+	let problem;
+	if (method.kind !== "method") problem = {
+		message: `${name} cannot be applied to the accessor ${where}`,
+		hint: "Use a regular method"
+	};
+	else if (method.static) problem = {
+		message: `${name} cannot be applied to the static method ${where}`,
+		hint: "Fields are resolved on the resolver instance: remove `static`"
+	};
+	else if (method.privateName) problem = {
+		message: `${name} cannot be applied to the #private method ${where}`,
+		hint: "Use a public method: the generated code calls it"
+	};
+	else if (method.visibility !== "public") problem = {
+		message: `${where} must be public: ${name} methods are called by the generated code`,
+		hint: `Remove the '${method.visibility}' modifier`
+	};
+	else if (method.computed) problem = {
+		message: `${name} cannot be applied to ${where}: computed method names are not supported`,
+		hint: "Use a plain method name"
+	};
+	else if (method.typeParameters.length > 0) problem = {
+		message: `${name} cannot be applied to the generic method ${where}<${method.typeParameters.join(", ")}>`,
+		hint: "The schema is derived from the signature: remove the type parameters"
+	};
+	if (problem === void 0) return true;
+	error(ctx, Codes.InvalidDecorator, decorator.location, problem.message, [problem.hint]);
+	return false;
+}
+/** A resolver method cannot also be handled by another extension (`@Get`, `@OnMessage`, `@Cron`). */
+function checkForeignHandler(ctx, method, decorator, where) {
+	for (const other of method.decorators) {
+		const owner = other.owner;
+		if (owner === void 0 || owner === "graphql" || owner === "core" || owner === "manifest") continue;
+		error(ctx, Codes.InvalidDecorator, other.location, `${where} cannot be both a GraphQL field (@${decorator.name}) and a @${other.name} handler`, ["A class is the provider of one extension: let both handlers call a shared service"]);
+		return false;
+	}
+	return true;
+}
+/**
+* Graphql parameter decorators of a parameter, de-duplicated by position (the compiler reports the
+* decorators of a parameter with a default value twice).
+*/
+function parameterDecorators(param) {
+	const seen = /* @__PURE__ */ new Set();
+	return param.decorators.filter((decorator) => {
+		if (!isParameterDecorator(decorator) || seen.has(decorator.location.start)) return false;
+		seen.add(decorator.location.start);
+		return true;
+	});
+}
+function analyzeParameter(ctx, cls, param, where) {
+	const decorators = parameterDecorators(param);
+	const decorator = decorators[0];
+	if (decorator === void 0) {
+		const lookAlike = param.decorators.find((found) => found.identity !== void 0 && HTTP_LOOK_ALIKES.has(found.identity));
+		if (lookAlike !== void 0) {
+			const replacement = HTTP_LOOK_ALIKES.get(lookAlike.identity).split("#")[1];
+			error(ctx, Codes.InvalidDecorator, lookAlike.location, `@${lookAlike.name} on parameter '${param.name}' of ${where} is imported from '@znight/http': resolver parameters use @${replacement}() from '${RUNTIME_MODULE}'`, [`Import it from '${RUNTIME_MODULE}': import { ${replacement} } from '${RUNTIME_MODULE}'`]);
+			return;
+		}
+		error(ctx, Codes.InvalidDecorator, param.location, `Parameter '${param.name}' of ${where} has no @Args(), @Parent(), @Ctx(), @Info() or @Loader() decorator`, ["Every resolver parameter is filled by GraphQL: @Args(name?, schema?) for arguments, @Parent() for the parent object, @Ctx() for the GraphQLContext, @Info() for the GraphQLResolveInfo, @Loader() for a DataLoader"]);
+		return;
+	}
+	if (decorators.length > 1) {
+		error(ctx, Codes.InvalidDecorator, decorators[1].location, `Parameter '${param.name}' of ${where} has several GraphQL decorators (${decorators.map((found) => `@${found.name}`).join(", ")})`, ["Keep a single one"]);
+		return;
+	}
+	if (param.rest) {
+		error(ctx, Codes.InvalidDecorator, decorator.location, `@${decorator.name} cannot be applied to the rest parameter '...${param.name}' of ${where}`);
+		return;
+	}
+	switch (PARAMETER_DECORATORS.get(decorator.identity)) {
+		case "args": return argsParameter(ctx, decorator, param, where);
+		case "parent": return {
+			kind: "parent",
+			location: decorator.location
+		};
+		case "ctx": return { kind: "ctx" };
+		case "info": return { kind: "info" };
+		default: return loaderParameter(ctx, cls, param, where);
+	}
+}
+/** `@Args()`, `@Args('name')`, `@Args('name', Schema)`, `@Args(Schema)`. */
+function argsParameter(ctx, decorator, param, where) {
+	const [first, second, ...extra] = decorator.args;
+	if (extra.length > 0) {
+		error(ctx, Codes.InvalidDecorator, decorator.location, `@Args takes at most two arguments (${where})`, ["@Args(), @Args('name'), @Args('name', Schema) or @Args(Schema)"]);
+		return;
+	}
+	let name;
+	let schemaArg = second;
+	if (first !== void 0) {
+		if (!first.evaluated && first.ref === void 0) return void 0;
+		if (typeof first.value === "string") {
+			if (!isGraphQLName(first.value)) {
+				error(ctx, Codes.NameConflict, first.location, `'${first.value}' is not a valid GraphQL argument name (parameter '${param.name}' of ${where})`, ["GraphQL names match /^[_A-Za-z][_0-9A-Za-z]*$/ and do not start with __"]);
+				return;
+			}
+			name = first.value;
+		} else if (first.ref !== void 0) {
+			if (second !== void 0) {
+				error(ctx, Codes.InvalidDecorator, second.location, `@Args(Schema) takes no second argument (${where})`, ["@Args('name', Schema) validates one argument, @Args(Schema) every argument"]);
+				return;
+			}
+			schemaArg = first;
+		} else if (first.value !== void 0) {
+			error(ctx, Codes.InvalidDecorator, first.location, `@Args on parameter '${param.name}' of ${where} expects an argument name or a schema, got ${describe$1(first.value)}`, ["@Args('id'), @Args() or @Args('input', Schema)"]);
+			return;
+		}
+	}
+	if (schemaArg !== void 0 && !(schemaArg.evaluated && schemaArg.value === void 0)) {
+		if (schemaArg.ref === void 0) {
+			if (schemaArg.evaluated) error(ctx, Codes.InvalidDecorator, schemaArg.location, `The schema of @Args on parameter '${param.name}' of ${where} must be a reference to an exported schema`, ["Declare it with `export const Schema = z.object(...)` and pass Schema: the generated module imports it"]);
+			return;
+		}
+		return {
+			kind: "args",
+			name,
+			schema: schemaArg.ref,
+			location: decorator.location
+		};
+	}
+	return {
+		kind: "args",
+		name,
+		schema: void 0,
+		location: decorator.location
+	};
+}
+/** `@Loader() authors: Loader<AuthorsById>`: binds `AuthorsById` with a lazy edge. */
+function loaderParameter(ctx, cls, param, where) {
+	const root = ctx.types.shape({ parameter: param }, LOADER_SHAPE);
+	const shape = root.root;
+	const argument = shape.kind === "reference" && shape.identity === GraphQLIds.Loader ? shape.typeArgs[0] : void 0;
+	const identity = argument?.kind === "named" ? root.named.get(argument.key)?.identity : void 0;
+	if (identity === void 0) {
+		error(ctx, Codes.InvalidLoader, param.typeLocation, `@Loader() parameter '${param.name}' of ${where} must be typed Loader<L>, with L a loader class`, [`${param.name}: Loader<AuthorsById>, where AuthorsById is a provider implementing BatchLoad<K, V> (import type { Loader } from '${RUNTIME_MODULE}')`]);
+		return;
+	}
+	return {
+		kind: "loader",
+		binding: ctx.bindInjection({
+			type: identity,
+			location: param.typeLocation,
+			label: `loader '${param.name}' of ${where}()`
+		}, {
+			from: cls,
+			lazy: true
+		}),
+		identity,
+		location: param.typeLocation
+	};
+}
+/**
+* Graphql decorators on a class without `@Resolver`: field methods are not inherited (a base
+* class), and parameter or guard decorators have no effect.
+*/
+function reportOutsideResolver(cls, ctx) {
+	for (const decorator of cls.decorators) if (decorator.identity === GraphQLIds.UseGuard) error(ctx, Codes.InvalidDecorator, decorator.location, `@UseGuard has no effect: ${cls.displayName} is not a @Resolver`, [`Add @Resolver() to ${cls.displayName}`]);
+	for (const method of cls.methods) {
+		const fields = method.decorators.filter(isFieldDecorator);
+		for (const field of fields) error(ctx, Codes.InvalidResolver, field.location, `@${field.name} ${cls.displayName}.${method.name} is declared on a class that is not a @Resolver`, [cls.abstract ? `Resolver methods are not inherited: declare the field on the concrete @Resolver() class (it may call ${method.name} of the base class)` : `Add @Resolver() to ${cls.displayName} (resolver methods are not inherited from base classes)`]);
+		if (fields.length === 0) reportStrayMethodDecorators(cls, method, ctx);
+	}
+}
+/** `@UseGuard` or parameter decorators on a method that is not a field. */
+function reportStrayMethodDecorators(cls, method, ctx) {
+	const where = `${cls.displayName}.${method.name}`;
+	for (const decorator of method.decorators) if (decorator.identity === GraphQLIds.UseGuard) error(ctx, Codes.InvalidDecorator, decorator.location, `@UseGuard has no effect: ${where} is not a GraphQL field`, ["Add @Query(), @Mutation(), @Subscription() or @ResolveField() to the method"]);
+	for (const param of method.params) for (const decorator of parameterDecorators(param)) error(ctx, Codes.InvalidDecorator, decorator.location, `@${decorator.name} has no effect: ${where} is not a GraphQL field`, ["Add @Query(), @Mutation(), @Subscription() or @ResolveField() to the method"]);
+}
+function error(ctx, code, location, message, hints = [], related = []) {
+	ctx.report({
+		code,
+		severity: "error",
+		message,
+		location,
+		...hints.length === 0 ? {} : { hints },
+		...related.length === 0 ? {} : { related }
+	});
+}
+/** An evaluated object literal (not an array, not a reference). */
+function isRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+/** Short description of a value for messages. */
+function describe$1(value) {
+	if (value === void 0) return "undefined";
+	if (value === null) return "null";
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "bigint") return `${value}n`;
+	if (typeof value !== "object") return String(value);
+	if (Array.isArray(value)) return "an array";
+	return isRecord(value) ? "an object" : "a reference";
+}
+/** First 16 hexadecimal characters of the SHA-256 of `sdl` (UTF-8). */
+function schemaHash(sdl) {
+	return createHash("sha256").update(sdl, "utf8").digest("hex").slice(0, 16);
+}
+// src/sdl.ts
+/**
+* Deterministic SDL printer (RFC 0005 §6.7, §7.3).
+*
+* Prints a schema model (the data of `metadata.extensions.graphql`, without its functions) exactly
+* like graphql-js 17 `printSchema()` prints the `GraphQLSchema` the runtime builds from it: same
+* order, same block strings, same default value literals, byte for byte. The compiler hashes this
+* output (`schemaHash`) and writes it as the optional SDL artifact; the runtime can print without
+* graphql-js.
+*
+* Import-free (types and constants of import-free modules only): shared by the compiler extension
+* and the runtime. Equivalence holds when the runtime builds the schema the way this module
+* assumes:
+*
+* - every type of the model passed to `new GraphQLSchema({ types })` in model order (metadata types
+*   are sorted by name), so the type map, hence `printSchema`, follows that order;
+* - default values passed as `default: { value }` (external values: enum values by name), printed
+*   by graphql-js through `valueToLiteral`;
+* - built-in scalars (`names.ts`) without description, with their `specifiedByURL`, and no scalar
+*   with a custom `valueToLiteral` used in a default value.
+*/
+/**
+* Prints the SDL of a schema, without a trailing newline (like `printSchema`). Throws an `Error` on
+* a malformed type reference or a default value that does not match its type (the compiler reports
+* these as diagnostics before printing).
+*/
+function printSdl(schema) {
+	const types = /* @__PURE__ */ new Map();
+	for (const type of schema.types) types.set(type.name, type);
+	const printer = new SdlPrinter(types);
+	const parts = [];
+	const definition = printSchemaDefinition(schema.roots, types);
+	if (definition !== void 0) parts.push(definition);
+	for (const type of schema.types) if (!SPECIFIED_SCALARS.has(type.name)) parts.push(printer.type(type));
+	return parts.join("\n\n");
+}
+/** `schema { ... }`, only when the root types do not have their default names (as graphql-js). */
+function printSchemaDefinition(roots, types) {
+	const isDefault = (root, name) => root === void 0 ? !types.has(name) : root === name;
+	if (isDefault(roots.query, ROOT_TYPE_NAMES.query) && isDefault(roots.mutation, ROOT_TYPE_NAMES.mutation) && isDefault(roots.subscription, ROOT_TYPE_NAMES.subscription)) return;
+	return `schema {
+  query: ${roots.query}\n` + (roots.mutation === void 0 ? "" : `  mutation: ${roots.mutation}\n`) + (roots.subscription === void 0 ? "" : `  subscription: ${roots.subscription}\n`) + "}";
+}
+const GRAPHQL_MAX_INT = 2147483647;
+const GRAPHQL_MIN_INT = -2147483648;
+const INTEGER_STRING = /^-?(?:0|[1-9][0-9]*)$/;
+/** graphql-js `print()` breaks lists and objects longer than this. */
+const MAX_LINE_LENGTH = 80;
+var SdlPrinter = class {
+	#types;
+	constructor(types) {
+		this.#types = types;
+	}
+	type(type) {
+		const head = printDescription(type.description, "", true);
+		switch (type.kind) {
+			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(" | ")}`}`;
+			case "scalar": {
+				const url = type.specifiedByURL ?? (type.builtin === true ? BUILTIN_SCALARS.get(type.name)?.specifiedByURL : void 0);
+				return `${head}scalar ${type.name}${url === void 0 ? "" : ` @specifiedBy(url: ${printString(url)})`}`;
+			}
+		}
+	}
+	#field(typeName, field, index) {
+		const coordinate = `${typeName}.${field.name}`;
+		return `${printDescription(field.description, "  ", index === 0)}  ${field.name}` + this.#args(coordinate, field.args ?? []) + `: ${checkedTypeRef(field.type, coordinate)}${printDeprecated(field.deprecationReason)}`;
+	}
+	#args(coordinate, args) {
+		if (args.length === 0) return "";
+		if (args.every((arg) => arg.description === void 0)) return `(${args.map((arg) => this.#inputValue(arg, `${coordinate}(${arg.name}:)`)).join(", ")})`;
+		return `(\n${args.map((arg, i) => `${printDescription(arg.description, "    ", i === 0)}    ${this.#inputValue(arg, `${coordinate}(${arg.name}:)`)}`).join("\n")}\n  )`;
+	}
+	#inputValue(value, coordinate) {
+		const ref = parseTypeRef(value.type);
+		if (ref === void 0) throw new Error(`Invalid type reference '${value.type}' (${coordinate})`);
+		let declaration = `${value.name}: ${value.type}`;
+		if (value.defaultValue !== void 0) {
+			const literal = this.#literal(value.defaultValue, ref);
+			if (literal === void 0) throw new Error(`Invalid default value for ${coordinate}: ${describe(value.defaultValue)}`);
+			declaration += ` = ${printLiteral(literal)}`;
+		}
+		return declaration + printDeprecated(value.deprecationReason);
+	}
+	/** graphql-js `valueToLiteral(value, type)`: `undefined` when the value does not fit the type. */
+	#literal(value, ref) {
+		if (ref.nonNull && value == null) return void 0;
+		if (value == null) return { kind: "NullValue" };
+		if (ref.kind === "list") {
+			const item = ref.of;
+			if (!isIterableObject(value)) return this.#literal(value, item);
+			const values = [];
+			for (const entry of value) {
+				const literal = this.#literal(entry, item);
+				if (literal === void 0) return void 0;
+				values.push(literal);
+			}
+			return {
+				kind: "ListValue",
+				values
+			};
+		}
+		const type = this.#types.get(ref.name);
+		if (type?.kind === "input") return this.#inputLiteral(value, type);
+		if (type?.kind === "enum") return typeof value === "string" && type.values.some((entry) => entry.name === value) ? {
+			kind: "EnumValue",
+			value
+		} : void 0;
+		return scalarLiteral(value, ref.name);
+	}
+	#inputLiteral(value, type) {
+		if (typeof value !== "object" || value === null) return void 0;
+		const record = value;
+		for (const key of Object.keys(record)) if (record[key] !== void 0 && !type.fields.some((field) => field.name === key)) return void 0;
+		const fields = [];
+		for (const field of type.fields) {
+			const fieldValue = Object.hasOwn(record, field.name) ? record[field.name] : void 0;
+			const ref = parseTypeRef(field.type);
+			if (ref === void 0) return void 0;
+			if (fieldValue === void 0) {
+				if (ref.nonNull && field.defaultValue === void 0) return void 0;
+				continue;
+			}
+			const literal = this.#literal(fieldValue, ref);
+			if (literal === void 0) return void 0;
+			fields.push([field.name, literal]);
+		}
+		return {
+			kind: "ObjectValue",
+			fields
+		};
+	}
+};
+/** 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) {
+		case "Int": return (typeof value === "number" && Number.isInteger(value) || typeof value === "bigint") && value <= GRAPHQL_MAX_INT && value >= GRAPHQL_MIN_INT ? {
+			kind: "IntValue",
+			value: String(value)
+		} : void 0;
+		case "Float": try {
+			const literal = defaultScalarLiteral(value);
+			return literal.kind === "FloatValue" || literal.kind === "IntValue" ? literal : void 0;
+		} catch {
+			return;
+		}
+		case "String": return typeof value === "string" ? {
+			kind: "StringValue",
+			value
+		} : void 0;
+		case "Boolean": return typeof value === "boolean" ? {
+			kind: "BooleanValue",
+			value
+		} : void 0;
+		case "ID":
+			if (typeof value === "string") return INTEGER_STRING.test(value) ? {
+				kind: "IntValue",
+				value
+			} : {
+				kind: "StringValue",
+				value
+			};
+			if (typeof value === "number") return Number.isInteger(value) ? {
+				kind: "IntValue",
+				value: String(value)
+			} : void 0;
+			return typeof value === "bigint" ? {
+				kind: "IntValue",
+				value: String(value)
+			} : void 0;
+		default: return defaultScalarLiteral(value);
+	}
+}
+/** graphql-js `defaultScalarValueToLiteral`. */
+function defaultScalarLiteral(value) {
+	if (value == null) return { kind: "NullValue" };
+	switch (typeof value) {
+		case "boolean": return {
+			kind: "BooleanValue",
+			value
+		};
+		case "string": return {
+			kind: "StringValue",
+			value
+		};
+		case "bigint": return {
+			kind: "IntValue",
+			value: value.toString()
+		};
+		case "number": {
+			if (!Number.isFinite(value)) return { kind: "NullValue" };
+			const text = String(value);
+			return INTEGER_STRING.test(text) ? {
+				kind: "IntValue",
+				value: text
+			} : {
+				kind: "FloatValue",
+				value: text
+			};
+		}
+		case "object": {
+			if (isIterableObject(value)) return {
+				kind: "ListValue",
+				values: Array.from(value, defaultScalarLiteral)
+			};
+			const record = value;
+			const fields = [];
+			for (const key of Object.keys(record)) if (record[key] !== void 0) fields.push([key, defaultScalarLiteral(record[key])]);
+			return {
+				kind: "ObjectValue",
+				fields
+			};
+		}
+		default: throw new TypeError(`Cannot convert value to AST: ${describe(value)}.`);
+	}
+}
+function isIterableObject(value) {
+	return typeof value === "object" && value !== null && typeof value[Symbol.iterator] === "function";
+}
+/** graphql-js `print()` of a value literal. */
+function printLiteral(literal) {
+	switch (literal.kind) {
+		case "IntValue":
+		case "FloatValue":
+		case "EnumValue": return literal.value;
+		case "StringValue": return printString(literal.value);
+		case "BooleanValue": return literal.value ? "true" : "false";
+		case "NullValue": return "null";
+		case "ListValue": {
+			const values = literal.values.map(printLiteral);
+			const line = `[${values.join(", ")}]`;
+			return line.length > MAX_LINE_LENGTH ? `[\n${indent(values.join("\n"))}\n]` : line;
+		}
+		case "ObjectValue": {
+			const fields = literal.fields.map(([name, value]) => `${name}: ${printLiteral(value)}`);
+			const line = `{ ${fields.join(", ")} }`;
+			if (line.length <= MAX_LINE_LENGTH) return line;
+			const body = indent(fields.join("\n"));
+			return body === "" ? "" : `{\n${body}\n}`;
+		}
+	}
+}
+/** graphql-js `indent()` of the printer. */
+function indent(text) {
+	return text === "" ? "" : `  ${text.replaceAll("\n", "\n  ")}`;
+}
+function printBlock(items) {
+	return items.length === 0 ? "" : ` {\n${items.join("\n")}\n}`;
+}
+function printDeprecated(reason) {
+	if (reason === void 0) return "";
+	return reason === "No longer supported" ? " @deprecated" : ` @deprecated(reason: ${printString(reason)})`;
+}
+/** graphql-js `printDescription()` of `printSchema`. */
+function printDescription(description, indentation, firstInBlock) {
+	if (description === void 0) return "";
+	const text = isPrintableAsBlockString(description) ? printBlockString(description) : printString(description);
+	return `${indentation !== "" && !firstInBlock ? `\n${indentation}` : indentation}${text.replaceAll("\n", `\n${indentation}`)}\n`;
+}
+function checkedTypeRef(type, coordinate) {
+	if (parseTypeRef(type) === void 0) throw new Error(`Invalid type reference '${type}' (${coordinate})`);
+	return type;
+}
+function describe(value) {
+	if (value === void 0) return "undefined";
+	if (typeof value === "bigint") return `${value}n`;
+	if (typeof value === "number" && !Number.isFinite(value)) return String(value);
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+/** `\t` and space: the GraphQL `WhiteSpace` characters. */
+function isWhiteSpace(code) {
+	return code === 9 || code === 32;
+}
+/** Escape sequence of each code unit graphql-js escapes in a string value. */
+const ESCAPES = Array.from({ length: 160 }, (_, code) => {
+	switch (code) {
+		case 8: return "\\b";
+		case 9: return "\\t";
+		case 10: return "\\n";
+		case 12: return "\\f";
+		case 13: return "\\r";
+		case 34: return "\\\"";
+		case 92: return "\\\\";
+		default: return code < 32 || code >= 127 ? `\\u${code.toString(16).toUpperCase().padStart(4, "0")}` : "";
+	}
+});
+const ESCAPED = /[\x00-\x1f\x22\x5c\x7f-\x9f]/g;
+/** A GraphQL string value (`"..."`), escaped like graphql-js `printString`. */
+function printString(value) {
+	return `"${value.replace(ESCAPED, (char) => ESCAPES[char.charCodeAt(0)] ?? char)}"`;
+}
+/** graphql-js `isPrintableAsBlockString`. */
+function isPrintableAsBlockString(value) {
+	if (value === "") return true;
+	let isEmptyLine = true;
+	let hasIndent = false;
+	let hasCommonIndent = true;
+	let seenNonEmptyLine = false;
+	for (let i = 0; i < value.length; ++i) switch (value.codePointAt(i)) {
+		case 0:
+		case 1:
+		case 2:
+		case 3:
+		case 4:
+		case 5:
+		case 6:
+		case 7:
+		case 8:
+		case 11:
+		case 12:
+		case 14:
+		case 15:
+		case 13: return false;
+		case 10:
+			if (isEmptyLine && !seenNonEmptyLine) return false;
+			seenNonEmptyLine = true;
+			isEmptyLine = true;
+			hasIndent = false;
+			break;
+		case 9:
+		case 32:
+			hasIndent ||= isEmptyLine;
+			break;
+		default:
+			hasCommonIndent &&= hasIndent;
+			isEmptyLine = false;
+	}
+	if (isEmptyLine) return false;
+	if (hasCommonIndent && seenNonEmptyLine) return false;
+	return true;
+}
+/** A GraphQL block string (`"""..."""`), laid out like graphql-js `printBlockString`. */
+function printBlockString(value) {
+	const escaped = value.replaceAll("\"\"\"", "\\\"\"\"");
+	const lines = escaped.split(/\r\n|[\n\r]/g);
+	const isSingleLine = lines.length === 1;
+	const forceLeadingNewLine = lines.length > 1 && lines.slice(1).every((line) => line.length === 0 || isWhiteSpace(line.charCodeAt(0)));
+	const hasTrailingTripleQuotes = escaped.endsWith("\\\"\"\"");
+	const hasTrailingQuote = value.endsWith("\"") && !hasTrailingTripleQuotes;
+	const hasTrailingSlash = value.endsWith("\\");
+	const forceTrailingNewline = hasTrailingQuote || hasTrailingSlash;
+	const printAsMultipleLines = !isSingleLine || value.length > 70 || forceTrailingNewline || forceLeadingNewLine || hasTrailingTripleQuotes;
+	let result = "";
+	const skipLeadingNewLine = isSingleLine && isWhiteSpace(value.charCodeAt(0));
+	if (printAsMultipleLines && !skipLeadingNewLine || forceLeadingNewLine) result += "\n";
+	result += escaped;
+	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;
+/** `value` (an internal value) as a GraphQL external value of `ref`; `types` resolves enums and inputs. */
+function externalValue(value, ref, types) {
+	if (value === null) return ref.nonNull ? { error: "null for a non-null type" } : { value: null };
+	if (value === void 0) return { error: "undefined" };
+	if (ref.kind === "list") {
+		if (!Array.isArray(value)) return externalValue(value, ref.of, types);
+		const items = [];
+		for (const item of value) {
+			const converted = externalValue(item, ref.of, types);
+			if ("error" in converted) return converted;
+			items.push(converted.value);
+		}
+		return { value: items };
+	}
+	switch (ref.name) {
+		case "String": return typeof value === "string" ? { value } : { error: "expected a string" };
+		case "ID": return typeof value === "string" || typeof value === "number" && Number.isInteger(value) ? { value } : { error: "expected a string or an integer" };
+		case "Int": return typeof value === "number" && Number.isInteger(value) && value <= GRAPHQL_INT_MAX && value >= GRAPHQL_INT_MIN ? { value } : { error: "expected a 32-bit integer" };
+		case "Float": return typeof value === "number" && Number.isFinite(value) ? { value } : { error: "expected a finite number" };
+		case "Boolean": return typeof value === "boolean" ? { value } : { error: "expected a boolean" };
+		case "JSON": return isJson(value) ? { value } : { error: "expected a JSON value" };
+	}
+	const type = types.get(ref.name);
+	if (type?.kind === "enum") {
+		const found = type.values.find((entry) => entry.value === value) ?? (typeof value === "string" ? type.values.find((entry) => entry.name === value) : void 0);
+		return found === void 0 ? { error: `expected one of ${type.values.map((entry) => entry.name).join(", ")}` } : { value: found.name };
+	}
+	if (type?.kind === "input") {
+		if (typeof value !== "object" || Array.isArray(value)) return { error: `expected an object of type ${type.name}` };
+		const record = value;
+		for (const key of Object.keys(record)) if (!type.fields.some((field) => field.name === key)) return { error: `${type.name} has no field '${key}'` };
+		const result = {};
+		for (const field of type.fields) {
+			if (!Object.hasOwn(record, field.name) || record[field.name] === void 0) {
+				if (field.ref.nonNull && field.defaultValue === void 0) return { error: `${type.name}.${field.name} is required` };
+				continue;
+			}
+			const converted = externalValue(record[field.name], field.ref, types);
+			if ("error" in converted) return { error: `${type.name}.${field.name}: ${converted.error}` };
+			result[field.name] = converted.value;
+		}
+		return { value: result };
+	}
+	return { error: `defaults of the scalar ${ref.name} are not supported` };
+}
+/** A JSON-compatible value (the `JSON` scalar). */
+function isJson(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (Array.isArray(value)) return value.every(isJson);
+	if (typeof value !== "object") return false;
+	return Object.values(value).every(isJson);
+}
+// src/compiler/discriminators.ts
+/**
+* `instanceof` when every member is an exported class (subclasses first), `__typename` when every
+* member declares it, else the first property of the first member whose literal value differs in
+* every member; `undefined` when none applies (ZNIGHT064).
+*/
+function discriminatorOf(members, classInfo) {
+	if (members.every((member) => member.classIdentity !== void 0 && classInfo(member.classIdentity)?.exported)) {
+		const depth = (identity) => classInfo(identity)?.heritage.length ?? 0;
+		return {
+			by: "class",
+			classes: members.map((member) => ({
+				identity: member.classIdentity,
+				name: member.name
+			})).sort((a, b) => depth(b.identity) - depth(a.identity) || compareStrings(a.name, b.name))
+		};
+	}
+	if (members.every((member) => member.properties.some((property) => property.name === "__typename"))) return { by: "typename" };
+	for (const candidate of members[0]?.properties ?? []) {
+		if (candidate.optional || candidate.literal === void 0) continue;
+		const values = literalValues(members, candidate.name);
+		if (values !== void 0) return {
+			by: "property",
+			property: candidate.name,
+			values
+		};
+	}
+}
+/** Literal value → member name when `property` is a required literal with a distinct value in every member. */
+function literalValues(members, property) {
+	const values = /* @__PURE__ */ new Map();
+	for (const member of members) {
+		const found = member.properties.find((entry) => entry.name === property);
+		if (found === void 0 || found.optional || found.literal === void 0) return void 0;
+		const key = String(found.literal);
+		if (values.has(key)) return void 0;
+		values.set(key, member.name);
+	}
+	const sorted = {};
+	for (const key of [...values.keys()].sort(compareStrings)) sorted[key] = values.get(key);
+	return sorted;
+}
+// src/compiler/docs.ts
+/** The comment text (before the first tag), `undefined` when empty. */
+function descriptionOf(doc) {
+	return doc === void 0 || doc.text === "" ? void 0 : doc.text;
+}
+/** The first tag named `name`. */
+function tagOf(doc, name) {
+	return doc?.tags.find((tag) => tag.name === name);
+}
+/** `@deprecated reason`: the reason (graphql-js' default one without text), `undefined` without the tag. */
+function deprecationOf(doc) {
+	const tag = tagOf(doc, "deprecated");
+	if (tag === void 0) return void 0;
+	const reason = tag.text.trim();
+	return reason === "" ? DEFAULT_DEPRECATION_REASON : reason;
+}
+/** `true` with a `@gqlHidden` tag. */
+function isHidden(doc) {
+	return tagOf(doc, "gqlHidden") !== void 0;
+}
+/**
+* The text of `@param name text` (also `@param {Type} name - text`), `undefined` when there is no
+* such tag or it has no text.
+*/
+function paramDescription(doc, name) {
+	for (const tag of doc?.tags ?? []) {
+		if (tag.name !== "param") continue;
+		const match = /^(?:\{[^}]*\}\s*)?\[?([\w$]+)(?:=[^\]]*)?\]?(?:\s+-)?(?:\s+([\s\S]*))?$/.exec(tag.text.trim());
+		if (match?.[1] !== name) continue;
+		const text = match[2]?.trim();
+		return text === void 0 || text === "" ? void 0 : text;
+	}
+}
+/** A `@default` value: JSON when it parses, the text otherwise (`@default title`). */
+function defaultTagValue(tag) {
+	const text = tag.text.trim();
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+// src/compiler/locate.ts
+/** From the member name: `name?: ` or `name(): ` (a getter), up to the annotation. */
+const MEMBER_HEAD = /^(?:[\w$]+|'[^']*'|"[^"]*")\s*\??\s*(?:\(\s*\))?\s*:\s*/;
+const OPENING = /* @__PURE__ */ new Set([
+	"(",
+	"[",
+	"{",
+	"<"
+]);
+const CLOSING = /* @__PURE__ */ new Set([
+	")",
+	"]",
+	"}",
+	">"
+]);
+/**
+* The type annotation of a property, a property signature or a getter (`get x(): T`), from the
+* location of the member (its name); the member itself when the annotation cannot be found.
+*/
+function annotationLocation(project, member) {
+	if (member === void 0) return void 0;
+	const file = project.getFile(member.file);
+	if (file === void 0) return member;
+	const text = file.text;
+	const head = MEMBER_HEAD.exec(text.slice(member.start, member.start + 256));
+	if (head === null) return member;
+	const start = member.start + head[0].length;
+	let depth = 0;
+	let end = start;
+	for (let index = start; index < text.length; index++) {
+		const char = text[index];
+		if (char === "=" && text[index + 1] === ">") {
+			index++;
+			continue;
+		}
+		if (depth === 0 && end > start && (char === "{" || char === "=")) break;
+		if (OPENING.has(char)) depth++;
+		else if (CLOSING.has(char)) {
+			if (depth === 0) break;
+			depth--;
+		} else if (depth === 0 && (char === ";" || char === ",")) break;
+		else if (depth === 0 && char === "\n" && !/^\s*[|&]/.test(text.slice(index + 1, index + 64))) break;
+		if (!/\s/.test(char)) end = index + 1;
+	}
+	return end > start ? file.location({
+		start,
+		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) {
+	const byType = /* @__PURE__ */ new Map();
+	const byName = /* @__PURE__ */ new Map();
+	for (const definition of ctx.definitionsOf(GraphQLIds.scalar)) {
+		const fail = (message, hints, related = []) => report({
+			code: Codes.InvalidDecorator,
+			severity: "error",
+			message,
+			location: definition.call,
+			hints,
+			related
+		});
+		const [nameArg, definitionArg] = definition.args;
+		const name = nameArg?.evaluated === true ? nameArg.value : void 0;
+		if (typeof name !== "string") {
+			fail(`scalar() of ${definition.name} needs a static name`, [`scalar<T>('Name', { ... })`]);
+			continue;
+		}
+		if (!isGraphQLName(name) || SPECIFIED_SCALARS.has(name)) {
+			report({
+				code: Codes.NameConflict,
+				severity: "error",
+				message: SPECIFIED_SCALARS.has(name) ? `'${name}' is a specified GraphQL scalar: scalar() cannot redefine it (${definition.name})` : `'${name}' is not a valid GraphQL scalar name (${definition.name})`,
+				location: nameArg?.location ?? definition.call,
+				hints: ["GraphQL names match /^[_A-Za-z][_0-9A-Za-z]*$/ and do not start with __"]
+			});
+			continue;
+		}
+		const type = definition.typeArgIdentities?.[0];
+		if (type === void 0) {
+			report({
+				code: Codes.InvalidType,
+				severity: "error",
+				message: `scalar('${name}') of ${definition.name} needs a named type argument: scalar<T>('${name}', ...)`,
+				location: definition.call,
+				hints: [`Name the TypeScript type of the scalar: export type ${name} = string & { readonly __brand: '${name}' }, then scalar<${name}>('${name}', ...)`]
+			});
+			continue;
+		}
+		if (SCALAR_ALIASES.has(type)) {
+			fail(`scalar('${name}') of ${definition.name} cannot map ${type.slice(type.indexOf("#") + 1)}: it is a built-in scalar alias`, ["Declare a branded type for the scalar: export type Name = string & { readonly __brand: \"Name\" }"]);
+			continue;
+		}
+		if (!definition.exported) {
+			fail(`The scalar ${definition.name} must be exported: the generated module imports it`, [`export const ${definition.name} = scalar<...>('${name}', ...)`]);
+			continue;
+		}
+		const declaration = {
+			name,
+			identity: definition.identity,
+			type,
+			description: staticProperty(ctx, definitionArg, "description"),
+			specifiedByURL: staticProperty(ctx, definitionArg, "specifiedByURL"),
+			location: definition.location
+		};
+		const sameType = byType.get(type);
+		if (sameType !== void 0) {
+			report({
+				code: Codes.NameConflict,
+				severity: "error",
+				message: `${definition.name} and ${sameType.identity} both map ${type.slice(type.indexOf("#") + 1)} to a scalar`,
+				location: definition.location,
+				related: [{
+					message: "the other scalar",
+					location: sameType.location
+				}],
+				hints: ["Keep one scalar per TypeScript type"]
+			});
+			continue;
+		}
+		const sameName = byName.get(name);
+		if (sameName !== void 0) {
+			report({
+				code: Codes.NameConflict,
+				severity: "error",
+				message: `Two scalars are named '${name}': ${definition.identity} and ${sameName.identity}`,
+				location: definition.location,
+				related: [{
+					message: "the other scalar",
+					location: sameName.location
+				}],
+				hints: ["Rename one of them"]
+			});
+			continue;
+		}
+		byType.set(type, declaration);
+		byName.set(name, declaration);
+	}
+	return byType;
+}
+/** A string property of an object literal argument, when statically evaluable. */
+function staticProperty(ctx, arg, key) {
+	if (arg === void 0) return void 0;
+	if (arg.evaluated && typeof arg.value === "object" && arg.value !== null && !Array.isArray(arg.value)) {
+		const value = arg.value[key];
+		return typeof value === "string" ? value : void 0;
+	}
+	const node = arg.node;
+	if (node.type !== "ObjectExpression") return void 0;
+	for (const property of node.properties) {
+		if (property.type !== "Property" || property.computed) continue;
+		if ((property.key.type === "Identifier" ? property.key.name : void 0) !== key) continue;
+		const result = ctx.project.evaluate(arg.location.file, property.value, { refs: "none" });
+		return result.kind === "value" && typeof result.value === "string" ? result.value : void 0;
+	}
+}
+// src/compiler/sdl-view.ts
+/** The SDL view of a model type. */
+function sdlType(model) {
+	const base = model.description === void 0 ? {} : { description: model.description };
+	switch (model.kind) {
+		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,
+				...field.description === void 0 ? {} : { description: field.description },
+				...field.deprecationReason === void 0 ? {} : { deprecationReason: field.deprecationReason },
+				...field.args.length === 0 ? {} : { args: field.args.map(sdlInputValue) }
+			}))
+		};
+		case "input": return {
+			kind: "input",
+			name: model.name,
+			...base,
+			fields: model.fields.map(sdlInputValue)
+		};
+		case "enum": return {
+			kind: "enum",
+			name: model.name,
+			...base,
+			values: model.values.map((value) => ({
+				name: value.name,
+				...value.description === void 0 ? {} : { description: value.description },
+				...value.deprecationReason === void 0 ? {} : { deprecationReason: value.deprecationReason }
+			}))
+		};
+		case "union": return {
+			kind: "union",
+			name: model.name,
+			...base,
+			members: model.members
+		};
+		case "scalar": return {
+			kind: "scalar",
+			name: model.name,
+			...base,
+			...model.definition === void 0 ? { builtin: true } : {},
+			...model.specifiedByURL === void 0 ? {} : { specifiedByURL: model.specifiedByURL }
+		};
+	}
+}
+function sdlInputValue(arg) {
+	return {
+		name: arg.name,
+		type: arg.type,
+		...arg.description === void 0 ? {} : { description: arg.description },
+		...arg.deprecationReason === void 0 ? {} : { deprecationReason: arg.deprecationReason },
+		...arg.defaultValue === void 0 ? {} : { defaultValue: arg.defaultValue }
+	};
+}
+// src/compiler/builder.ts
+const NAME_HINT = "GraphQL names match /^[_A-Za-z][_0-9A-Za-z]*$/ and do not start with __";
+const RECORD_HINT = "GraphQL objects have fixed fields: declare an interface, or use JSONValue (import type { JSONValue } from '@znight/graphql')";
+const ROOT_NAMES = new Set(Object.values(ROOT_TYPE_NAMES));
+/** Builds the model; `undefined` when the application has no resolver. */
+function buildModel(ctx, options) {
+	const resolvers = [...ctx.stored].sort((a, b) => compareStrings(a.host.identity, b.host.identity));
+	if (resolvers.length === 0) return void 0;
+	return new SchemaBuilder(ctx, options).build(resolvers);
+}
+var SchemaBuilder = class {
+	#ctx;
+	#number;
+	#shapeOptions;
+	/** `scalar<T>()` declarations by the identity of `T`. */
+	#scalars;
+	/** Every named shape seen, by key. */
+	#named = /* @__PURE__ */ new Map();
+	/** Models by GraphQL name (the first claimant). */
+	#types = /* @__PURE__ */ new Map();
+	/** Models by declaration key. */
+	#models = /* @__PURE__ */ new Map();
+	/** GraphQL names by declaration key. */
+	#names = /* @__PURE__ */ new Map();
+	#positions = /* @__PURE__ */ new Map();
+	#reported = /* @__PURE__ */ new Set();
+	#fieldResolvers = /* @__PURE__ */ new Map();
+	#defaults = [];
+	#methods = /* @__PURE__ */ new Map();
+	#errors = 0;
+	constructor(ctx, options) {
+		this.#ctx = ctx;
+		this.#number = options.number;
+		const declarations = readScalars(ctx, (diagnostic) => this.#report(diagnostic));
+		this.#scalars = declarations;
+		const keep = [.../* @__PURE__ */ new Set([...BASE_KEEP, ...declarations.keys()])].sort(compareStrings);
+		this.#shapeOptions = Object.freeze({
+			keep: Object.freeze(keep),
+			members: "instance",
+			jsdoc: true
+		});
+	}
+	build(resolvers) {
+		checkLoaders(this.#ctx, resolvers, (diagnostic) => this.#report(diagnostic));
+		this.#indexFieldResolvers(resolvers);
+		const roots = /* @__PURE__ */ new Map();
+		const rootFields = /* @__PURE__ */ new Map();
+		let hasQuery = false;
+		for (const resolver of resolvers) for (const field of resolver.fields) {
+			if (field.operation === "field") continue;
+			if (field.operation === "query") hasQuery = true;
+			if (!field.complete) continue;
+			const method = this.#method(resolver, field);
+			if (method === void 0) continue;
+			const root = this.#rootModel(roots, field.operation);
+			const coordinate = `${root.name}.${field.name}`;
+			const previous = rootFields.get(coordinate);
+			if (previous !== void 0) {
+				this.#report({
+					code: Codes.NameConflict,
+					severity: "error",
+					message: `Two root fields are named ${coordinate}: ${resolver.host.displayName}.${field.method} and ${previous.resolver.host.displayName}.${previous.field.method}`,
+					location: field.location,
+					related: [{
+						message: "the other field",
+						location: previous.field.location
+					}],
+					hints: [`Rename one of them: @${decoratorName(field.operation)}('otherName')`]
+				});
+				continue;
+			}
+			rootFields.set(coordinate, {
+				field,
+				resolver
+			});
+			root.fields.push(this.#resolverField(root, resolver, field, method));
+		}
+		if (!hasQuery) {
+			const first = resolvers[0];
+			this.#report({
+				code: Codes.InvalidResolver,
+				severity: "error",
+				message: "The application has GraphQL resolvers but no @Query field: GraphQL requires a query root type",
+				location: first.location,
+				hints: [`Add a @Query() method to a resolver (${first.host.displayName}, for instance)`]
+			});
+		}
+		this.#reportUnreachableFieldResolvers();
+		this.#checkDefaults();
+		this.#checkInputCycles();
+		checkDecisions(this.#ctx, resolvers, (diagnostic) => this.#report(diagnostic));
+		if (this.#errors > 0 || !hasQuery) return void 0;
+		return this.#assemble(roots, resolvers);
+	}
+	#report(diagnostic) {
+		if (diagnostic.severity === "error") this.#errors++;
+		this.#ctx.report(diagnostic);
+	}
+	/** Reports once per `key`. */
+	#reportOnce(key, diagnostic) {
+		if (this.#reported.has(key)) return;
+		this.#reported.add(key);
+		this.#report(diagnostic);
+	}
+	#fail(code, use, message, hints) {
+		const location = use.locate();
+		this.#report({
+			code,
+			severity: "error",
+			message,
+			...location === void 0 ? {} : { location },
+			...hints.length === 0 ? {} : { hints },
+			related: reachedFrom(use)
+		});
+	}
+	#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);
+	}
+	#shape(target) {
+		const result = this.#ctx.types.shape(target, this.#shapeOptions);
+		for (const named of result.named.values()) this.#named.set(named.key, named);
+		return result;
+	}
+	#rootModel(roots, operation) {
+		let root = roots.get(operation);
+		if (root === void 0) {
+			const name = ROOT_TYPE_NAMES[operation];
+			root = {
+				kind: "object",
+				name,
+				key: `#root:${operation}`,
+				description: void 0,
+				location: void 0,
+				fields: [],
+				trail: name,
+				root: void 0,
+				classIdentity: void 0,
+				properties: [],
+				interfaces: []
+			};
+			roots.set(operation, root);
+			this.#claim(root, void 0);
+		}
+		return root;
+	}
+	/** A field backed by a resolver method (root field or field resolver). */
+	#resolverField(owner, resolver, field, method) {
+		const coordinate = `${owner.name}.${field.name}`;
+		const isRoot = field.operation !== "field";
+		const use = {
+			position: "output",
+			coordinate,
+			trail: isRoot ? coordinate : `${owner.trail}.${field.name}`,
+			reached: isRoot ? void 0 : owner.trail,
+			root: isRoot ? method.location : owner.root,
+			locate: () => method.location
+		};
+		const type = this.#returnType(resolver, field, method, use);
+		return {
+			name: field.name,
+			type: type === void 0 ? "String" : printTypeRef(type.ref),
+			description: descriptionOf(method.doc),
+			deprecationReason: deprecationOf(method.doc),
+			args: this.#arguments(field, method, use),
+			binding: {
+				resolver,
+				field
+			},
+			location: field.location
+		};
+	}
+	#returnType(resolver, field, method, use) {
+		const where = `${resolver.host.displayName}.${field.method}`;
+		if (method.returnType === void 0) return this.#fail(Codes.InvalidType, use, `${where} has no return type annotation (${use.coordinate})`, [`Annotate the return type: the schema is derived from it (${field.method}(...): Promise<Book>)`]);
+		const result = this.#shape({ returnOf: method });
+		const rootIssue = result.issues.find((issue) => issue.named === void 0);
+		const located = {
+			...use,
+			locate: () => rootIssue?.location ?? method.location
+		};
+		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.#report({
+					code: Codes.InvalidResolver,
+					severity: "error",
+					message: `@Subscription ${where} must return an async iterable, not ${describeShape(root)}`,
+					location: method.location,
+					hints: [`Declare it as an async generator (async *${field.method}(): AsyncGenerator<Event>) or return pubsub.subscribe(...) (AsyncIterable<Event>)`]
+				});
+				return;
+			}
+			const item = iterable.typeArgs[0];
+			if (item === void 0) return this.#fail(Codes.InvalidType, located, `${where} must declare the type of its events (${use.coordinate})`, ["AsyncIterable<Event>"]);
+			return this.#convert(item, false, located);
+		}
+		if (iterable !== void 0) return this.#fail(Codes.InvalidType, located, `${where} returns an async iterable: only @Subscription fields stream values (${use.coordinate})`, ["Use @Subscription() for a stream of events, or return a list (Promise<readonly Book[]>)"]);
+		if (root.kind === "undefined") return this.#fail(Codes.InvalidType, located, `${where} returns void: GraphQL fields must return a value (${use.coordinate})`, ["Return a payload type (the changed object) or a boolean"]);
+		return this.#convert(root, false, located);
+	}
+	/** Arguments of a resolver field: `@Args('name')` parameters and the properties of `@Args()` types. */
+	#arguments(field, method, owner) {
+		const args = [];
+		const seen = /* @__PURE__ */ new Map();
+		const add = (arg, location) => {
+			if (seen.has(arg.name)) {
+				const first = seen.get(arg.name);
+				this.#report({
+					code: Codes.NameConflict,
+					severity: "error",
+					message: `Argument '${arg.name}' of ${owner.coordinate} is declared twice`,
+					...location === void 0 ? {} : { location },
+					...first === void 0 ? {} : { related: [{
+						message: "first declared here",
+						location: first
+					}] },
+					hints: ["Argument names must be unique: rename one of them"]
+				});
+				return;
+			}
+			seen.set(arg.name, location);
+			args.push(arg);
+		};
+		field.params.forEach((data, index) => {
+			if (data?.kind !== "args") return;
+			const param = method.params[index];
+			const result = this.#shape({ parameter: param });
+			if (data.name !== void 0) {
+				const use = {
+					position: "input",
+					coordinate: `${owner.coordinate}(${data.name}:)`,
+					trail: `${owner.trail}(${data.name})`,
+					reached: owner.reached,
+					root: owner.root,
+					locate: () => param.typeLocation
+				};
+				const arg = this.#parameterArgument(data.name, param, method, result, use);
+				if (arg !== void 0) add(arg, param.location);
+				return;
+			}
+			const properties = this.#propertiesOf(result.root);
+			if (properties === "record") {
+				this.#fail(Codes.InvalidType, {
+					...owner,
+					locate: () => param.typeLocation
+				}, `@Args() parameter '${param.name}' of ${owner.coordinate} cannot be a record or an index signature: GraphQL arguments are fixed`, [RECORD_HINT, `@Args('${param.name}') declares one argument named '${param.name}'`]);
+				return;
+			}
+			if (properties === void 0) {
+				this.#fail(Codes.InvalidType, {
+					...owner,
+					locate: () => param.typeLocation
+				}, `@Args() parameter '${param.name}' of ${owner.coordinate} must have an object type: its properties are the arguments`, [`@Args('${param.name}') declares one argument named '${param.name}'`]);
+				return;
+			}
+			for (const property of properties) {
+				if (isHidden(property.doc)) continue;
+				const use = {
+					position: "input",
+					coordinate: `${owner.coordinate}(${property.name}:)`,
+					trail: `${owner.trail}(${property.name})`,
+					reached: owner.reached,
+					root: owner.root,
+					locate: () => annotationLocation(this.#ctx.project, property.location) ?? param.typeLocation
+				};
+				const arg = this.#inputValue(property, use);
+				if (arg !== void 0) add(arg, property.location ?? param.location);
+			}
+		});
+		return args;
+	}
+	/** `@Args('limit') limit: Int = 20`. */
+	#parameterArgument(name, param, method, result, use) {
+		if (!isGraphQLName(name)) {
+			this.#fail(Codes.NameConflict, use, `'${name}' is not a valid GraphQL argument name (${use.coordinate})`, [NAME_HINT]);
+			return;
+		}
+		const converted = this.#convert(result.root, param.optional, use);
+		if (converted === void 0) return void 0;
+		let ref = converted.ref;
+		const arg = {
+			name,
+			type: "",
+			ref,
+			description: descriptionOf(param.doc) ?? paramDescription(method.doc, param.name),
+			deprecationReason: deprecationOf(param.doc),
+			defaultValue: void 0,
+			nullAsUndefined: false,
+			location: param.location
+		};
+		const initializer = param.initializer;
+		let hasDefault = false;
+		if (param.hasDefault) {
+			if (initializer?.evaluated === true && initializer.ref === void 0 && !containsRef(initializer.value)) {
+				this.#defaults.push({
+					target: arg,
+					value: initializer.value,
+					use,
+					location: initializer.location
+				});
+				hasDefault = true;
+			} else ref = {
+				...ref,
+				nonNull: false
+			};
+		}
+		arg.ref = ref;
+		arg.type = printTypeRef(ref);
+		arg.nullAsUndefined = !ref.nonNull && !converted.acceptsNull;
+		this.#checkDeprecatedInput(arg, hasDefault, use);
+		return arg;
+	}
+	/** A property as an argument or an input field (§6.3): `@default`, `@deprecated`, null handling. */
+	#inputValue(property, use) {
+		if (!isGraphQLName(property.name)) {
+			this.#fail(Codes.NameConflict, {
+				...use,
+				locate: () => property.location
+			}, `'${property.name}' is not a valid GraphQL name (${use.coordinate})`, [NAME_HINT, "Hide the property with /** @gqlHidden */"]);
+			return;
+		}
+		if (property.kind === "getter") {
+			this.#fail(Codes.InvalidInput, use, `${use.coordinate} is a getter: input values are plain data`, ["Declare a property instead, or hide the getter with /** @gqlHidden */"]);
+			return;
+		}
+		const converted = this.#convert(property.shape, property.optional, use);
+		if (converted === void 0) return void 0;
+		const arg = {
+			name: property.name,
+			type: printTypeRef(converted.ref),
+			ref: converted.ref,
+			description: descriptionOf(property.doc),
+			deprecationReason: deprecationOf(property.doc),
+			defaultValue: void 0,
+			nullAsUndefined: !converted.ref.nonNull && !converted.acceptsNull,
+			location: property.location
+		};
+		const tag = tagOf(property.doc, "default");
+		if (tag !== void 0) this.#defaults.push({
+			target: arg,
+			value: defaultTagValue(tag),
+			use,
+			location: tag.location
+		});
+		this.#checkDeprecatedInput(arg, tag !== void 0, use);
+		return arg;
+	}
+	/** graphql-js rejects a deprecated argument or input field that is required. */
+	#checkDeprecatedInput(arg, hasDefault, use) {
+		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"]);
+	}
+	#indexFieldResolvers(resolvers) {
+		for (const resolver of resolvers) for (const field of resolver.fields) {
+			if (field.operation !== "field" || !field.complete) continue;
+			const method = this.#method(resolver, field);
+			if (method === void 0) continue;
+			const index = field.params.findIndex((param) => param?.kind === "parent");
+			const param = method.params[index];
+			if (param === void 0) continue;
+			const result = this.#shape({ parameter: param });
+			const key = this.#objectKeyOf(result.root);
+			if (key === void 0) {
+				this.#report({
+					code: Codes.InvalidResolver,
+					severity: "error",
+					message: `The @Parent() parameter '${param.name}' of ${resolver.host.displayName}.${field.method} must have an object type, not ${describeShape(result.root)}`,
+					location: param.typeLocation,
+					hints: ["The parent type is the object type the field is added to: an interface, a class or a named alias of an object type"]
+				});
+				continue;
+			}
+			let list = this.#fieldResolvers.get(key);
+			if (list === void 0) {
+				list = [];
+				this.#fieldResolvers.set(key, list);
+			}
+			list.push({
+				resolver,
+				field,
+				method,
+				attached: false
+			});
+		}
+		for (const list of this.#fieldResolvers.values()) list.sort((a, b) => compareStrings(a.resolver.host.identity, b.resolver.host.identity) || a.field.location.start - b.field.location.start);
+	}
+	#attachFieldResolvers(model) {
+		const pending = this.#fieldResolvers.get(model.key);
+		if (pending === void 0) return;
+		for (const entry of pending) {
+			entry.attached = true;
+			const field = this.#resolverField(model, entry.resolver, entry.field, entry.method);
+			const index = model.fields.findIndex((existing) => existing.name === field.name);
+			if (index === -1) {
+				model.fields.push(field);
+				continue;
+			}
+			const existing = model.fields[index];
+			const where = `${entry.resolver.host.displayName}.${entry.field.method}`;
+			if (existing.binding !== void 0) {
+				this.#report({
+					code: Codes.NameConflict,
+					severity: "error",
+					message: `Two field resolvers add ${model.name}.${field.name}: ${where} and ${existing.binding.resolver.host.displayName}.${existing.binding.field.method}`,
+					location: entry.field.location,
+					related: [{
+						message: "the other field resolver",
+						location: existing.binding.field.location
+					}],
+					hints: ["Keep one of them, or rename one: @ResolveField('otherName')"]
+				});
+				continue;
+			}
+			if (existing.type !== field.type) {
+				this.#report({
+					code: Codes.NameConflict,
+					severity: "error",
+					message: `@ResolveField ${where} returns ${field.type}, but the property ${model.name}.${field.name} is ${existing.type}`,
+					location: entry.field.location,
+					...existing.location === void 0 ? {} : { related: [{
+						message: "the property",
+						location: existing.location
+					}] },
+					hints: ["A field resolver replacing a property must resolve the same GraphQL type: change its return type, or rename the field"]
+				});
+				continue;
+			}
+			model.fields[index] = {
+				...field,
+				description: field.description ?? existing.description,
+				deprecationReason: field.deprecationReason ?? existing.deprecationReason
+			};
+		}
+	}
+	#reportUnreachableFieldResolvers() {
+		for (const [key, list] of this.#fieldResolvers) for (const entry of list) {
+			if (entry.attached) continue;
+			const name = this.#named.get(key)?.name ?? key;
+			this.#report({
+				code: Codes.InvalidResolver,
+				severity: "warning",
+				message: `@ResolveField ${entry.resolver.host.displayName}.${entry.field.method} adds a field to ${name}, which no root field reaches as an output type: it is not part of the schema`,
+				location: entry.field.location,
+				hints: [`Return ${name} from a @Query (or another reachable field), or remove the field resolver`]
+			});
+		}
+	}
+	/**
+	* The GraphQL type of a shape: `null`, `undefined` and `optional` make it nullable, everything
+	* else is non-null (§6.2).
+	*/
+	#convert(shape, optional, use) {
+		let nullable = optional;
+		let acceptsNull = false;
+		let inner = shape;
+		if (shape.kind === "union") {
+			const rest = shape.members.filter((member) => member.kind !== "null" && member.kind !== "undefined");
+			if (rest.length !== shape.members.length) {
+				nullable = true;
+				acceptsNull = shape.members.some((member) => member.kind === "null");
+			}
+			if (rest.length === 0) return this.#fail(Codes.InvalidType, use, `${use.coordinate} is always null or undefined`, ["Declare the type of the value"]);
+			inner = rest.length === 1 ? rest[0] : {
+				kind: "union",
+				members: rest
+			};
+		}
+		const converted = this.#inner(inner, use);
+		if (converted === void 0) return void 0;
+		const isNullable = nullable || converted.nullable;
+		return {
+			ref: {
+				...converted.ref,
+				nonNull: !isNullable
+			},
+			acceptsNull: acceptsNull || converted.nullable
+		};
+	}
+	#inner(shape, use) {
+		switch (shape.kind) {
+			case "string": return refTo("String");
+			case "number": return refTo(this.#number);
+			case "boolean": return refTo("Boolean");
+			case "literal":
+				if (typeof shape.value === "string") return refTo("String");
+				return refTo(typeof shape.value === "number" ? this.#number : "Boolean");
+			case "date": return this.#builtin("DateTime", use);
+			case "bigint": return this.#builtin("BigInt", use);
+			case "array": {
+				const item = this.#convert(shape.items, false, use);
+				return item === void 0 ? void 0 : {
+					ref: {
+						kind: "list",
+						of: item.ref,
+						nonNull: false
+					},
+					nullable: false
+				};
+			}
+			case "named": return this.#namedType(shape.key, use);
+			case "reference": return this.#reference(shape, use);
+			case "url": return this.#fail(Codes.InvalidType, use, `Cannot map 'URL' to a GraphQL type (${use.coordinate})`, ["Expose a string (url.href), or declare a scalar: export const UrlScalar = scalar<URL>('URL', { ... })"]);
+			case "binary": return this.#fail(Codes.InvalidType, use, `Cannot map binary data to a GraphQL type (${use.coordinate})`, ["Expose a URL (coverUrl: string), hide the property with /** @gqlHidden */, or declare a scalar: export const Base64 = scalar<Uint8Array>('Base64', { ... })"]);
+			case "unknown": return this.#fail(Codes.InvalidType, use, `Cannot map 'unknown' or 'any' to a GraphQL type (${use.coordinate})`, ["Declare the type, or use JSONValue (import type { JSONValue } from '@znight/graphql') for arbitrary JSON"]);
+			case "never":
+			case "null":
+			case "undefined": return this.#fail(Codes.InvalidType, use, `Cannot map '${shape.kind}' to a GraphQL type (${use.coordinate})`, ["Declare the type of the value"]);
+			case "tuple": return this.#fail(Codes.InvalidType, use, `Cannot map a tuple to a GraphQL type (${use.coordinate})`, ["Use an array (readonly T[]) or a named object type"]);
+			case "object":
+				if (shape.additional !== void 0) return this.#fail(Codes.InvalidType, use, `Cannot map a record or an index signature to a GraphQL type (${use.coordinate})`, [RECORD_HINT]);
+				return this.#fail(Codes.InvalidType, use, `Cannot map an anonymous object type to a GraphQL type (${use.coordinate})`, ["GraphQL types have names: declare it (export interface BookStats { ... }) and use it"]);
+			case "intersection": return this.#fail(Codes.InvalidType, use, `Cannot map an anonymous intersection to a GraphQL type (${use.coordinate})`, ["Name it: export type BookWithAuthor = Book & { readonly author: Author }"]);
+			case "union": return this.#anonymousUnion(shape.members, use);
+			case "schema": return this.#fail(Codes.InvalidType, use, `Cannot map a schema type to a GraphQL type (${use.coordinate})`, ["Declare the TypeScript type: the annotation is the GraphQL type"]);
+			case "opaque": return this.#opaque(shape, use);
+		}
+	}
+	#anonymousUnion(members, use) {
+		if (members.every((member) => member.kind === "literal" && typeof member.value === "string")) {
+			const values = members.map((member) => `'${member.value}'`).join(" | ");
+			return this.#fail(Codes.InvalidType, use, `Cannot map the anonymous union ${values} to a GraphQL type (${use.coordinate})`, [`Name it to make it an enum: export type Sort = ${values}`]);
+		}
+		if (members.every((member) => member.kind === "named")) return this.#fail(Codes.InvalidType, use, `Cannot map an anonymous union to a GraphQL type (${use.coordinate})`, [`GraphQL unions have names: export type SearchResult = ${members.map((member) => this.#named.get(member.key)?.name ?? "?").join(" | ")}`]);
+		return this.#fail(Codes.InvalidType, use, `Cannot map the union ${members.map(describeShape).join(" | ")} to a GraphQL type (${use.coordinate})`, ["GraphQL unions only contain object types: declare one type, or an object type per case"]);
+	}
+	#opaque(shape, use) {
+		const text = shape.text;
+		let hints;
+		switch (shape.reason) {
+			case "non-json":
+				if (text.startsWith("Promise")) hints = ["A Promise is only unwrapped at the top of a resolver return type: declare the resolved type"];
+				else if (text.startsWith("Map") || text.startsWith("WeakMap")) hints = ["Use an array of entries, a named object type, or JSONValue (import type { JSONValue } from '@znight/graphql')"];
+				else hints = ["Declare a plain data type (an interface, an array, a scalar)"];
+				break;
+			case "missing-annotation":
+				hints = ["Annotate the type: the compiler reads annotations only"];
+				break;
+			case "function":
+				hints = ["Functions are not data: return the value, or hide the member with /** @gqlHidden */"];
+				break;
+			case "type-parameter":
+				hints = ["Give the type arguments explicitly"];
+				break;
+			default: hints = ["Declare the structure with an interface or a named alias"];
+		}
+		return this.#fail(Codes.InvalidType, use, `Cannot map '${text}' to a GraphQL type (${use.coordinate})`, hints);
+	}
+	#reference(shape, use) {
+		const alias = SCALAR_ALIASES.get(shape.identity);
+		if (alias === "JSON") {
+			const json = this.#builtin("JSON", use);
+			return json === void 0 ? void 0 : {
+				ref: json.ref,
+				nullable: true
+			};
+		}
+		if (alias !== void 0) return refTo(alias === "Float" ? "Float" : alias);
+		const scalar = this.#scalars.get(shape.identity);
+		if (scalar !== void 0) return this.#customScalar(scalar, use);
+		if (OUTPUT_ITERABLES.has(shape.identity)) {
+			if (use.position === "input") return this.#fail(Codes.InvalidInput, use, `${use.coordinate} is a ${shape.name}: input lists are arrays`, ["Declare an array (readonly T[]) for input values"]);
+			const item = shape.typeArgs[0];
+			if (item === void 0) return this.#fail(Codes.InvalidType, use, `${use.coordinate}: ${shape.name} needs a type argument`, []);
+			const converted = this.#convert(item, false, use);
+			return converted === void 0 ? void 0 : {
+				ref: {
+					kind: "list",
+					of: converted.ref,
+					nonNull: false
+				},
+				nullable: false
+			};
+		}
+		if (ASYNC_ITERABLES.has(shape.identity)) return this.#fail(Codes.InvalidType, use, `Cannot map '${shape.name}' to a GraphQL type (${use.coordinate})`, ["Async iterables are only the return type of @Subscription methods"]);
+		return this.#fail(Codes.InvalidType, use, `Cannot map '${shape.name}' to a GraphQL type (${use.coordinate})`, ["Declare a plain data type (an interface, an array, a scalar)"]);
+	}
+	#builtin(name, use) {
+		const key = `#builtin:${name}`;
+		if (!this.#models.has(key)) {
+			const model = {
+				kind: "scalar",
+				name,
+				key,
+				description: void 0,
+				location: void 0,
+				definition: void 0,
+				specifiedByURL: void 0
+			};
+			this.#models.set(key, model);
+			if (!this.#claim(model, use)) return void 0;
+		}
+		return refTo(name);
+	}
+	#customScalar(scalar, use) {
+		const key = `#scalar:${scalar.identity}`;
+		if (!this.#models.has(key)) {
+			const model = {
+				kind: "scalar",
+				name: scalar.name,
+				key,
+				description: scalar.description,
+				location: scalar.location,
+				definition: scalar.identity,
+				specifiedByURL: scalar.specifiedByURL
+			};
+			this.#models.set(key, model);
+			if (!this.#claim(model, use)) return void 0;
+		}
+		return refTo(scalar.name);
+	}
+	#namedType(key, use) {
+		const named = this.#named.get(key);
+		if (named === void 0) return this.#fail(Codes.InvalidType, use, `Cannot resolve the type of ${use.coordinate}`, []);
+		switch (named.declaration) {
+			case "enum": return this.#enum(named, use);
+			case "alias": return this.#alias(named, use);
+			default: return this.#object(named, named, use);
+		}
+	}
+	/**
+	* A named alias: an object type (object literal, intersection, utility type, generic instance),
+	* an enum (string literals), a union (object types), or transparent (`type Email = string`,
+	* `type Books = Book[]`, `type Author = Person`).
+	*/
+	#alias(alias, use) {
+		const shape = alias.shape;
+		switch (shape.kind) {
+			case "object":
+			case "intersection": return this.#object(alias, alias, use);
+			case "named": {
+				const target = this.#named.get(shape.key);
+				if (target !== void 0 && target.declaration !== "alias" && target.declaration !== "enum" && target.typeArgs.length > 0) return this.#object(alias, target, use);
+				return this.#namedType(shape.key, use);
+			}
+			case "union": {
+				const rest = shape.members.filter((member) => member.kind !== "null" && member.kind !== "undefined");
+				const nullable = rest.length !== shape.members.length;
+				if (rest.length === 1) {
+					const inner = this.#inner(rest[0], use);
+					return inner === void 0 ? void 0 : {
+						ref: inner.ref,
+						nullable: inner.nullable || nullable
+					};
+				}
+				let converted;
+				if (rest.every((member) => member.kind === "literal")) converted = this.#literalEnum(alias, rest, use);
+				else if (rest.length > 0 && rest.every((member) => member.kind === "named")) converted = this.#union(alias, rest, use);
+				else converted = this.#anonymousUnion(rest, use);
+				return converted === void 0 ? void 0 : {
+					ref: converted.ref,
+					nullable
+				};
+			}
+			default: return this.#inner(shape, use);
+		}
+	}
+	/**
+	* The declaration key of the object type a shape maps to in output position (the parent of a
+	* field resolver), `undefined` when it is not an object type. Mirrors {@link #alias}.
+	*/
+	#objectKeyOf(shape) {
+		if (shape.kind === "union") {
+			const rest = shape.members.filter((member) => member.kind !== "null" && member.kind !== "undefined");
+			return rest.length === 1 ? this.#objectKeyOf(rest[0]) : void 0;
+		}
+		if (shape.kind !== "named") return void 0;
+		const named = this.#named.get(shape.key);
+		if (named === void 0 || named.declaration === "enum") return void 0;
+		if (named.declaration !== "alias") return named.key;
+		const target = named.shape;
+		if (target.kind === "object" || target.kind === "intersection") return named.key;
+		if (target.kind === "named") {
+			const instance = this.#named.get(target.key);
+			if (instance !== void 0 && instance.declaration !== "alias" && instance.declaration !== "enum" && instance.typeArgs.length > 0) return named.key;
+		}
+		return this.#objectKeyOf(target);
+	}
+	/** An object type (output) or an input object type (input) for `named`, structured as `structure`. */
+	#object(named, structure, use) {
+		const key = named.key;
+		if (!this.#checkPosition(named, use)) return void 0;
+		const existing = this.#models.get(key);
+		if (existing !== void 0) return this.#known(existing);
+		const name = this.#typeName(named, use);
+		if (name === void 0) return void 0;
+		const properties = this.#propertiesOf(structure.shape);
+		if (properties === "record") return this.#fail(Codes.InvalidType, use, `Cannot map ${named.name}, a record or an index signature, to a GraphQL type (${use.coordinate})`, [RECORD_HINT]);
+		if (properties === void 0) return this.#fail(Codes.InvalidType, use, `Cannot map ${named.name} to a GraphQL object type (${use.coordinate})`, ["Declare an interface, a class or a named object type"]);
+		const description = descriptionOf(named.doc) ?? (structure === named ? void 0 : descriptionOf(structure.doc));
+		const trail = `${use.trail} → ${name}`;
+		if (use.position === "input") {
+			const model = {
+				kind: "input",
+				name,
+				key,
+				description,
+				location: named.location,
+				fields: []
+			};
+			this.#models.set(key, model);
+			if (!this.#claim(model, use)) return void 0;
+			for (const property of properties) {
+				if (isHidden(property.doc)) continue;
+				const fieldUse = {
+					position: "input",
+					coordinate: `${name}.${property.name}`,
+					trail: `${trail}.${property.name}`,
+					reached: trail,
+					root: use.root,
+					locate: () => annotationLocation(this.#ctx.project, property.location)
+				};
+				const field = this.#inputValue(property, fieldUse);
+				if (field !== void 0) model.fields.push(field);
+			}
+			return refTo(name);
+		}
+		const model = {
+			kind: "object",
+			name,
+			key,
+			description,
+			location: named.location,
+			fields: [],
+			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)),
+			interfaces: []
+		};
+		this.#models.set(key, model);
+		if (!this.#claim(model, use)) return void 0;
+		for (const property of properties) {
+			const field = this.#outputField(model, property);
+			if (field !== void 0) model.fields.push(field);
+		}
+		this.#attachFieldResolvers(model);
+		return refTo(name);
+	}
+	/** A property as a union discriminator candidate: its literal value, through aliases (`kind: BookKind`). */
+	#discriminant(property) {
+		let shape = property.shape;
+		for (let depth = 0; shape.kind === "named" && depth < 32; depth++) {
+			const named = this.#named.get(shape.key);
+			if (named?.declaration !== "alias") break;
+			shape = named.shape;
+		}
+		return {
+			name: property.name,
+			optional: property.optional,
+			literal: shape.kind === "literal" ? shape.value : void 0
+		};
+	}
+	#outputField(model, property) {
+		if (isHidden(property.doc) || property.name === "__typename") return void 0;
+		if (property.shape.kind === "opaque" && property.shape.reason === "function") return void 0;
+		const use = {
+			position: "output",
+			coordinate: `${model.name}.${property.name}`,
+			trail: `${model.trail}.${property.name}`,
+			reached: model.trail,
+			root: model.root,
+			locate: () => annotationLocation(this.#ctx.project, property.location)
+		};
+		if (!isGraphQLName(property.name)) return this.#fail(Codes.NameConflict, {
+			...use,
+			locate: () => property.location
+		}, `'${property.name}' is not a valid GraphQL field name (${use.coordinate})`, [NAME_HINT, "Hide the property with /** @gqlHidden */"]);
+		const converted = this.#convert(property.shape, property.optional, use);
+		if (converted === void 0) return void 0;
+		return {
+			name: property.name,
+			type: printTypeRef(converted.ref),
+			description: descriptionOf(property.doc),
+			deprecationReason: deprecationOf(property.doc),
+			args: [],
+			binding: void 0,
+			location: property.location
+		};
+	}
+	/**
+	* The properties of an object structure (intersections merged, later members win), `'record'` for
+	* a record or an index signature (ZNIGHT060: GraphQL objects have fixed fields).
+	*/
+	#propertiesOf(shape) {
+		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);
+			}
+			case "intersection": {
+				const merged = /* @__PURE__ */ new Map();
+				for (const member of shape.members) {
+					const properties = this.#propertiesOf(member);
+					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;
+		}
+	}
+	/** A declaration is used in one position: input or output (ZNIGHT063 otherwise). */
+	#checkPosition(named, use) {
+		let uses = this.#positions.get(named.key);
+		if (uses === void 0) {
+			uses = {};
+			this.#positions.set(named.key, uses);
+		}
+		const other = use.position === "input" ? uses.output : uses.input;
+		if (uses[use.position] === void 0) uses[use.position] = {
+			coordinate: use.coordinate,
+			location: use.locate()
+		};
+		if (other === void 0) return true;
+		const output = use.position === "output" ? use.coordinate : other.coordinate;
+		const input = use.position === "input" ? use.coordinate : other.coordinate;
+		const inputOwner = input.includes("(") ? input.slice(0, input.indexOf("(")) : input.split(".")[0];
+		this.#reportOnce(`position\0${named.key}`, {
+			code: Codes.InvalidInput,
+			severity: "error",
+			message: `'${named.name}' is used as an output type (${output}) and as an input type (${input})`,
+			location: named.location,
+			hints: [`GraphQL needs two types: declare \`export interface ${named.name}Input extends ${named.name} {}\` and use it in ${inputOwner}`],
+			related: [...uses.output?.location === void 0 ? [] : [{
+				message: `used as output: ${output}`,
+				location: uses.output.location
+			}], ...uses.input?.location === void 0 ? [] : [{
+				message: `used as input: ${input}`,
+				location: uses.input.location
+			}]]
+		});
+		return false;
+	}
+	/**
+	* The GraphQL name of a declaration (§6.4): `@gqlName`, the declaration name, or for a generic
+	* instance the names of its type arguments followed by the declaration name (`BookPage`).
+	*/
+	#typeName(named, use) {
+		if (this.#names.has(named.key)) return this.#names.get(named.key);
+		let name;
+		const explicit = tagOf(named.doc, "gqlName")?.text.trim();
+		if (explicit !== void 0 && explicit !== "") name = explicit;
+		else if (named.typeArgs.length === 0) name = named.name;
+		else {
+			const args = named.typeArgs.map((arg) => this.#argumentName(arg));
+			const missing = args.findIndex((arg) => arg === void 0);
+			if (missing === -1) name = `${args.join("")}${named.name}`;
+			else this.#reportOnce(`argument\0${named.key}`, {
+				code: Codes.InvalidType,
+				severity: "error",
+				message: `Cannot name the GraphQL type of ${named.name}<...> (${use.coordinate}): its type argument ${describeShape(named.typeArgs[missing])} has no GraphQL name`,
+				location: named.location,
+				related: reachedFrom(use),
+				hints: [`Name the instance with an alias (export type BookPages = ${named.name}<...>) or with /** @gqlName Name */`]
+			});
+		}
+		this.#names.set(named.key, name);
+		return name;
+	}
+	/** The GraphQL name a type argument contributes to a generic instance name. */
+	#argumentName(shape) {
+		switch (shape.kind) {
+			case "string": return "String";
+			case "number": return this.#number;
+			case "boolean": return "Boolean";
+			case "date": return "DateTime";
+			case "bigint": return "BigInt";
+			case "reference": {
+				const alias = SCALAR_ALIASES.get(shape.identity);
+				if (alias !== void 0) return alias;
+				return this.#scalars.get(shape.identity)?.name;
+			}
+			case "union": {
+				const rest = shape.members.filter((member) => member.kind !== "null" && member.kind !== "undefined");
+				return rest.length === 1 ? this.#argumentName(rest[0]) : void 0;
+			}
+			case "named": {
+				const named = this.#named.get(shape.key);
+				if (named === void 0) return void 0;
+				if (named.declaration === "alias") {
+					const target = named.shape;
+					const instance = target.kind === "named" ? this.#named.get(target.key) : void 0;
+					const isObject = target.kind === "object" || target.kind === "intersection" || instance !== void 0 && instance.declaration !== "alias" && instance.declaration !== "enum" && instance.typeArgs.length > 0;
+					const isEnum = target.kind === "union" && target.members.every((member) => member.kind === "literal");
+					const isUnion = target.kind === "union" && target.members.filter((member) => member.kind === "named").length > 1;
+					if (!isObject && !isEnum && !isUnion) return this.#argumentName(target);
+				}
+				return this.#typeName(named, {
+					position: "output",
+					coordinate: named.name,
+					trail: named.name,
+					reached: void 0,
+					root: void 0,
+					locate: () => named.location
+				});
+			}
+			default: return;
+		}
+	}
+	/**
+	* Registers a model under its GraphQL name: the name must be valid, not reserved, and not taken
+	* by another declaration (ZNIGHT061).
+	*/
+	#claim(model, use) {
+		const name = model.name;
+		const isRoot = model.key.startsWith("#root:");
+		const location = model.location ?? use?.locate();
+		let problem;
+		if (!isGraphQLName(name)) problem = `'${name}' is not a valid GraphQL type name`;
+		else if (!isRoot && ROOT_NAMES.has(name)) problem = `'${name}' is the name of a root operation type`;
+		else if (SPECIFIED_SCALARS.has(name)) problem = `'${name}' is the name of a specified GraphQL scalar`;
+		if (problem !== void 0) {
+			this.#reportOnce(`name\0${model.key}`, {
+				code: Codes.NameConflict,
+				severity: "error",
+				message: `${problem} (${model.key.startsWith("#") ? name : model.key})`,
+				...location === void 0 ? {} : { location },
+				related: use === void 0 ? [] : reachedFrom(use),
+				hints: [isGraphQLName(name) ? "Rename the declaration, or name it with /** @gqlName OtherName */" : NAME_HINT]
+			});
+			return false;
+		}
+		const existing = this.#types.get(name);
+		if (existing === void 0) {
+			this.#types.set(name, model);
+			return true;
+		}
+		if (existing === model) return true;
+		const pair = [existing.key, model.key].sort(compareStrings).join("\0");
+		this.#reportOnce(`conflict\0${pair}`, {
+			code: Codes.NameConflict,
+			severity: "error",
+			message: `Two types are named '${name}' in the GraphQL schema: ${describeKey(model)} and ${describeKey(existing)}`,
+			...location === void 0 ? {} : { location },
+			related: [...existing.location === void 0 ? [] : [{
+				message: "the other declaration",
+				location: existing.location
+			}], ...use === void 0 ? [] : reachedFrom(use)],
+			hints: ["Rename one of them, or name one with /** @gqlName OtherName */"]
+		});
+		return false;
+	}
+	/** A model met again: its reference, unless its name was refused (already reported). */
+	#known(model) {
+		return this.#types.get(model.name) === model ? refTo(model.name) : void 0;
+	}
+	/** A TypeScript `enum`: names = member names, internal values = member values. */
+	#enum(named, use) {
+		const existing = this.#models.get(named.key);
+		if (existing !== void 0) return this.#known(existing);
+		const name = this.#typeName(named, use);
+		if (name === void 0) return void 0;
+		const members = named.enumMembers;
+		if (members === void 0 || members.length === 0) return this.#fail(Codes.InvalidType, use, `The values of the enum ${named.name} cannot be evaluated (${use.coordinate})`, ["Use literal member values (A = \"a\", B = 1)"]);
+		const values = [];
+		for (const member of members) {
+			if (!this.#checkEnumValueName(member.name, named, member.location, use)) continue;
+			values.push({
+				name: member.name,
+				value: member.value,
+				description: descriptionOf(member.doc),
+				deprecationReason: deprecationOf(member.doc)
+			});
+		}
+		return this.#registerEnum(named, name, values, use);
+	}
+	/** A named alias of a union of string literals: names = values = the literals, in source order. */
+	#literalEnum(named, members, use) {
+		const existing = this.#models.get(named.key);
+		if (existing !== void 0) return this.#known(existing);
+		const literals = named.literals ?? members.map((member) => member.value);
+		if (!literals.every((value) => typeof value === "string")) return this.#fail(Codes.InvalidType, use, `Cannot map ${named.name} (${literals.map((value) => JSON.stringify(value)).join(" | ")}) to a GraphQL type (${use.coordinate}): only unions of string literals are enums`, ["Declare a TypeScript enum (enum Level { Low = 1, High = 2 }), or use Int"]);
+		const name = this.#typeName(named, use);
+		if (name === void 0) return void 0;
+		const values = [];
+		for (const literal of literals) {
+			if (!this.#checkEnumValueName(literal, named, named.location, use)) continue;
+			values.push({
+				name: literal,
+				value: literal,
+				description: void 0,
+				deprecationReason: void 0
+			});
+		}
+		return this.#registerEnum(named, name, values, use);
+	}
+	#checkEnumValueName(value, named, location, use) {
+		if (isGraphQLName(value) && !RESERVED_ENUM_VALUES.has(value)) return true;
+		this.#reportOnce(`enum\0${named.key}\0${value}`, {
+			code: Codes.NameConflict,
+			severity: "error",
+			message: `'${value}' of ${named.name} is not a valid GraphQL enum value`,
+			location,
+			related: reachedFrom(use),
+			hints: [`${NAME_HINT}; true, false and null are reserved`]
+		});
+		return false;
+	}
+	#registerEnum(named, name, values, use) {
+		const model = {
+			kind: "enum",
+			name,
+			key: named.key,
+			description: descriptionOf(named.doc),
+			location: named.location,
+			values
+		};
+		this.#models.set(named.key, model);
+		if (!this.#claim(model, use)) return void 0;
+		return refTo(name);
+	}
+	/** A named alias of a union of object types (output only), with its runtime discriminator. */
+	#union(alias, members, use) {
+		if (use.position === "input") return this.#fail(Codes.InvalidInput, use, `${use.coordinate} is the union ${alias.name}: unions cannot be input values`, ["Declare one input type with optional fields, or one argument per case"]);
+		const existing = this.#models.get(alias.key);
+		if (existing !== void 0) return this.#known(existing);
+		const name = this.#typeName(alias, use);
+		if (name === void 0) return void 0;
+		const model = {
+			kind: "union",
+			name,
+			key: alias.key,
+			description: descriptionOf(alias.doc),
+			location: alias.location,
+			members: [],
+			discriminator: void 0
+		};
+		this.#models.set(alias.key, model);
+		if (!this.#claim(model, use)) return void 0;
+		const trail = `${use.trail} → ${name}`;
+		const objects = [];
+		let failed = false;
+		for (const member of members) {
+			const memberUse = {
+				...use,
+				coordinate: name,
+				trail,
+				reached: trail,
+				locate: () => alias.location
+			};
+			const converted = this.#inner(member, memberUse);
+			if (converted === void 0) {
+				failed = true;
+				continue;
+			}
+			const target = converted.ref.kind === "named" ? this.#types.get(converted.ref.name) : void 0;
+			if (target?.kind !== "object") {
+				failed = true;
+				this.#fail(Codes.InvalidType, memberUse, `The union ${name} contains ${describeShape(member)}, which is not an object type`, ["GraphQL unions only contain object types"]);
+				continue;
+			}
+			if (!objects.includes(target)) objects.push(target);
+		}
+		objects.sort((a, b) => compareStrings(a.name, b.name));
+		model.members = objects.map((object) => object.name);
+		if (!failed) model.discriminator = this.#discriminator(model, objects);
+		return refTo(name);
+	}
+	/**
+	* How the runtime tells the members apart (§5.7): `instanceof` when every member is an exported
+	* class, a `__typename` property, a literal property with a distinct value per member, else
+	* ZNIGHT064.
+	*/
+	#discriminator(union, members) {
+		const found = discriminatorOf(members, (identity) => this.#ctx.classInfo(identity));
+		if (found !== void 0) return found;
+		const names = members.map((member) => member.name);
+		const one = names.length === 1;
+		const listed = one ? names[0] : `${names.slice(0, -1).join(", ")} and ${names.at(-1)}`;
+		const allClasses = members.every((member) => member.classIdentity !== void 0);
+		let why;
+		if (allClasses) why = one ? "is a class that is not exported" : "are classes that are not all exported";
+		else why = one ? "has no literal property" : "have no common literal property";
+		this.#report({
+			code: Codes.UnresolvableAbstractType,
+			severity: "error",
+			message: `The members of union ${union.name} cannot be told apart at runtime: ${listed} ${why}`,
+			...union.location === void 0 ? {} : { location: union.location },
+			hints: [allClasses ? "Export the member classes: the generated module imports them for instanceof" : `Add a literal property to each member (${members.map((member) => `readonly kind: '${lowerFirst(member.name)}'`).join(" / ")}), or make the members classes`]
+		});
+	}
+	/** Defaults (`@default`, parameter defaults) against their types (ZNIGHT063), as external values. */
+	#checkDefaults() {
+		for (const pending of this.#defaults) {
+			const result = externalValue(pending.value, pending.target.ref, this.#types);
+			if ("error" in result) {
+				const location = pending.location ?? pending.use.locate();
+				this.#report({
+					code: Codes.InvalidInput,
+					severity: "error",
+					message: `Invalid default value ${describeValue(pending.value)} for ${pending.use.coordinate} (${pending.target.type}): ${result.error}`,
+					...location === void 0 ? {} : { location },
+					related: reachedFrom(pending.use),
+					hints: ["Defaults are JSON values of the argument type (enum values as their member value or name)"]
+				});
+				continue;
+			}
+			pending.target.defaultValue = result.value;
+			if (pending.target.ref.nonNull) pending.target.nullAsUndefined = false;
+		}
+	}
+	/** GraphQL forbids a cycle of non-null input fields (ZNIGHT063). */
+	#checkInputCycles() {
+		const inputs = [...this.#models.values()].filter((model) => model.kind === "input").sort((a, b) => compareStrings(a.name, b.name));
+		const state = /* @__PURE__ */ new Map();
+		const stack = [];
+		const visit = (model) => {
+			state.set(model.name, "visiting");
+			stack.push(model.name);
+			for (const field of model.fields) {
+				if (field.ref.kind !== "named" || !field.ref.nonNull) continue;
+				const target = this.#types.get(field.ref.name);
+				if (target?.kind !== "input") continue;
+				const status = state.get(target.name);
+				if (status === "visiting") {
+					const cycle = [...stack.slice(stack.indexOf(target.name)), target.name];
+					this.#report({
+						code: Codes.InvalidInput,
+						severity: "error",
+						message: `The input types ${cycle.join(" → ")} reference each other through non-null fields: no value can be written`,
+						...target.location === void 0 ? {} : { location: target.location },
+						hints: ["Make one of the fields of the cycle optional (?: T) or a list"]
+					});
+				} else if (status === void 0) visit(target);
+			}
+			stack.pop();
+			state.set(model.name, "done");
+		};
+		for (const model of inputs) if (!state.has(model.name)) visit(model);
+	}
+	#assemble(roots, resolvers) {
+		const types = [...this.#types.values()].sort((a, b) => compareStrings(a.name, b.name));
+		const meta = [];
+		for (const resolver of resolvers) for (const field of resolver.fields) meta.push(...field.meta);
+		const rootNames = {
+			query: ROOT_TYPE_NAMES.query,
+			...roots.has("mutation") ? { mutation: ROOT_TYPE_NAMES.mutation } : {},
+			...roots.has("subscription") ? { subscription: ROOT_TYPE_NAMES.subscription } : {}
+		};
+		const sdl = printSdl({
+			roots: rootNames,
+			types: types.map(sdlType)
+		});
+		return {
+			roots: rootNames,
+			types,
+			meta,
+			sdl,
+			schemaHash: schemaHash(sdl)
+		};
+	}
+};
+/** A (nullable, until `#convert` decides) reference to a named type. */
+function refTo(name) {
+	return {
+		ref: {
+			kind: "named",
+			name,
+			nonNull: false
+		},
+		nullable: false
+	};
+}
+function reachedFrom(use) {
+	return use.reached === void 0 || use.root === void 0 ? [] : [{
+		message: `reached from ${use.reached}`,
+		location: use.root
+	}];
+}
+function decoratorName(operation) {
+	return ROOT_TYPE_NAMES[operation];
+}
+function describeKey(model) {
+	return model.key.startsWith("#") ? `the ${model.kind} ${model.name}` : model.key;
+}
+/** Short description of a shape for messages (`string`, `Book`, `Map<string, number>`). */
+function describeShape(shape) {
+	switch (shape.kind) {
+		case "literal": return JSON.stringify(shape.value);
+		case "named": return shape.key.slice(shape.key.indexOf("#") + 1);
+		case "reference": return shape.name;
+		case "opaque": return shape.text;
+		case "array": return `${describeShape(shape.items)}[]`;
+		case "union": return shape.members.map(describeShape).join(" | ");
+		case "object": return "an object literal type";
+		default: return shape.kind;
+	}
+}
+function describeValue(value) {
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+function containsRef(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (Array.isArray(value)) return value.some(containsRef);
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) return true;
+	return Object.values(value).some(containsRef);
+}
+function lowerFirst(text) {
+	return `${text.charAt(0).toLowerCase()}${text.slice(1)}`;
+}
+// src/compiler/generate.ts
+/** Module of `isThenable` (a required peer of `@znight/graphql`). */
+const HTTP_MODULE = "@znight/http";
+/** Builds the graphql section; `undefined` (no section) when the application has no resolver. */
+function generateGraphQL(ctx, model, options) {
+	if (model === void 0) return void 0;
+	if (options.sdl !== false) ctx.emitFile(options.sdl, `${model.sdl}\n`);
+	const imports = createImports(ctx);
+	const entries = [
+		["version", ctx.lit(1)],
+		["schemaHash", model.schemaHash],
+		["roots", ctx.obj(Object.entries(model.roots))],
+		["types", ctx.arr(model.types.map((type) => typeNode(ctx, imports, type)))]
+	];
+	const groups = groupsNode(ctx, model.meta);
+	if (groups !== void 0) entries.push(["groups", groups]);
+	return ctx.obj(entries);
+}
+function createImports(ctx) {
+	let args;
+	let context;
+	let info;
+	let validateArgs;
+	let isThenable;
+	const hosts = /* @__PURE__ */ new Map();
+	return {
+		argsType: () => {
+			args ??= ctx.importFrom(RUNTIME_MODULE, "GraphQLArgs", { type: true });
+			return args;
+		},
+		contextType: () => {
+			context ??= ctx.importFrom(RUNTIME_MODULE, "GraphQLContext", { type: true });
+			return context;
+		},
+		infoType: () => {
+			info ??= ctx.importFrom("graphql", "GraphQLResolveInfo", { type: true });
+			return info;
+		},
+		validateArgs: () => {
+			validateArgs ??= ctx.importFrom(RUNTIME_MODULE, "validateArgs");
+			return validateArgs;
+		},
+		isThenable: () => {
+			isThenable ??= ctx.importFrom(HTTP_MODULE, "isThenable");
+			return isThenable;
+		},
+		hostType: (identity) => {
+			let node = hosts.get(identity);
+			if (node === void 0) {
+				node = ctx.importType(identity);
+				hosts.set(identity, node);
+			}
+			return node;
+		}
+	};
+}
+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":
+		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]];
+			if (value.description !== void 0) entries.push(["description", value.description]);
+			if (value.deprecationReason !== void 0) entries.push(["deprecationReason", value.deprecationReason]);
+			return ctx.obj(entries);
+		}))]]);
+		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]);
+	if (field.deprecationReason !== void 0) entries.push(["deprecationReason", field.deprecationReason]);
+	if (field.args.length > 0) entries.push(["args", ctx.arr(field.args.map((arg) => inputValueNode(ctx, arg)))]);
+	if (field.binding !== void 0) entries.push(["resolver", resolverNode(ctx, imports, field.binding.resolver, field.binding.field)]);
+	return ctx.obj(entries);
+}
+function inputValueNode(ctx, arg) {
+	const entries = [["name", arg.name], ["type", arg.type]];
+	if (arg.description !== void 0) entries.push(["description", arg.description]);
+	if (arg.deprecationReason !== void 0) entries.push(["deprecationReason", arg.deprecationReason]);
+	if (arg.defaultValue !== void 0) entries.push(["defaultValue", ctx.lit(arg.defaultValue)]);
+	if (arg.nullAsUndefined) entries.push(["nullAsUndefined", ctx.lit(true)]);
+	return ctx.obj(entries);
+}
+function resolverNode(ctx, imports, resolver, field) {
+	const guards = [...resolver.guards, ...field.guards].map((ref) => ctx.tokenOf(ref) ?? ref.token);
+	const entries = [
+		["token", ctx.tokenOf(resolver.host) ?? resolver.host.identity],
+		["method", field.method],
+		["operation", field.operation],
+		["guards", ctx.lit(guards)],
+		["meta", ctx.obj(field.meta.map((entry) => [entry.key, ctx.lit(entry.value)]))]
+	];
+	const loaders = field.params.flatMap((param) => param?.kind === "loader" ? [loaderToken(ctx, param)] : []);
+	if (loaders.length > 0) entries.push(["loaders", ctx.lit(loaders)]);
+	entries.push(["invoke", invokeNode(ctx, imports, resolver, field)]);
+	return ctx.obj(entries);
+}
+/** The provider token a loader parameter is bound to. */
+function loaderToken(ctx, param) {
+	const ref = ctx.binding(param.binding);
+	if (typeof ref === "string") return ref;
+	if (ref !== void 0 && "token" in ref) return ref.token;
+	return param.identity;
+}
+/** Which `invoke` parameters a field uses: `(r, p, a, c, i)`. */
+function usedParameters(field) {
+	let p = false;
+	let a = false;
+	let c = false;
+	let i = false;
+	for (const param of field.params) switch (param?.kind) {
+		case "parent":
+			p = true;
+			break;
+		case "args":
+			a = true;
+			break;
+		case "ctx":
+		case "loader":
+			c = true;
+			break;
+		case "info": i = true;
+	}
+	return [
+		p,
+		a,
+		c,
+		i
+	];
+}
+/**
+* `(r: Resolver, p: unknown, a: GraphQLArgs, c: GraphQLContext, i: GraphQLResolveInfo) => r.m(...)`:
+* unused middle parameters are `_`-prefixed, trailing ones omitted (`noUnusedParameters`).
+*/
+function invokeNode(ctx, imports, resolver, field) {
+	const used = usedParameters(field);
+	const last = used.lastIndexOf(true);
+	const types = [
+		() => ctx.code`unknown`,
+		imports.argsType,
+		imports.contextType,
+		imports.infoType
+	];
+	const names = [
+		"p",
+		"a",
+		"c",
+		"i"
+	];
+	const params = [["r", imports.hostType(resolver.host.identity)]];
+	for (let index = 0; index <= last; index++) params.push([`${used[index] ? "" : "_"}${names[index]}`, types[index]()]);
+	const validated = field.params.flatMap((param, index) => param?.kind === "args" && param.schema !== void 0 ? [index] : []);
+	return ctx.arrow(params, (r, ...rest) => {
+		const [p, a, c, i] = rest;
+		const scope = {
+			p,
+			a,
+			c,
+			i
+		};
+		if (validated.length === 0) return call(ctx, r, field, (index) => argument(ctx, scope, field, index));
+		return validatingBlock(ctx, imports, r, scope, field, validated);
+	});
+}
+/** `r.method(args)`. */
+function call(ctx, r, field, argumentOf) {
+	return ctx.call(ctx.member(r, field.method), field.params.map((_, index) => argumentOf(index)));
+}
+/** The expression passed for the parameter `index` (validation not applied). */
+function argument(ctx, scope, field, index) {
+	const param = field.params[index];
+	switch (param?.kind) {
+		case "parent": return ctx.code`${scope.p} as never`;
+		case "ctx": return scope.c;
+		case "info": return scope.i;
+		case "loader": return ctx.code`${ctx.call(ctx.member(scope.c, "loader"), [loaderToken(ctx, param)])} as never`;
+		case "args": return ctx.code`${argsValue(ctx, scope, param.name)} as never`;
+		default: return ctx.lit(void 0);
+	}
+}
+/** `a['name']`, or `a` for `@Args()`. */
+function argsValue(ctx, scope, name) {
+	const a = scope.a;
+	return name === void 0 ? a : ctx.code`${a}[${name}]`;
+}
+/** `validateArgs(Schema, a['input'], 'input')`. */
+function validation(ctx, imports, scope, param) {
+	return ctx.call(imports.validateArgs(), [
+		ctx.ref(param.schema),
+		argsValue(ctx, scope, param.name),
+		param.name ?? "args"
+	]);
+}
+/**
+* The body of the `invoke` of a field validating arguments: each validation is evaluated in order
+* into a `const`; while they return values the method is called synchronously, the first thenable
+* resumes in an `async` arrow that awaits it and the later validations (the order of evaluation and
+* the error reported first are those of an `async` invoke awaiting every validation).
+*
+* ```ts
+* (r: BookResolver, _p: unknown, a: GraphQLArgs) => {
+*   const v0 = validateArgs(NewBookInput, a['input'], 'input')
+*   if (isThenable(v0)) return (async () => r.addBook(await v0 as never))()
+*   return r.addBook(v0 as never)
+* }
+* ```
+*/
+function validatingBlock(ctx, imports, r, scope, field, validated) {
+	return ctx.block(validated.map((index) => `v${index}`), (...locals) => {
+		const local = new Map(validated.map((index, position) => [index, locals[position]]));
+		const statements = [];
+		for (const index of validated) {
+			const name = local.get(index);
+			const param = field.params[index];
+			statements.push(ctx.code`const ${name} = ${validation(ctx, imports, scope, param)}`);
+			const resume = ctx.arrow([], () => call(ctx, r, field, (position) => {
+				const value = local.get(position);
+				if (value === void 0) return argument(ctx, scope, field, position);
+				if (position < index) return ctx.code`${value} as never`;
+				if (position === index) return ctx.code`await ${value} as never`;
+				const later = field.params[position];
+				return ctx.code`await ${validation(ctx, imports, scope, later)} as never`;
+			}), { async: true });
+			statements.push(ctx.code`if (${ctx.call(imports.isThenable(), [name])}) return (${resume})()`);
+		}
+		statements.push(ctx.code`return ${call(ctx, r, field, (position) => {
+			const value = local.get(position);
+			return value === void 0 ? argument(ctx, scope, field, position) : ctx.code`${value} as never`;
+		})}`);
+		return statements;
+	});
+}
+/**
+* `groups`: the route decorator groups the runtime needs (required, holding several keys, or named
+* differently from their key), sorted; `undefined` when there is none (RFC 0001, as `extensions.http`).
+*/
+function groupsNode(ctx, meta) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const entry of meta) {
+		const group = groups.get(entry.group);
+		if (group === void 0) groups.set(entry.group, {
+			keys: /* @__PURE__ */ new Set([entry.key]),
+			required: entry.required
+		});
+		else {
+			group.keys.add(entry.key);
+			group.required ||= entry.required;
+		}
+	}
+	const needed = [...groups].filter(([name, group]) => group.required || group.keys.size > 1 || !group.keys.has(name)).sort(([a], [b]) => compareStrings(a, b));
+	if (needed.length === 0) return void 0;
+	return ctx.obj(needed.map(([name, group]) => [name, ctx.obj([["keys", ctx.lit([...group.keys].sort(compareStrings))], ["required", group.required]])]));
+}
+// src/compiler/options.ts
+/** The defaults. */
+const DEFAULT_OPTIONS = Object.freeze({
+	sdl: false,
+	number: "Float",
+	schema: false
+});
+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?, 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,
+		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"],
+	params: ["static"]
+};
+const NO_ARGUMENT = {
+	targets: ["parameter"],
+	params: []
+};
+/** Decorators owned by the extension, by canonical identity (static / value arguments, §4.6). */
+const decorators = Object.freeze({
+	[GraphQLIds.Resolver]: {
+		targets: ["class"],
+		params: ["static", "static"]
+	},
+	[GraphQLIds.Query]: FIELD,
+	[GraphQLIds.Mutation]: FIELD,
+	[GraphQLIds.Subscription]: FIELD,
+	[GraphQLIds.ResolveField]: FIELD,
+	[GraphQLIds.Args]: {
+		targets: ["parameter"],
+		params: ["value", "value"]
+	},
+	[GraphQLIds.Parent]: NO_ARGUMENT,
+	[GraphQLIds.Ctx]: NO_ARGUMENT,
+	[GraphQLIds.Info]: NO_ARGUMENT,
+	[GraphQLIds.Loader]: NO_ARGUMENT,
+	[GraphQLIds.UseGuard]: {
+		targets: ["class", "method"],
+		params: [],
+		rest: "value"
+	}
+});
+function createExtension(options) {
+	/**
+	* Models by compile, built by `validate`, read by `generate`. The key is `graph.extensions`: the
+	* validate and generate contexts of one compile get different graph objects sharing this array.
+	*/
+	const models = /* @__PURE__ */ new WeakMap();
+	const modelOf = (graph) => models.get(graph.extensions);
+	return Object.freeze({
+		apiVersion: 1,
+		name: EXTENSION_NAME,
+		decorators,
+		options,
+		analyzeClass: (cls, ctx) => analyzeGraphQLClass(cls, ctx, options),
+		validate(ctx) {
+			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);
+		},
+		configure(next) {
+			return createExtension(resolveOptions(options, next));
+		}
+	});
+}
+/** The `@znight/graphql` compiler extension with its default options. */
+const graphqlCompilerExtension = createExtension(DEFAULT_OPTIONS);
+export { graphqlCompilerExtension as default, graphqlCompilerExtension };
+
+//# sourceMappingURL=compiler.mjs.map