@znight/graphql 0.0.0-stage → 0.2.0

package/dist/compiler.mjs

@@ -0,0 +1,2832 @@
+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 { 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"
+});
+/** 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). */
+function analyzeGraphQLClass(cls, ctx) {
+	const resolvers = cls.decorators.filter((decorator) => decorator.identity === GraphQLIds.Resolver);
+	const resolver = resolvers[0];
+	if (resolver === void 0) {
+		reportOutsideResolver(cls, ctx);
+		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
+		}]);
+		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"]);
+		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"]);
+		return;
+	}
+	const scope = resolverScope(ctx, resolver);
+	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));
+	}
+	ctx.store({
+		kind: "resolver",
+		host: cls,
+		scope,
+		location: resolver.location,
+		guards: classGuards,
+		fields
+	});
+}
+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({ scope })`. */
+function resolverScope(ctx, decorator) {
+	const arg = decorator.args[0];
+	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) {
+	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) {
+			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": return `${head}type ${type.name}${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
+		};
+	}
+};
+/** 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/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;
+}
+// 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": return {
+			kind: "object",
+			name: model.name,
+			...base,
+			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) {
+		this.#checkLoaders(resolvers);
+		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();
+		this.#checkDecisions(resolvers);
+		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: []
+			};
+			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"]);
+	}
+	/** `Loader<L>`: `L` must be a loader provider, implementing `BatchLoad<K, V>` (ZNIGHT065). */
+	#checkLoaders(resolvers) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const resolver of resolvers) for (const field of resolver.fields) for (const param of field.params) {
+			if (param?.kind !== "loader" || seen.has(param.binding.id)) continue;
+			seen.add(param.binding.id);
+			const token = tokenOfRef(this.#ctx.binding(param.binding));
+			const provider = token === void 0 ? void 0 : this.#ctx.provider(token);
+			if (provider === void 0 || provider.heritage.some((type) => type.identity === GraphQLIds.BatchLoad)) continue;
+			if (provider.kind !== "class" || hasLoadMethod(this.#ctx, provider.classIdentity)) continue;
+			this.#report({
+				code: Codes.InvalidLoader,
+				severity: "error",
+				message: `${provider.displayName} is not a loader: Loader<${provider.displayName}> needs a provider implementing BatchLoad<K, V> (${resolver.host.displayName}.${field.method})`,
+				location: param.location,
+				hints: [`export class ${provider.displayName} implements BatchLoad<ID, Value> { async load(keys: readonly ID[]): Promise<readonly (Value | Error)[]> { ... } }`]
+			});
+		}
+	}
+	#indexFieldResolvers(resolvers) {
+		for (const resolver of resolvers) for (const field of resolver.fields) {
+			if (field.operation !== "field" || !field.complete) continue;
+			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))
+		};
+		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);
+	}
+	/** RFC 0001: every root field decides every required route decorator group (ZNIGHT023). */
+	#checkDecisions(resolvers) {
+		const applied = [];
+		for (const resolver of resolvers) for (const field of resolver.fields) applied.push(...field.meta);
+		const required = requiredRouteGroups(this.#ctx, applied);
+		if (required.length === 0) return;
+		for (const resolver of resolvers) for (const field of resolver.fields) {
+			if (field.operation === "field") continue;
+			const decided = new Set(field.meta.map((entry) => entry.group));
+			for (const group of required) {
+				if (decided.has(group.group)) continue;
+				const root = ROOT_TYPE_NAMES[field.operation];
+				this.#report({
+					code: Codes.MissingRouteDecision,
+					severity: "error",
+					message: `Root field ${root}.${field.name} (${resolver.host.displayName}.${field.method}) has no "${group.group}" decision`,
+					location: field.methodLocation,
+					hints: [`Add ${group.suggestion} to the method or to ${resolver.host.displayName}`],
+					related: [{
+						message: `The "${group.group}" group is required`,
+						location: group.decorators[0].definition
+					}]
+				});
+			}
+		}
+	}
+	#assemble(roots, resolvers) {
+		const types = [...this.#types.values()].sort((a, b) => compareStrings(a.name, b.name));
+		const meta = [];
+		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)
+		};
+	}
+};
+/** The class (or one of its base classes) declares an instance `load` method. */
+function hasLoadMethod(ctx, identity) {
+	const seen = /* @__PURE__ */ new Set();
+	let current = identity;
+	while (current !== void 0 && !seen.has(current)) {
+		seen.add(current);
+		const cls = ctx.classInfo(current);
+		if (cls === void 0) return true;
+		if (cls.methods.some((method) => method.name === "load" && method.kind === "method" && !method.static)) return true;
+		if (cls.properties.some((property) => property.name === "load" && !property.static)) return true;
+		current = cls.superClass?.identity;
+	}
+	return false;
+}
+/** A (nullable, until `#convert` decides) reference to a named type. */
+function refTo(name) {
+	return {
+		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];
+}
+/** The token of a binding result (`undefined` when binding failed). */
+function tokenOfRef(ref) {
+	if (typeof ref === "string") return ref;
+	return ref !== void 0 && "token" in ref ? ref.token : void 0;
+}
+function describeKey(model) {
+	return model.key.startsWith("#") ? `the ${model.kind} ${model.name}` : model.key;
+}
+/** 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": return ctx.obj([...head, ["fields", ctx.arr(type.fields.map((field) => fieldNode(ctx, imports, field)))]]);
+		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": {
+			const discriminator = type.discriminator;
+			let node;
+			if (discriminator === void 0 || discriminator.by === "typename") node = ctx.obj([["by", "typename"]]);
+			else if (discriminator.by === "property") node = ctx.obj([
+				["by", "property"],
+				["property", discriminator.property],
+				["values", ctx.obj(Object.entries(discriminator.values))]
+			]);
+			else node = ctx.obj([["by", "class"], ["classes", ctx.arr(discriminator.classes.map((entry) => ctx.arr([ctx.importValue(entry.identity), entry.name])))]]);
+			return ctx.obj([
+				...head,
+				["members", ctx.lit([...type.members])],
+				["discriminator", node]
+			]);
+		}
+		case "scalar": return type.definition === void 0 ? ctx.obj([...head, ["builtin", ctx.lit(true)]]) : ctx.obj([...head, ["scalar", ctx.importValue(type.definition)]]);
+	}
+}
+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"
+});
+const KNOWN = /* @__PURE__ */ new Set(["sdl", "number"]);
+/**
+* Merges `options` onto `base`. Throws a `TypeError` naming the option on an invalid value: options
+* are written in `znight.config.ts`, the error surfaces when the configuration is loaded.
+*/
+function resolveOptions(base, options) {
+	if (typeof options !== "object" || options === null || Array.isArray(options)) throw new TypeError("[znight] graphql.configure() expects an options object: { sdl?, number? }");
+	for (const key of Object.keys(options)) if (!KNOWN.has(key)) throw new TypeError(`[znight] graphql.configure(): unknown option "${key}" (options: sdl, number)`);
+	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
+	});
+}
+// 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"]
+	},
+	[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: analyzeGraphQLClass,
+		validate(ctx) {
+			models.set(ctx.graph.extensions, buildModel(ctx, options));
+		},
+		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