@znight/graphql 0.2.2 → 0.4.0

package/dist/{plugin-CR_wVfRU.mjs → plugin-BssB7wtn.mjs}

@@ -1,53 +1,9 @@
+import { c as singleResult, d as resolveIn, f as GraphQLErrorCode, l as GraphQLTokens, n as checkSseOptions, p as GraphQLException, s as GraphQLExecutor, t as HttpTransport, u as ErrorFormatter } from "./http-BWcayUtH.mjs";
 import { a as SPECIFIED_SCALARS, o as isGraphQLName, r as RESERVED_ENUM_VALUES, s as parseTypeRef, t as BUILTIN_SCALARS } from "./names-BlzDM5cF.mjs";
 import { ErrorCode, ZnightError, displayName, resolveOptions } from "@znight/core";
 import DataLoader from "dataloader";
-import { EventChannel, HttpResponse, HttpTokens, ValidationException, isHttpException, isThenable, parseByteSize, parseMediaType } from "@znight/http";
-import { AbortedGraphQLExecutionError, GraphQLBoolean, GraphQLEnumType, GraphQLError, GraphQLFloat, GraphQLID, GraphQLInputObjectType, GraphQLInt, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLSchema, GraphQLString, GraphQLUnionType, Kind, NoSchemaIntrospectionCustomRule, createSourceEventStream, execute, executeSubscriptionEvent, getNamedType, isObjectType, parse, printSchema, specifiedRules, validate, validateSchema, validateSubscriptionArgs, valueFromASTUntyped } from "graphql";
-import { createHash, randomUUID } from "node:crypto";
-// src/errors.ts
-/**
-* GraphQL errors shown to clients (RFC 0005 §5.10, §8.8): `GraphQLException` and the
-* `extensions.code` values the plugin produces (Apollo conventions, which clients already know).
-*
-* Import-free: the exception is a plain `Error` subclass, rendered by the runtime as
-* `{ message, locations, path, extensions: { code, ...extensions } }`.
-*/
-/** `extensions.code` values produced by `@znight/graphql`. Applications may use their own codes too. */
-const GraphQLErrorCode = Object.freeze({
-	ParseFailed: "GRAPHQL_PARSE_FAILED",
-	ValidationFailed: "GRAPHQL_VALIDATION_FAILED",
-	BadUserInput: "BAD_USER_INPUT",
-	QueryTooComplex: "QUERY_TOO_COMPLEX",
-	Unauthenticated: "UNAUTHENTICATED",
-	Forbidden: "FORBIDDEN",
-	NotFound: "NOT_FOUND",
-	Conflict: "CONFLICT",
-	TooManyRequests: "TOO_MANY_REQUESTS",
-	BadRequest: "BAD_REQUEST",
-	SubscriptionOverflow: "SUBSCRIPTION_OVERFLOW",
-	ServiceUnavailable: "SERVICE_UNAVAILABLE",
-	InternalServerError: "INTERNAL_SERVER_ERROR"
-});
-/**
-* An error whose message and extensions are sent to the client as they are (§5.10): throw it from a
-* resolver or return it from a `GraphQLErrorMapper`.
-*
-* ```ts
-* throw new GraphQLException(`No book ${id}`, { code: 'NOT_FOUND', extensions: { bookId: id } })
-* ```
-*/
-var GraphQLException = class extends Error {
-	/** `extensions.code`. */
-	code;
-	/** Extra `extensions` entries. */
-	extensions;
-	constructor(message, options) {
-		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
-		this.name = "GraphQLException";
-		this.code = options.code;
-		this.extensions = options.extensions;
-	}
-};
+import { EventChannel, isThenable, parseByteSize } from "@znight/http";
+import { GraphQLBoolean, GraphQLEnumType, GraphQLFloat, GraphQLID, GraphQLInputObjectType, GraphQLInt, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLSchema, GraphQLString, GraphQLUnionType, Kind, printSchema, validateSchema, valueFromASTUntyped } from "graphql";
 // src/loaders.ts
 /**
 * Creates the per-execution DataLoaders of loader providers: the provider is resolved in the
@@ -310,11 +266,11 @@ function checkFieldDecisions(fields, groups, mode, logger) {
 		const members = [...keys].filter(([, info]) => info.group === group).map(([key]) => key).sort();
 		const parts = [];
 		if (entry.missing.length > 0) {
-			parts.push(`${count$1(entry.missing.length)} ${entry.missing.length === 1 ? "has" : "have"} no "${group}" decision: ${entry.missing.join(", ")}`);
+			parts.push(`${count(entry.missing.length)} ${entry.missing.length === 1 ? "has" : "have"} no "${group}" decision: ${entry.missing.join(", ")}`);
 			hints.push(`Add a decision of the "${group}" group (${members.join(", ") || group}) to the resolver method or to its class`);
 		}
 		if (entry.unenforced.length > 0) {
-			parts.push(`no guard enforces the "${group}" group on ${count$1(entry.unenforced.length)}: ${entry.unenforced.join(", ")}`);
+			parts.push(`no guard enforces the "${group}" group on ${count(entry.unenforced.length)}: ${entry.unenforced.join(", ")}`);
 			hints.push(`Register a GraphQL guard declaring \`static enforces\` with the decorators of the "${group}" group: GraphQLPlugin.configure({ guards: [...] }) or @UseGuard(...)`);
 		}
 		const message = parts.join("; ");
@@ -330,1130 +286,40 @@ function checkFieldDecisions(fields, groups, mode, logger) {
 		throw new ZnightError(ErrorCode.MissingRouteDecision, `GraphQLPlugin: ${text.charAt(0).toUpperCase()}${text.slice(1)}`, { hints });
 	}
 }
-function count$1(fields) {
+function count(fields) {
 	return fields === 1 ? "1 field" : `${fields} fields`;
 }
-// src/context.ts
-const NO_VARIABLES = Object.freeze({});
-/**
-* The `GraphQLContext` of one operation. Built from references the executor already holds (the
-* operation node, the request, the options, the enclosing scope): one allocation per operation,
-* every field read on demand.
-*/
-var OperationContext = class {
-	document;
-	#runtime;
-	#operation;
-	#request;
-	#options;
-	#scope;
-	#requestId;
-	#http;
-	#signal;
-	#ended;
-	#state;
-	#loaders;
-	constructor(runtime, document, operation, request, options, scope) {
-		this.#runtime = runtime;
-		this.document = document;
-		this.#operation = operation;
-		this.#request = request;
-		this.#options = options;
-		this.#scope = scope;
-		this.#requestId = options.requestId;
-	}
-	get transport() {
-		return this.#options.transport ?? "direct";
-	}
-	get operationType() {
-		return this.#operation.operation;
-	}
-	get operationName() {
-		return this.#operation.name?.value;
-	}
-	get requestId() {
-		let id = this.#requestId;
-		if (id === void 0) {
-			const http = this.http;
-			const scoped = http === void 0 ? this.#scope?.get(HttpTokens.RequestId) : void 0;
-			id = http?.requestId ?? (typeof scoped === "string" ? scoped : randomUUID());
-			this.#requestId = id;
-		}
-		return id;
-	}
-	get http() {
-		let http = this.#http;
-		if (http === void 0) {
-			http = this.#options.http ?? this.#scope?.get(HttpTokens.Context) ?? null;
-			this.#http = http;
-		}
-		return http ?? void 0;
-	}
-	get variables() {
-		return this.#request.variables ?? NO_VARIABLES;
-	}
-	get signal() {
-		let signal = this.#signal;
-		if (signal === void 0) {
-			const base = this.#options.signal ?? this.http?.signal ?? this.#runtime.signal;
-			const ended = this.#ended;
-			signal = ended === void 0 ? base : AbortSignal.any([base, ended]);
-			this.#signal = signal;
-		}
-		return signal;
-	}
-	/**
-	* Ties {@link signal} to the end of a subscription: it also aborts when `ended` does (the stream
-	* ended by itself or with `return()`). Called before any resolver runs.
-	*/
-	endsWith(ended) {
-		this.#ended = ended;
-	}
-	get state() {
-		this.#state ??= /* @__PURE__ */ new Map();
-		return this.#state;
-	}
-	loader(key) {
-		const token = typeof key === "string" ? key : this.#tokenOf(key);
-		let loaders = this.#loaders;
-		if (loaders === void 0) {
-			loaders = /* @__PURE__ */ new Map();
-			this.#loaders = loaders;
-		}
-		let loader = loaders.get(token);
-		if (loader === void 0) {
-			loader = this.#runtime.loaders.create(token);
-			loaders.set(token, loader);
-		}
-		return loader;
-	}
-	/** Starts a new execution (a subscription event): loaders and their caches are renewed. */
-	resetLoaders() {
-		this.#loaders = void 0;
-	}
-	#tokenOf(loader) {
-		const token = typeof loader === "function" ? this.#runtime.container.tokenOf(loader) : void 0;
-		if (token === void 0) {
-			const name = typeof loader === "function" ? loader.name || "<anonymous>" : String(loader);
-			throw new ZnightError(ErrorCode.MissingProvider, `GraphQLContext.loader(): ${name} is not a provider`, { hints: ["Add @Injectable() to the loader class (it implements BatchLoad<K, V>)"] });
-		}
-		return token;
-	}
-};
-// src/format.ts
-/** Resolves a {@link Resolvable} (in the current scope for scoped providers). */
-function resolveIn(container, resolvable) {
-	return resolvable.token === void 0 ? resolvable.instance : container.get(resolvable.token);
-}
-/** Message of masked errors. */
-const MASKED_MESSAGE = "Unexpected error.";
-/** `HttpException` status → `extensions.code` (other 4xx: `BAD_REQUEST`, 5xx: masked). */
-const STATUS_CODES = /* @__PURE__ */ new Map([
-	[400, GraphQLErrorCode.BadUserInput],
-	[401, GraphQLErrorCode.Unauthenticated],
-	[403, GraphQLErrorCode.Forbidden],
-	[404, GraphQLErrorCode.NotFound],
-	[409, GraphQLErrorCode.Conflict],
-	[429, GraphQLErrorCode.TooManyRequests]
-]);
-/** Formats the errors of execution results. One per plugin, built at boot. */
-var ErrorFormatter = class {
-	#container;
-	#mappers;
-	#expose;
-	#logger;
-	#schema;
-	constructor(options) {
-		this.#container = options.container;
-		this.#mappers = options.mappers;
-		this.#expose = options.exposeErrors;
-		this.#logger = options.logger;
-		this.#schema = options.schema;
-	}
-	/** Formats the errors of an executed operation (field errors). */
-	format(errors, ctx) {
-		const result = new Array(errors.length);
-		let logged;
-		for (let index = 0; index < errors.length; index++) {
-			const error = errors[index];
-			const original = error.originalError;
-			if (original === void 0 || original === null) {
-				result[index] = withCode(error, error.extensions["code"] === void 0 ? GraphQLErrorCode.InternalServerError : void 0);
-				continue;
-			}
-			const exposed = this.#exposed(original, ctx);
-			if (exposed !== void 0) {
-				result[index] = render(error, exposed);
-				const cause = exposed.cause;
-				if (cause !== void 0) {
-					logged ??= /* @__PURE__ */ new Set();
-					if (!logged.has(cause)) {
-						logged.add(cause);
-						this.#log(error, cause, ctx, exposed.code);
-					}
-				}
-				continue;
-			}
-			if (original instanceof GraphQLError && !isCompletionError(original)) {
-				result[index] = {
-					...original.toJSON(),
-					...located(error)
-				};
-				continue;
-			}
-			logged ??= /* @__PURE__ */ new Set();
-			if (!logged.has(original)) {
-				logged.add(original);
-				this.#log(error, original, ctx, void 0);
-			}
-			result[index] = {
-				message: this.#expose && original instanceof Error ? original.message : MASKED_MESSAGE,
-				...located(error),
-				extensions: { code: GraphQLErrorCode.InternalServerError }
-			};
-		}
-		return result;
-	}
-	/** The exception shown for `original`, `undefined` when it must be masked. */
-	#exposed(original, ctx) {
-		if (original instanceof GraphQLException) return original;
-		for (const resolvable of this.#mappers) {
-			let mapped;
-			try {
-				mapped = resolveIn(this.#container, resolvable).map(original, ctx);
-			} catch (error) {
-				this.#logger.error("GraphQLPlugin: an error mapper failed", {
-					err: error,
-					requestId: ctx.requestId
-				});
-				continue;
-			}
-			if (mapped !== void 0) return mapped;
-		}
-		if (isHttpException(original)) {
-			const status = original.status;
-			if (original instanceof ValidationException) return new GraphQLException(original.message, {
-				code: GraphQLErrorCode.BadUserInput,
-				extensions: { issues: original.details }
-			});
-			if (status >= 500) return void 0;
-			return new GraphQLException(original.message, { code: STATUS_CODES.get(status) ?? GraphQLErrorCode.BadRequest });
-		}
-	}
-	/** Logs an unexpected error, or the cause of a presented one (`code`), at `error` level. */
-	#log(error, cause, ctx, code) {
-		const coordinate = coordinateOf(this.#schema, ctx.document, ctx.operationName, error.path);
-		const what = code === void 0 ? "unexpected error" : `${code} error`;
-		this.#logger.error(`GraphQL: ${what}${coordinate === void 0 ? "" : ` in ${coordinate}`}`, {
-			err: cause,
-			requestId: ctx.requestId,
-			...code === void 0 ? {} : { code },
-			...coordinate === void 0 ? {} : { coordinate },
-			...error.path === void 0 ? {} : { path: error.path.join(".") }
-		});
-	}
-};
-/**
-* What graphql-js raises while completing a resolver's value: a built-in scalar or an enum that
-* cannot represent it (`String cannot represent value: { passwordHash: ... }`), a list value that
-* is not iterable, a union or interface value that resolves to no member. A server bug whose message
-* holds the value, masked and logged like any unexpected error. graphql-js throws plain
-* `GraphQLError`s without code there, told apart from the ones of user code by their message.
-*/
-const COMPLETION_ERROR = /^(?:(?:Int|Float|String|Boolean|ID) cannot represent |Enum "[^"]*" cannot represent |Expected Iterable, but did not find one for field "|Abstract type "|Runtime Object type ")/;
-function isCompletionError(error) {
-	return error.constructor === GraphQLError && error.extensions["code"] === void 0 && COMPLETION_ERROR.test(error.message);
-}
-function located(error) {
-	return {
-		...error.locations === void 0 ? {} : { locations: error.locations },
-		...error.path === void 0 ? {} : { path: error.path }
-	};
-}
-/** `{ message, locations, path, extensions: { ...extensions, code } }`. */
-function render(error, exception) {
-	return {
-		message: exception.message,
-		...located(error),
-		extensions: {
-			...exception.extensions,
-			code: exception.code
-		}
-	};
-}
-/** A graphql-js error formatted with `extensions.code` set to `code` (kept as is without code). */
-function withCode(error, code) {
-	const formatted = error.toJSON();
-	if (code === void 0) return formatted;
-	return {
-		...formatted,
-		extensions: {
-			...formatted.extensions,
-			code
-		}
-	};
-}
-/** A request error (no location): `{ message, extensions: { code } }`. */
-function requestError(message, code, nodes) {
-	return withCode(new GraphQLError(message, nodes === void 0 ? {} : { nodes }), code);
-}
-/**
-* The schema coordinate (`Book.author`) of the field at `path`, found by walking the operation's
-* selections (aliases, fragments, inline fragments). Best effort, for logs: `undefined` when the
-* path crosses a union without a type condition.
-*/
-function coordinateOf(schema, document, operationName, path) {
-	if (path === void 0 || path.length === 0) return void 0;
-	const fragments = /* @__PURE__ */ new Map();
-	let operation;
-	for (const definition of document.definitions) if (definition.kind === Kind.FRAGMENT_DEFINITION) fragments.set(definition.name.value, definition);
-	else if (definition.kind === Kind.OPERATION_DEFINITION && (operationName === void 0 || definition.name?.value === operationName)) operation ??= definition;
-	if (operation === void 0) return void 0;
-	let type = schema.getRootType(operation.operation);
-	let selections = [operation.selectionSet];
-	let coordinate;
-	for (const segment of path) {
-		if (typeof segment === "number") continue;
-		const found = findField(selections, segment, fragments, type?.name);
-		if (found === void 0 || type === void 0 || type === null) return void 0;
-		const parent = found.typeCondition === void 0 ? type : schema.getType(found.typeCondition);
-		if (!isObjectType(parent)) return void 0;
-		const field = parent.getFields()[found.field.name.value];
-		coordinate = `${parent.name}.${found.field.name.value}`;
-		if (field === void 0) return coordinate;
-		type = getNamedType(field.type);
-		selections = found.field.selectionSet === void 0 ? [] : [found.field.selectionSet];
-	}
-	return coordinate;
-}
-function findField(sets, key, fragments, typeCondition) {
-	for (const set of sets) for (const selection of set.selections) if (selection.kind === Kind.FIELD) {
-		if ((selection.alias ?? selection.name).value === key) return {
-			field: selection,
-			typeCondition
-		};
-	} else {
-		const nested = selection.kind === Kind.INLINE_FRAGMENT ? selection : fragments.get(selection.name.value);
-		if (nested === void 0) continue;
-		const found = findField([nested.selectionSet], key, fragments, nested.typeCondition?.name.value ?? typeCondition);
-		if (found !== void 0) return found;
-	}
-}
-// src/limits.ts
-/** The limit errors of `document` (`QUERY_TOO_COMPLEX`), `undefined` when it is within its limits. */
-function checkLimits(document, limits) {
-	const { maxDepth, maxAliases, maxDirectives } = limits;
-	if (maxDepth === void 0 && maxAliases === void 0 && maxDirectives === void 0) return void 0;
-	const counter = {
-		aliases: 0,
-		directives: 0,
-		spreads: 0
-	};
-	const fragments = /* @__PURE__ */ new Map();
-	for (const definition of document.definitions) if (definition.kind === Kind.FRAGMENT_DEFINITION) fragments.set(definition.name.value, definition);
-	let errors;
-	const fail = (message) => {
-		errors ??= [];
-		errors.push(new GraphQLError(message, { extensions: { code: GraphQLErrorCode.QueryTooComplex } }));
-	};
-	for (const definition of document.definitions) if (definition.kind === Kind.OPERATION_DEFINITION || definition.kind === Kind.FRAGMENT_DEFINITION) {
-		countDirectives(definition.directives, counter);
-		if (definition.kind === Kind.OPERATION_DEFINITION) for (const variable of definition.variableDefinitions ?? []) countDirectives(variable.directives, counter);
-		count(definition.selectionSet, counter);
-	}
-	if (maxAliases !== void 0) {
-		if (counter.aliases > maxAliases) fail(`The document has ${counter.aliases} aliases, more than the limit of ${maxAliases}.`);
-		else if (counter.spreads > 0) {
-			const memo = /* @__PURE__ */ new Map();
-			for (const definition of document.definitions) {
-				if (definition.kind !== Kind.OPERATION_DEFINITION) continue;
-				if (aliasesOf(definition.selectionSet, fragments, memo, /* @__PURE__ */ new Set(), maxAliases + 1) > maxAliases) {
-					fail(`${definition.name === void 0 ? "The operation" : `The operation ${definition.name.value}`} has more than ${maxAliases} aliases once its fragments are expanded.`);
-					break;
-				}
-			}
-		}
-	}
-	if (maxDirectives !== void 0 && counter.directives > maxDirectives) fail(`The document has ${counter.directives} directives, more than the limit of ${maxDirectives}.`);
-	if (maxDepth !== void 0) {
-		const depths = /* @__PURE__ */ new Map();
-		for (const definition of document.definitions) {
-			if (definition.kind !== Kind.OPERATION_DEFINITION) continue;
-			const depth = depthOf(definition.selectionSet, fragments, depths, /* @__PURE__ */ new Set());
-			if (depth > maxDepth) fail(`${definition.name === void 0 ? "The operation" : `The operation ${definition.name.value}`} is ${depth} levels deep, more than the limit of ${maxDepth}.`);
-		}
-	}
-	return errors;
-}
-function countDirectives(directives, counter) {
-	if (directives !== void 0) counter.directives += directives.length;
-}
-function count(set, counter) {
-	for (const selection of set.selections) {
-		countDirectives(selection.directives, counter);
-		if (selection.kind === Kind.FIELD) {
-			if (selection.alias !== void 0) counter.aliases++;
-			if (selection.selectionSet !== void 0) count(selection.selectionSet, counter);
-		} else if (selection.kind === Kind.INLINE_FRAGMENT) count(selection.selectionSet, counter);
-		else counter.spreads++;
-	}
-}
-/**
-* Aliases a selection set executes, fragment spreads expanded (`a: f { ...F } b: f { ...F }` counts
-* the aliases of `F` twice). Fragment counts are memoised, so the walk stays linear in the document;
-* counts saturate at `cap` (one more than the limit) and a fragment cycle counts 0 (validation
-* rejects it).
-*/
-function aliasesOf(set, fragments, memo, visiting, cap) {
-	let total = 0;
-	for (const selection of set.selections) {
-		if (selection.kind === Kind.FIELD) {
-			if (selection.alias !== void 0) total++;
-			if (selection.selectionSet !== void 0) total += aliasesOf(selection.selectionSet, fragments, memo, visiting, cap);
-		} else if (selection.kind === Kind.INLINE_FRAGMENT) total += aliasesOf(selection.selectionSet, fragments, memo, visiting, cap);
-		else {
-			const name = selection.name.value;
-			let known = memo.get(name);
-			if (known === void 0) {
-				const fragment = fragments.get(name);
-				if (fragment === void 0 || visiting.has(name)) continue;
-				visiting.add(name);
-				known = aliasesOf(fragment.selectionSet, fragments, memo, visiting, cap);
-				visiting.delete(name);
-				memo.set(name, known);
-			}
-			total += known;
-		}
-		if (total >= cap) return cap;
-	}
-	return total;
-}
-/**
-* Field nesting of a selection set (`{ a { b } }` is 2). Introspection fields (`__schema`,
-* `__type`) do not count: `MaxIntrospectionDepthRule` bounds them. Fragment depths are memoised; a
-* fragment cycle counts 0 (validation rejects it).
-*/
-function depthOf(set, fragments, depths, visiting) {
-	let max = 0;
-	for (const selection of set.selections) {
-		let depth = 0;
-		if (selection.kind === Kind.FIELD) {
-			if (selection.name.value.startsWith("__")) continue;
-			depth = selection.selectionSet === void 0 ? 1 : 1 + depthOf(selection.selectionSet, fragments, depths, visiting);
-		} else if (selection.kind === Kind.INLINE_FRAGMENT) depth = depthOf(selection.selectionSet, fragments, depths, visiting);
-		else {
-			const name = selection.name.value;
-			const known = depths.get(name);
-			if (known === void 0) {
-				const fragment = fragments.get(name);
-				if (fragment === void 0 || visiting.has(name)) continue;
-				visiting.add(name);
-				depth = depthOf(fragment.selectionSet, fragments, depths, visiting);
-				visiting.delete(name);
-				depths.set(name, depth);
-			} else depth = known;
-		}
-		if (depth > max) max = depth;
-	}
-	return max;
-}
-// src/tokens.ts
-/**
-* Tokens of the values `GraphQLPlugin` supplies to the container (declared in the package
-* manifest). `GraphQLContext` is a request-scoped external: inject it in request-scoped providers
-* or through `Lazy<GraphQLContext>`.
-*/
-const GraphQLTokens = Object.freeze({
-	Context: "@znight/graphql#GraphQLContext",
-	PubSub: "@znight/graphql#PubSub",
-	Plugin: "@znight/graphql#GraphQLPlugin"
-});
-// src/execution.ts
-/**
-* The answer of {@link GraphQLExecutor.execute} to a subscription with
-* {@link ExecuteOptions.streamSubscriptions}: start it with {@link GraphQLExecutor.subscribe}.
-*/
-const SUBSCRIBE = Object.freeze({
-	status: 0,
-	result: Object.freeze({})
-});
-const OPERATION_HOOK = "graphql:operation";
-const DIRECT$1 = Object.freeze({});
-const DONE$1 = Object.freeze({
-	done: true,
-	value: void 0
-});
-/** SHA-256 (hex) of a query text: `GraphQLOperationEvent.documentId`. */
-function documentId(query) {
-	return createHash("sha256").update(query, "utf8").digest("hex");
-}
-/** A parsed and validated document, kept by the document cache. */
-var CachedDocument = class {
-	query;
-	document;
-	/** The operation of a single-operation document. */
-	single;
-	/** Operations by name (documents with several operations). */
-	named;
-	#id;
-	constructor(query, document) {
-		this.query = query;
-		this.document = document;
-		let single;
-		let named;
-		let count = 0;
-		for (const definition of document.definitions) {
-			if (definition.kind !== Kind.OPERATION_DEFINITION) continue;
-			count++;
-			single = definition;
-			if (definition.name !== void 0) {
-				named ??= /* @__PURE__ */ new Map();
-				named.set(definition.name.value, definition);
-			}
-		}
-		this.single = count === 1 ? single : void 0;
-		this.named = named;
-	}
-	/** SHA-256 of the query, computed on first read (only the hook needs it). */
-	get id() {
-		this.#id ??= documentId(this.query);
-		return this.#id;
-	}
-};
-/** A bounded LRU of documents by exact query text. */
-var DocumentCache = class {
-	#max;
-	#entries = /* @__PURE__ */ new Map();
-	#last;
-	constructor(max) {
-		this.#max = max;
-	}
-	get size() {
-		return this.#entries.size;
-	}
-	get(query) {
-		const entry = this.#entries.get(query);
-		if (entry !== void 0 && this.#last !== query) {
-			this.#entries.delete(query);
-			this.#entries.set(query, entry);
-			this.#last = query;
-		}
-		return entry;
-	}
-	set(query, entry) {
-		if (this.#max === 0) return;
-		if (this.#entries.size >= this.#max) {
-			const oldest = this.#entries.keys().next();
-			if (oldest.done !== true) this.#entries.delete(oldest.value);
-		}
-		this.#entries.set(query, entry);
-		this.#last = query;
-	}
-	clear() {
-		this.#entries.clear();
-		this.#last = void 0;
+// src/engine.ts
+/** The engine of a plugin: bound functions over its executor. */
+var Engine = class {
+	schema;
+	settings;
+	rules;
+	parse;
+	validate;
+	execute;
+	subscribe;
+	constructor(executor, settings, driver) {
+		this.schema = executor.schema;
+		this.settings = Object.freeze({ ...settings });
+		this.rules = executor.engineRules;
+		this.parse = (source) => executor.parseDocument(source, driver);
+		this.validate = (schema, document, rules) => executor.validateDocument(schema, document, rules, driver);
+		this.execute = (args, options) => executor.executeDocument(args, executeOptions(args, options, driver));
+		this.subscribe = (args, options) => executor.subscribeDocument(args, executeOptions(args, options, driver));
 	}
 };
-/** A request refused before execution. */
-var Rejection = class {
-	status;
-	errors;
-	operationType;
-	operationName;
-	documentId;
-	headers;
-	constructor(status, errors, documentId, operation, headers) {
-		this.status = status;
-		this.errors = errors;
-		this.documentId = documentId;
-		this.operationType = operation?.operation;
-		this.operationName = operation?.name?.value;
-		this.headers = headers;
-	}
-	response() {
-		return {
-			status: this.status,
-			result: { errors: this.errors },
-			...this.headers === void 0 ? {} : { headers: this.headers }
-		};
-	}
-};
-/** The GraphQL executor of a plugin. */
-var GraphQLExecutor = class {
-	#schema;
-	#container;
-	#hooks;
-	#logger;
-	#formatter;
-	#runtime;
-	#rules;
-	#limits;
-	#maxTokens;
-	#hideSuggestions;
-	#cache;
-	#maxActive;
-	#streams = /* @__PURE__ */ new Set();
-	#direct = /* @__PURE__ */ new Set();
-	/** Subscriptions counted against `maxActive` while their source starts (not yet in `#streams`). */
-	#starting = 0;
-	constructor(options) {
-		this.#schema = options.schema;
-		this.#container = options.container;
-		this.#hooks = options.hooks;
-		this.#logger = options.logger;
-		this.#formatter = options.formatter;
-		this.#runtime = options.runtime;
-		this.#rules = options.introspection ? specifiedRules : [...specifiedRules, NoSchemaIntrospectionCustomRule];
-		this.#limits = options.limits;
-		this.#maxTokens = options.limits.maxTokens;
-		this.#hideSuggestions = !options.introspection;
-		this.#cache = new DocumentCache(options.documentCache);
-		this.#maxActive = options.maxActiveSubscriptions;
-	}
-	/** Active subscriptions (every transport). */
-	get activeSubscriptions() {
-		return this.#streams.size;
-	}
-	/** Documents in the cache. */
-	get cachedDocuments() {
-		return this.#cache.size;
-	}
-	/**
-	* Executes a query or a mutation. Resolves (or returns, when every resolver is synchronous) a
-	* response; rejects only when `options.signal` aborts the execution (with the signal's reason).
-	* A subscription is a 400: it needs {@link subscribe} ({@link SUBSCRIBE} with
-	* `streamSubscriptions`).
-	*/
-	execute(request, options = DIRECT$1) {
-		const prepared = this.#prepare(request, options);
-		if (prepared instanceof Rejection) return this.#reject(prepared, request, options);
-		if (prepared.operation.operation === "subscription") {
-			if (options.streamSubscriptions === true) return SUBSCRIBE;
-			return this.#reject(new Rejection(400, [requestError("Subscriptions are delivered as a stream: send the request with accept: text/event-stream (GraphQL over SSE), or call GraphQLPlugin.subscribe()", GraphQLErrorCode.BadRequest)], prepared.entry.id, prepared.operation), request, options);
-		}
-		const scope = this.#container.currentScope();
-		const ctx = this.#context(prepared, request, options, scope);
-		const hooks = this.#hooks;
-		if (!hooks.hasWrappers(OPERATION_HOOK) && !hooks.hasListeners(OPERATION_HOOK)) return this.#inScope(scope, ctx, () => this.#run(prepared, request, options, ctx));
-		return this.#inScope(scope, ctx, () => this.#observed(ctx, prepared.entry.id, () => this.#run(prepared, request, options, ctx)));
-	}
-	/**
-	* Subscribes: a stream of results, one per source event, or a rejection (status 400, 405 or 503).
-	* A query or a mutation gives a stream of its single result. The stream ends when the source
-	* ends, when `options.signal` aborts, or with `return()`; a source failure ends it with a final
-	* error result (`SUBSCRIPTION_OVERFLOW` for a subscriber that fell behind `MemoryPubSub`).
-	*/
-	async subscribe(request, options = DIRECT$1) {
-		const prepared = this.#prepare(request, options);
-		if (prepared instanceof Rejection) return this.#reject(prepared, request, options);
-		if (prepared.operation.operation !== "subscription") {
-			const response = await this.execute(request, options);
-			return response.status === 200 ? new SingleResultStream(response.result) : response;
-		}
-		const limited = this.#maxActive !== void 0;
-		if (limited && this.#streams.size + this.#starting >= this.#maxActive) return this.#reject(new Rejection(503, [requestError("Too many active subscriptions, retry later", GraphQLErrorCode.ServiceUnavailable)], prepared.entry.id, prepared.operation), request, options);
-		let reserved = limited;
-		if (reserved) this.#starting++;
-		const release = () => {
-			if (reserved) {
-				reserved = false;
-				this.#starting--;
-			}
-		};
-		const outer = this.#container.currentScope();
-		const ctx = this.#context(prepared, request, options, outer);
-		const ended = new AbortController();
-		ctx.endsWith(ended.signal);
-		let run;
-		let close;
-		if (outer === void 0) {
-			const opened = this.#container.openScope([[GraphQLTokens.Context, ctx]]);
-			run = (fn) => opened.run(fn);
-			close = () => {
-				ended.abort();
-				opened.close()?.catch((error) => this.#runtimeLogError("Failed to close the scope of a subscription", error));
-			};
-		} else {
-			outer.set(GraphQLTokens.Context, ctx);
-			run = (fn) => fn();
-			close = () => ended.abort();
-		}
-		const observer = this.#observer(ctx, prepared.entry.id);
-		try {
-			const stream = await run(() => this.#startSubscription(prepared, request, options, ctx, observer, run, close, release));
-			release();
-			if (stream instanceof Rejection) {
-				close();
-				observer?.end("rejected", stream.errors);
-				return stream.response();
-			}
-			return stream;
-		} catch (error) {
-			release();
-			close();
-			observer?.end("error", void 0);
-			throw error;
-		}
-	}
-	/** Ends every subscription started with `transport: 'direct'` (plugin `onStop`). */
-	async stopDirect() {
-		await Promise.all([...this.#direct].map((stream) => stream.return()));
-	}
-	/** Forgets every cached document. */
-	clear() {
-		this.#cache.clear();
-	}
-	/** Request checks, the document (cached, or parsed, limited and validated), the operation. */
-	#prepare(request, options) {
-		const query = request?.query;
-		if (typeof query !== "string" || query === "") return badRequest(typeof query === "string" ? "The query is empty" : "Missing query (a string)");
-		const operationName = request.operationName;
-		if (operationName !== void 0 && operationName !== null && typeof operationName !== "string") return badRequest("operationName must be a string");
-		const variables = request.variables;
-		if (variables !== void 0 && variables !== null && (typeof variables !== "object" || Array.isArray(variables))) return badRequest("variables must be an object");
-		const entry = this.#cache.get(query) ?? this.#load(query);
-		if (entry instanceof Rejection) return entry;
-		let operation;
-		if (operationName === void 0 || operationName === null) {
-			operation = entry.single;
-			if (operation === void 0) return new Rejection(400, [requestError("Must provide operation name if query contains multiple operations.", GraphQLErrorCode.BadRequest)], entry.id);
-		} else {
-			operation = entry.named?.get(operationName);
-			if (operation === void 0) return new Rejection(400, [requestError(`Unknown operation named "${operationName}".`, GraphQLErrorCode.BadRequest)], entry.id);
-		}
-		if (options.queriesOnly === true && operation.operation !== "query") return new Rejection(405, [requestError(`A ${operation.operation} cannot be sent with GET: use POST`, GraphQLErrorCode.BadRequest)], entry.id, operation, { allow: "POST" });
-		return {
-			entry,
-			operation
-		};
-	}
-	/** Parses, limits and validates a document; caches it when valid (rejected documents are not cached). */
-	#load(query) {
-		let document;
-		try {
-			document = parse(query, this.#maxTokens === void 0 ? void 0 : { maxTokens: this.#maxTokens });
-		} catch (error) {
-			if (!(error instanceof GraphQLError)) throw error;
-			return new Rejection(400, [withCode(error, GraphQLErrorCode.ParseFailed)], documentId(query));
-		}
-		const limited = checkLimits(document, this.#limits);
-		if (limited !== void 0) return new Rejection(400, limited.map((error) => withCode(error, void 0)), documentId(query));
-		const errors = validate(this.#schema, document, this.#rules, { hideSuggestions: this.#hideSuggestions });
-		if (errors.length > 0) return new Rejection(400, errors.map((error) => withCode(error, GraphQLErrorCode.ValidationFailed)), documentId(query));
-		const entry = new CachedDocument(query, document);
-		this.#cache.set(query, entry);
-		return entry;
-	}
-	#context(prepared, request, options, scope) {
-		return new OperationContext(this.#runtime, prepared.entry.document, prepared.operation, request, options, scope);
-	}
-	/** Runs `fn` in the current scope (the GraphQL context set in it) or in a new one, closed after. */
-	#inScope(scope, ctx, fn) {
-		if (scope !== void 0) {
-			scope.set(GraphQLTokens.Context, ctx);
-			return fn();
-		}
-		const opened = this.#container.openScope([[GraphQLTokens.Context, ctx]]);
-		let result;
-		try {
-			result = opened.run(fn);
-		} catch (error) {
-			const closing = opened.close();
-			if (closing === void 0) throw error;
-			return closing.then(() => Promise.reject(error), () => Promise.reject(error));
-		}
-		if (isPromise$2(result)) return result.then((value) => {
-			const closing = opened.close();
-			return closing === void 0 ? value : closing.then(() => value);
-		}, (error) => {
-			const closing = opened.close();
-			if (closing === void 0) throw error;
-			return closing.then(() => Promise.reject(error), () => Promise.reject(error));
-		});
-		const closing = opened.close();
-		return closing === void 0 ? result : closing.then(() => result);
-	}
-	#run(prepared, request, options, ctx) {
-		let result;
-		try {
-			result = execute({
-				schema: this.#schema,
-				document: prepared.entry.document,
-				operationName: request.operationName,
-				variableValues: request.variables,
-				contextValue: ctx,
-				abortSignal: options.abortSignal ?? options.signal,
-				hideSuggestions: this.#hideSuggestions
-			});
-		} catch (error) {
-			return Promise.reject(abortReason(error, options));
-		}
-		if (isPromise$2(result)) return result.then((settled) => this.#respond(settled, ctx), (error) => Promise.reject(abortReason(error, options)));
-		return this.#respond(result, ctx);
-	}
-	/** The response of an execution result: as is without errors, formatted errors otherwise. */
-	#respond(result, ctx) {
-		const errors = result.errors;
-		if (errors === void 0) return {
-			status: 200,
-			result
-		};
-		if (!("data" in result)) return {
-			status: 400,
-			result: { errors: errors.map(variableError) }
-		};
-		return {
-			status: 200,
-			result: {
-				data: result.data,
-				errors: this.#formatter.format(errors, ctx),
-				...result.extensions === void 0 ? {} : { extensions: result.extensions }
-			}
-		};
-	}
-	/** Formats a subscription result: an event, a source that could not start or failed (field errors). */
-	formatEvent(result, ctx) {
-		const errors = result.errors;
-		if (errors === void 0) return result;
-		return {
-			..."data" in result ? { data: result.data } : {},
-			errors: this.#formatter.format(errors, ctx)
-		};
-	}
-	#startSubscription(prepared, request, options, ctx, observer, run, close, release) {
-		const validated = validateSubscriptionArgs({
-			schema: this.#schema,
-			document: prepared.entry.document,
-			operationName: request.operationName,
-			variableValues: request.variables,
-			contextValue: ctx,
-			abortSignal: options.signal,
-			hideSuggestions: this.#hideSuggestions
-		});
-		if (!("schema" in validated)) return new Rejection(400, validated.map(variableError), prepared.entry.id, prepared.operation);
-		const start = (source) => {
-			release();
-			if (!isAsyncIterable(source)) {
-				const result = this.formatEvent(source, ctx);
-				close();
-				observer?.end("error", result.errors);
-				return new SingleResultStream(result);
-			}
-			const stream = new SubscriptionStream({
-				executor: this,
-				source: source[Symbol.asyncIterator](),
-				validated,
-				ctx,
-				run,
-				signal: options.signal,
-				field: responseKey(prepared.operation),
-				onEnd: (outcome, errors) => {
-					this.#streams.delete(stream);
-					this.#direct.delete(stream);
-					close();
-					observer?.end(outcome, errors);
-				}
-			});
-			this.#streams.add(stream);
-			if (ctx.transport === "direct") this.#direct.add(stream);
-			return stream;
-		};
-		const source = createSourceEventStream(validated);
-		return isPromise$2(source) ? source.then(start) : start(source);
-	}
-	/** A rejection as a response, observed by the hook (outcome `rejected`). */
-	#reject(rejection, request, options) {
-		const hooks = this.#hooks;
-		const wrapped = hooks.hasWrappers(OPERATION_HOOK);
-		if (!wrapped && !hooks.hasListeners(OPERATION_HOOK)) return rejection.response();
-		const event = {
-			operationType: rejection.operationType,
-			operationName: rejection.operationName ?? (typeof request?.operationName === "string" ? request.operationName : void 0),
-			documentId: rejection.documentId,
-			transport: options.transport ?? "direct",
-			requestId: options.requestId ?? options.http?.requestId ?? this.#scopedRequestId(),
-			context: void 0,
-			startTime: performance.now(),
-			outcome: "rejected",
-			errors: summaries(rejection.errors)
-		};
-		if (!wrapped) {
-			hooks.emit(OPERATION_HOOK, event);
-			return rejection.response();
-		}
-		return hooks.run(OPERATION_HOOK, event, () => Promise.resolve(rejection.response())).then((response) => {
-			if (hooks.hasListeners(OPERATION_HOOK)) hooks.emit(OPERATION_HOOK, event);
-			return response;
-		});
-	}
-	/** An executed query or mutation, observed by the hook. */
-	#observed(ctx, id, run) {
-		const hooks = this.#hooks;
-		const event = operationEvent(ctx, id);
-		const done = (response) => {
-			event.outcome = outcomeOf(response);
-			if (response.result.errors !== void 0) event.errors = summaries(response.result.errors);
-			return response;
-		};
-		const failed = (error) => {
-			event.outcome = "error";
-			throw error;
-		};
-		const emit = () => {
-			if (hooks.hasListeners(OPERATION_HOOK)) hooks.emit(OPERATION_HOOK, event);
-		};
-		if (hooks.hasWrappers(OPERATION_HOOK)) return hooks.run(OPERATION_HOOK, event, () => Promise.resolve(run()).then(done, failed)).then((response) => {
-			emit();
-			return response;
-		}, (error) => {
-			emit();
-			throw error;
-		});
-		let response;
-		try {
-			response = run();
-		} catch (error) {
-			event.outcome = "error";
-			emit();
-			throw error;
-		}
-		if (!isPromise$2(response)) {
-			done(response);
-			emit();
-			return response;
-		}
-		return response.then((settled) => {
-			done(settled);
-			emit();
-			return settled;
-		}, (error) => {
-			event.outcome = "error";
-			emit();
-			throw error;
-		});
-	}
-	/** The hook of a subscription, for its whole life (`end()` settles it), or `undefined` without wrappers nor listeners. */
-	#observer(ctx, id) {
-		const hooks = this.#hooks;
-		const wrapped = hooks.hasWrappers(OPERATION_HOOK);
-		if (!wrapped && !hooks.hasListeners(OPERATION_HOOK)) return void 0;
-		const event = operationEvent(ctx, id);
-		let resolve;
-		if (wrapped) {
-			const ended = new Promise((settle) => {
-				resolve = settle;
-			});
-			hooks.run(OPERATION_HOOK, event, () => ended).catch((error) => this.#runtimeLogError("A \"graphql:operation\" hook wrapper failed", error));
-		}
-		let ended = false;
-		return { end: (outcome, errors) => {
-			if (ended) return;
-			ended = true;
-			event.outcome = outcome;
-			if (errors !== void 0 && errors.length > 0) event.errors = summaries(errors);
-			resolve?.();
-			if (hooks.hasListeners(OPERATION_HOOK)) hooks.emit(OPERATION_HOOK, event);
-		} };
-	}
-	/** The request id of the enclosing scope (a controller calling GraphQL), or a new one. */
-	#scopedRequestId() {
-		const id = this.#container.currentScope()?.get(HttpTokens.RequestId);
-		return typeof id === "string" ? id : randomUUID();
-	}
-	#runtimeLogError(message, error) {
-		this.#logger.error(`GraphQLPlugin: ${message}`, { err: error });
-	}
-};
-function noop$1() {}
-function badRequest(message) {
-	return new Rejection(400, [requestError(message, GraphQLErrorCode.BadRequest)], void 0);
-}
-function variableError(error) {
-	return withCode(error, error.extensions["code"] === void 0 ? GraphQLErrorCode.BadUserInput : void 0);
-}
-/** graphql-js rejects with `AbortedGraphQLExecutionError`: callers get the reason of their signal. */
-function abortReason(error, options) {
-	const signal = options.abortSignal ?? options.signal;
-	if (error instanceof AbortedGraphQLExecutionError && signal?.aborted === true) return signal.reason;
-	return error;
-}
-function operationEvent(ctx, id) {
+function executeOptions(args, options, driver) {
+	const signal = options?.signal ?? args?.abortSignal ?? void 0;
+	const requestId = options?.requestId;
 	return {
-		operationType: ctx.operationType,
-		operationName: ctx.operationName,
-		documentId: id,
-		transport: ctx.transport,
-		requestId: ctx.requestId,
-		context: ctx,
-		startTime: performance.now()
+		transport: options?.transport ?? "http",
+		driver,
+		serverContext: args?.contextValue,
+		...signal === void 0 ? {} : { signal },
+		...requestId === void 0 ? {} : { requestId }
 	};
 }
-function outcomeOf(response) {
-	if (response.status !== 200) return "rejected";
-	const result = response.result;
-	if (result.errors === void 0 || result.errors.length === 0) return "success";
-	return result.data === null || result.data === void 0 ? "error" : "partial";
-}
-function summaries(errors) {
-	return errors.map((error) => {
-		const code = error.extensions?.["code"];
-		return {
-			message: error.message,
-			code: typeof code === "string" ? code : void 0,
-			...error.path === void 0 ? {} : { path: error.path }
-		};
-	});
-}
-/** The response key of the root field of a subscription (its single selection). */
-function responseKey(operation) {
-	const selection = operation.selectionSet.selections[0];
-	return selection?.kind === Kind.FIELD ? (selection.alias ?? selection.name).value : void 0;
-}
-function isPromise$2(value) {
-	return typeof value?.then === "function";
-}
-function isAsyncIterable(value) {
-	return value !== null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
-}
-/** A stream of one result (a query sent as a stream, a rejection for `plugin.subscribe()`). */
-function singleResult(result) {
-	return new SingleResultStream(result);
-}
-/** The stream of a query or a mutation sent as a stream (SSE): its single result. */
-var SingleResultStream = class {
-	#result;
-	constructor(result) {
-		this.#result = result;
-	}
-	next() {
-		const result = this.#result;
-		if (result === void 0) return Promise.resolve(DONE$1);
-		this.#result = void 0;
-		return Promise.resolve({
-			done: false,
-			value: result
-		});
-	}
-	return() {
-		this.#result = void 0;
-		return Promise.resolve(DONE$1);
-	}
-	[Symbol.asyncIterator]() {
-		return this;
-	}
-};
-/**
-* The results of a subscription: each source event executed with `executeSubscriptionEvent`, a
-* fresh per-execution state (loaders) and the operation's `GraphQLContext`.
-*
-* The source is started at once: its first `next()` is requested when the stream is created, so
-* that a resolver written as an async generator (`for await (const x of pubsub.subscribe(...))`)
-* has subscribed when `subscribe()` resolves, whatever the transport and however late its consumer
-* reads (an SSE body pulled on demand). Only that first event is read ahead; the next ones are read
-* when the consumer asks (backpressure).
-*/
-var SubscriptionStream = class {
-	#init;
-	#onAbort;
-	/** The first `next()` of the source, requested at creation and consumed by the first read. */
-	#first;
-	/** `next()` calls of the source still pending. */
-	#reading = 0;
-	#ended = false;
-	#partial = false;
-	constructor(init) {
-		this.#init = init;
-		const signal = init.signal;
-		if (signal !== void 0) {
-			this.#onAbort = () => {
-				this.return();
-			};
-			signal.addEventListener("abort", this.#onAbort, { once: true });
-		}
-		const first = init.run(() => this.#read());
-		first.catch(noop$1);
-		this.#first = first;
-		if (signal?.aborted === true) this.return();
-	}
-	next() {
-		if (this.#ended) return Promise.resolve(DONE$1);
-		return this.#init.run(() => this.#pull());
-	}
-	/** The next event of the source. */
-	async #read() {
-		this.#reading++;
-		try {
-			return await this.#init.source.next();
-		} finally {
-			this.#reading--;
-		}
-	}
-	async #pull() {
-		const init = this.#init;
-		let step;
-		try {
-			const first = this.#first;
-			this.#first = void 0;
-			step = await (first ?? this.#read());
-		} catch (error) {
-			if (this.#ended) return DONE$1;
-			const result = init.executor.formatEvent({ errors: [new GraphQLError(errorMessage(error), {
-				originalError: asError(error),
-				path: init.field === void 0 ? void 0 : [init.field]
-			})] }, init.ctx);
-			this.#end("error", result.errors);
-			return {
-				done: false,
-				value: result
-			};
-		}
-		if (step.done === true || this.#ended) {
-			this.#end(this.#partial ? "partial" : "success", void 0);
-			return DONE$1;
-		}
-		init.ctx.resetLoaders();
-		const executed = executeSubscriptionEvent({
-			...init.validated,
-			rootValue: step.value
-		});
-		const result = init.executor.formatEvent(isPromise$2(executed) ? await executed : executed, init.ctx);
-		if (result.errors !== void 0) this.#partial = true;
-		return {
-			done: false,
-			value: result
-		};
-	}
-	async return() {
-		if (this.#ended) return DONE$1;
-		this.#first = void 0;
-		this.#end(this.#partial ? "partial" : "success", void 0);
-		const reading = this.#reading > 0;
-		try {
-			const returned = Promise.resolve(this.#init.source.return?.());
-			if (reading) returned.catch(noop$1);
-			else await returned;
-		} catch {}
-		return DONE$1;
-	}
-	throw() {
-		return this.return();
-	}
-	[Symbol.asyncIterator]() {
-		return this;
-	}
-	#end(outcome, errors) {
-		if (this.#ended) return;
-		this.#ended = true;
-		if (this.#onAbort !== void 0) this.#init.signal?.removeEventListener("abort", this.#onAbort);
-		this.#init.onEnd(outcome, errors);
-	}
-};
-function asError(error) {
-	return error instanceof Error ? error : new Error(String(error));
-}
-function errorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
 // src/options.ts
 const KEYS = /* @__PURE__ */ new Set([
 	"path",
@@ -1468,7 +334,8 @@ const KEYS = /* @__PURE__ */ new Set([
 	"documentCache",
 	"subscriptions",
 	"pubsub",
-	"enforcement"
+	"enforcement",
+	"driver"
 ]);
 const PATH = /^\/[A-Za-z0-9\-._~!$&'()*+,;=:@/]*$/;
 const LIMIT_DEFAULTS = {
@@ -1563,6 +430,10 @@ function resolveGraphQLOptions(options, env = process.env) {
 	if (pubsub !== void 0 && !(isRecord$1(pubsub) && typeof pubsub.publish === "function" && typeof pubsub.subscribe === "function")) throw invalidOption("pubsub", "a PubSub (publish() and subscribe() methods)", pubsub);
 	const enforcement = options["enforcement"] ?? "error";
 	if (enforcement !== "error" && enforcement !== "warn") throw invalidOption("enforcement", "'error' or 'warn'", enforcement);
+	const driver = resolveDriver(options["driver"]);
+	if (driver !== void 0 && subscriptions !== false) {
+		for (const key of ["heartbeat", "maxDuration"]) if (subscriptions[key] !== void 0) throw new ZnightError(ErrorCode.InvalidGraphQLSetup, `GraphQLPlugin: subscriptions.${key} configures the built-in SSE transport, not the ${driver.name} driver`, { hints: [`Remove subscriptions.${key}: the ${driver.name} driver's own keep-alive options apply`] });
+	}
 	return {
 		path,
 		http,
@@ -1582,9 +453,23 @@ function resolveGraphQLOptions(options, env = process.env) {
 		subscriptions,
 		bufferSize,
 		pubsub,
-		enforcement
+		enforcement,
+		driver
 	};
 }
+/** The `driver` option: an object with a `name` (not `builtin`) and `start()`, `routes()` and `stop()` functions when present. */
+function resolveDriver(value) {
+	if (value === void 0) return void 0;
+	const expected = "a GraphQL driver ({ name, start(), routes?(), stop?() }, from yogaDriver() for instance)";
+	if (value === null || typeof value !== "object") throw invalidOption("driver", expected, value);
+	const driver = value;
+	const name = driver["name"];
+	if (typeof name !== "string" || name === "") throw invalidOption("driver", `${expected} with a name`, value);
+	if (name === "builtin") throw invalidOption("driver.name", "a name other than 'builtin' (reserved for the built-in transport)", name);
+	if (typeof driver["start"] !== "function") throw invalidOption("driver", `${expected} with a start() method`, value);
+	for (const method of ["routes", "stop"]) if (driver[method] !== void 0 && typeof driver[method] !== "function") throw invalidOption(`driver.${method}`, "a function", driver[method]);
+	return value;
+}
 // src/pipeline.ts
 /** Whether global guards run on a field: root fields always, field resolvers when they carry metadata (§5.9). */
 function globalGuardsApply(binding) {
@@ -1597,17 +482,18 @@ function pipelineFactory(options) {
 }
 function fieldFunctions(options, normalizers, binding, coordinate, field, parent) {
 	const container = options.container;
-	const invoke = binding.invoke;
 	const target = options.resolver(binding, coordinate);
 	const guards = [...globalGuardsApply(binding) ? options.globalGuards : [], ...binding.guards.map((token) => options.guard(token, coordinate))];
 	const normalize = field.args === void 0 ? void 0 : normalizers.args(field.args);
 	const recover = options.results?.(field, coordinate);
-	const route = guards.length === 0 && recover === void 0 ? void 0 : Object.freeze({
+	const custom = binding.context === true;
+	const route = guards.length === 0 && recover === void 0 && !custom ? void 0 : Object.freeze({
 		meta: binding.meta,
 		coordinate
 	});
 	const parentType = parent.name;
 	const fieldName = field.name;
+	const invoke = custom ? customInvoke(options, binding, coordinate, route, parentType, fieldName) : binding.invoke;
 	let resolve;
 	if (guards.length === 0) {
 		if (target.token === void 0) {
@@ -1630,10 +516,11 @@ function fieldFunctions(options, normalizers, binding, coordinate, field, parent
 		resolve = (p, a, c, i) => {
 			const operation = c;
 			const args = a;
-			const allowed = runGuards(container, guards, new FieldContext(route, operation, parentType, fieldName, args, p, i));
+			const fieldContext = new FieldContext(route, operation, parentType, fieldName, args, p, i);
+			const allowed = runGuards(container, guards, fieldContext);
 			const call = () => {
 				if (normalize !== void 0) normalize(args);
-				return invoke(resolveIn(container, target), p, args, operation, i);
+				return invoke(resolveIn(container, target), p, args, operation, i, fieldContext);
 			};
 			if (allowed === true) return call();
 			if (allowed === false) return forbidden();
@@ -1652,6 +539,27 @@ function identity$1(payload) {
 	return payload;
 }
 /**
+* The invoke of a method with custom parameters (RFC 0010): the generated `invoke` receives the
+* field's `ResolverContext` (the guards' one when the field has guards, else a new one) and the
+* instances of its parameter resolvers: one frozen array resolved at boot when they are all
+* singletons, otherwise resolved in the operation scope on every call.
+*/
+function customInvoke(options, binding, coordinate, route, parentType, fieldName) {
+	const generated = binding.invoke;
+	const container = options.container;
+	const resolvers = (binding.paramResolvers ?? []).map((token) => {
+		if (options.paramResolver === void 0) throw new TypeError(`No parameter resolver for ${coordinate}`);
+		return options.paramResolver(token, coordinate);
+	});
+	const context = (p, a, c, i, f) => f ?? new FieldContext(route, c, parentType, fieldName, a, p, i);
+	if (resolvers.length === 0) return (r, p, a, c, i, f) => generated(r, p, a, c, i, context(p, a, c, i, f));
+	if (resolvers.every((resolver) => resolver.token === void 0)) {
+		const instances = Object.freeze(resolvers.map((resolver) => resolveIn(container, resolver)));
+		return (r, p, a, c, i, f) => generated(r, p, a, c, i, context(p, a, c, i, f), instances);
+	}
+	return (r, p, a, c, i, f) => generated(r, p, a, c, i, context(p, a, c, i, f), resolvers.map((resolver) => resolveIn(container, resolver)));
+}
+/**
 * The resolve function of a field that carries results (RFC 0008): errors of the whole pipeline
 * (guards, null handling, `invoke`), thrown or rejected, go through `recover`. Synchronous results
 * stay synchronous; a promise gets one rejection handler. For a subscription, a value is a source
@@ -2425,585 +1333,43 @@ function pathOf(info) {
 	for (let step = info.path; step !== void 0; step = step.prev) path.push(step.key);
 	return path.reverse();
 }
-// src/transport/abort.ts
-/** The stand-in passed as graphql-js `abortSignal` by the HTTP transport (one per request). */
-var DeferredAbort = class {
-	aborted = false;
-	reason = void 0;
-	/** graphql-js registers one listener per execution; more are kept in {@link #others}. */
-	#listener = void 0;
-	#others = void 0;
-	throwIfAborted() {
-		if (this.aborted) throw this.reason;
-	}
-	addEventListener(type, listener) {
-		if (type !== "abort") return;
-		if (this.#listener === void 0) {
-			this.#listener = listener;
-			return;
-		}
-		this.#others ??= [];
-		this.#others.push(listener);
-	}
-	removeEventListener(type, listener) {
-		if (type !== "abort") return;
-		if (this.#listener === listener) {
-			this.#listener = void 0;
-			return;
-		}
-		const others = this.#others;
-		const index = others === void 0 ? -1 : others.indexOf(listener);
-		if (index !== -1) others?.splice(index, 1);
-	}
-	/**
-	* The execution is asynchronous: from now on, `signal` aborting aborts the execution. Reads the
-	* signal only when graphql-js still listens (a pending execution).
-	*/
-	follow(read) {
-		if (this.#listener === void 0 && (this.#others === void 0 || this.#others.length === 0)) return;
-		const signal = read();
-		if (signal.aborted) {
-			this.#abort(signal.reason);
-			return;
-		}
-		signal.addEventListener("abort", () => this.#abort(signal.reason), { once: true });
-	}
-	/** This stand-in, typed as the `AbortSignal` graphql-js expects. */
-	asSignal() {
-		return this;
-	}
-	#abort(reason) {
-		if (this.aborted) return;
-		this.aborted = true;
-		this.reason = reason;
-		const listener = this.#listener;
-		const others = this.#others;
-		this.#listener = void 0;
-		this.#others = void 0;
-		listener?.();
-		if (others !== void 0) for (const other of others) other();
-	}
-};
-// src/transport/accept.ts
-/**
-* Content negotiation of the GraphQL endpoint (RFC 0005 §8.3): which of the media types the
-* endpoint produces a request accepts best. Import-free.
-*
-* `application/json` is the only type matched by wildcards (`*\/*`, `application/*`): the
-* GraphQL-over-HTTP draft asks for `application/json` when the client accepts anything, and the
-* other types change the protocol (`application/graphql-response+json` statuses, an event stream,
-* the GraphiQL page), so they are chosen only when listed. Among types of equal quality,
-* `application/graphql-response+json` wins, then `application/json`, then HTML (a browser listing
-* `text/html` first gets GraphiQL). An event stream is chosen only when it is strictly preferred, or
-* the only acceptable type: a client listing JSON and `text/event-stream` alike (urql, for
-* incremental delivery) gets its queries and mutations as one JSON body, and its subscriptions as
-* a stream ({@link STREAMABLE}).
-*/
-/** What a response is encoded as. */
-const Media = Object.freeze({
-	EventStream: 0,
-	GraphQLJson: 1,
-	Json: 2,
-	Html: 3,
-	None: 4
-});
-/** The media type names, by {@link Media} value (`None` excluded). */
-const NAMES = [
-	["text", "event-stream"],
-	["application", "graphql-response+json"],
-	["application", "json"],
-	["text", "html"]
-];
-/** The media ranges of an `accept` header (lower-case, without parameters other than `q`). */
-function parseRanges(header) {
-	const ranges = [];
-	for (const item of header.split(",")) {
-		const parts = item.split(";");
-		const media = parts[0].trim().toLowerCase();
-		const slash = media.indexOf("/");
-		if (slash <= 0 || slash === media.length - 1) continue;
-		let q = 1;
-		for (let index = 1; index < parts.length; index++) {
-			const parameter = parts[index].trim();
-			if (parameter.length < 2 || (parameter.charCodeAt(0) | 32) !== 113 || parameter[1] !== "=") continue;
-			const value = Number(parameter.slice(2));
-			if (value >= 0 && value <= 1) q = value;
-		}
-		ranges.push({
-			type: media.slice(0, slash),
-			subtype: media.slice(slash + 1),
-			q
-		});
-	}
-	return ranges;
-}
-/**
-* The quality of `type/subtype` in `ranges`: that of the most specific matching range (RFC 9110
-* §12.5.1), wildcards only when `wildcards` is set; 0 when nothing matches.
-*/
-function quality(ranges, type, subtype, wildcards) {
-	let best = -1;
-	let specificity = -1;
-	for (const range of ranges) {
-		let level;
-		if (range.type === type && range.subtype === subtype) level = 2;
-		else if (!wildcards) continue;
-		else if (range.type === type && range.subtype === "*") level = 1;
-		else if (range.type === "*" && range.subtype === "*") level = 0;
-		else continue;
-		if (level > specificity || level === specificity && range.q > best) {
-			specificity = level;
-			best = range.q;
-		}
-	}
-	return best < 0 ? 0 : best;
-}
-/**
-* Chooses the media type of a response among `produced` (a bit mask of `1 << Media.X`), per
-* `accept` (`undefined`: no header, i.e. `application/json`): a {@link MediaKind}, plus
-* {@link STREAMABLE} when a JSON type wins and an event stream is acceptable too.
-*/
-function negotiate(accept, produced) {
-	if (accept === void 0) return produced & 1 << Media.Json ? Media.Json : Media.None;
-	const ranges = parseRanges(accept);
-	if (ranges.length === 0) return produced & 1 << Media.Json ? Media.Json : Media.None;
-	let chosen = Media.None;
-	let best = 0;
-	for (let media = Media.GraphQLJson; media < NAMES.length; media++) {
-		if ((produced & 1 << media) === 0) continue;
-		const [type, subtype] = NAMES[media];
-		const q = quality(ranges, type, subtype, media === Media.Json);
-		if (q > best) {
-			best = q;
-			chosen = media;
-		}
-	}
-	if (produced & 1 << Media.EventStream) {
-		const q = quality(ranges, "text", "event-stream", false);
-		if (q > best) return Media.EventStream;
-		if (q > 0 && (chosen === Media.GraphQLJson || chosen === Media.Json)) chosen |= 8;
-	}
-	return chosen;
-}
-const CACHE_MAX = 64;
-/**
-* {@link negotiate} for one route, memoised by header value: a server sees a handful of `accept`
-* values, so a request costs a map lookup. Bounded, since clients choose the values: cleared when
-* full.
-*/
-var Negotiator = class {
-	#produced;
-	#cache = /* @__PURE__ */ new Map();
-	/** The answer without `accept` header. */
-	#absent;
-	/** `produced`: a bit mask of `1 << Media.X`. */
-	constructor(produced) {
-		this.#produced = produced;
-		this.#absent = negotiate(void 0, produced);
-	}
-	/** The {@link negotiate} answer: a {@link MediaKind}, possibly with {@link STREAMABLE}. */
-	choose(accept) {
-		if (accept === void 0) return this.#absent;
-		let media = this.#cache.get(accept);
-		if (media === void 0) {
-			media = negotiate(accept, this.#produced);
-			if (this.#cache.size === CACHE_MAX) this.#cache.clear();
-			this.#cache.set(accept, media);
-		}
-		return media;
-	}
-};
-// src/transport/graphiql.ts
-/**
-* The GraphiQL page (RFC 0005 §8.3, §8.9): served on `GET path` with `accept: text/html` when the
-* `graphiql` option is on (default: `NODE_ENV === 'development'`). React and GraphiQL load from a
-* pinned CDN with Subresource Integrity; the inline script is fixed at boot and allowed by hash in
-* the page's own `content-security-policy`, which overrides the strict API default of RFC 0001 on
-* this response only.
-*/
-/** jsDelivr. */
-const GRAPHIQL_CDN = "https://cdn.jsdelivr.net";
-/**
-* The assets of the page: GraphiQL 3 (the last major with a UMD build) on React 18. Bumped by hand,
-* with their SRI hashes (`sha384` of the files on the CDN).
-*/
-const GRAPHIQL_ASSETS = Object.freeze([
-	{
-		url: `${GRAPHIQL_CDN}/npm/graphiql@3.9.0/graphiql.min.css`,
-		integrity: "sha384-QMux00XgRtwRLSYIY3kw2rj1ovk5AuuliAchk+HSQbqdbGFnz9GYuqIlOqxhwCE2",
-		kind: "style"
-	},
-	{
-		url: `${GRAPHIQL_CDN}/npm/react@18.3.1/umd/react.production.min.js`,
-		integrity: "sha384-DGyLxAyjq0f9SPpVevD6IgztCFlnMF6oW/XQGmfe+IsZ8TqEiDrcHkMLKI6fiB/Z",
-		kind: "script"
-	},
-	{
-		url: `${GRAPHIQL_CDN}/npm/react-dom@18.3.1/umd/react-dom.production.min.js`,
-		integrity: "sha384-gTGxhz21lVGYNMcdJOyq01Edg0jhn/c22nsx0kyqP0TxaV5WVdsSH1fSDUf5YJj1",
-		kind: "script"
-	},
-	{
-		url: `${GRAPHIQL_CDN}/npm/graphiql@3.9.0/graphiql.min.js`,
-		integrity: "sha384-8NGfVj4CVlqHajlZj+bPJT4thxPMHMJYn7DWK2CvtopLd02E7qsPHazniBYvVjOO",
-		kind: "script"
-	}
-]);
-/** `<`, `>` and `&` escaped: JSON safe inside a `<script>` element. */
-function scriptJson(value) {
-	return JSON.stringify(value).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
-}
-function escapeHtml(text) {
-	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-/** The GraphiQL page of the endpoint `endpoint` (an absolute path, prefix included) and its CSP. */
-function renderGraphiQL(endpoint) {
-	const tags = GRAPHIQL_ASSETS.map((asset) => asset.kind === "style" ? `<link rel="stylesheet" href="${escapeHtml(asset.url)}" integrity="${asset.integrity}" crossorigin="anonymous">` : `<script src="${escapeHtml(asset.url)}" integrity="${asset.integrity}" crossorigin="anonymous"><\/script>`);
-	const inline = [`const fetcher = GraphiQL.createFetcher({ url: ${scriptJson(endpoint)} })`, `ReactDOM.createRoot(document.getElementById('graphiql')).render(React.createElement(GraphiQL, { fetcher }))`].join("\n");
-	const hash = `'sha256-${createHash("sha256").update(inline).digest("base64")}'`;
-	return {
-		html: [
-			"<!doctype html>",
-			"<html lang=\"en\">",
-			"<head>",
-			"<meta charset=\"utf-8\">",
-			"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">",
-			"<title>GraphiQL</title>",
-			"<style>body { margin: 0; } #graphiql { height: 100dvh; }</style>",
-			...tags.filter((tag) => tag.startsWith("<link")),
-			"</head>",
-			"<body>",
-			"<div id=\"graphiql\">Loading GraphiQL…</div>",
-			...tags.filter((tag) => tag.startsWith("<script")),
-			`<script>${inline}<\/script>`,
-			"</body>",
-			"</html>",
-			""
-		].join("\n"),
-		csp: [
-			"default-src 'none'",
-			`script-src ${GRAPHIQL_CDN} ${hash}`,
-			`style-src 'unsafe-inline' ${GRAPHIQL_CDN}`,
-			`font-src data: ${GRAPHIQL_CDN}`,
-			"img-src 'self' data:",
-			"connect-src 'self'",
-			"base-uri 'none'",
-			"form-action 'none'",
-			"frame-ancestors 'self'"
-		].join("; ")
-	};
-}
-// src/transport/sse.ts
-/** The last event of a stream that ended normally. */
-const COMPLETE = Object.freeze({
-	event: "complete",
-	data: ""
-});
-const DONE = Object.freeze({
-	done: true,
-	value: void 0
-});
-/**
-* The event source of an operation: one `next` event per result, then `complete` when the
-* operation ended by itself. A stream ended by `ctx.signal` (client gone, shutdown, `maxDuration`)
-* gets no `complete`: GraphQL-over-SSE clients then treat it as a lost connection and retry.
-*/
-var ResultEvents = class {
-	#results;
-	#signal;
-	#done = false;
-	constructor(results, signal) {
-		this.#results = results;
-		this.#signal = signal;
-	}
-	async next() {
-		if (this.#done) return DONE;
-		const step = await this.#results.next();
-		if (step.done !== true) return {
-			done: false,
-			value: {
-				event: "next",
-				data: step.value
-			}
-		};
-		this.#done = true;
-		return this.#signal.aborted ? DONE : {
-			done: false,
-			value: COMPLETE
-		};
-	}
-	async return() {
-		this.#done = true;
-		await this.#results.return();
-		return DONE;
-	}
-	[Symbol.asyncIterator]() {
-		return this;
-	}
-};
-// src/transport/http.ts
-const JSON_TYPE = "application/json; charset=utf-8";
-const GRAPHQL_JSON_TYPE = "application/graphql-response+json; charset=utf-8";
-/** Response options of `application/graphql-response+json` replies, by status. */
-const GRAPHQL_JSON_200 = Object.freeze({
-	status: 200,
-	headers: Object.freeze({ "content-type": GRAPHQL_JSON_TYPE })
-});
-const GRAPHQL_JSON_400 = Object.freeze({
-	status: 400,
-	headers: Object.freeze({ "content-type": GRAPHQL_JSON_TYPE })
-});
-/** `application/json` is what the serialiser gives an object body: only the status is set. */
-const JSON_200 = Object.freeze({ status: 200 });
-const UTF8 = new TextDecoder("utf-8", { fatal: true });
-/** A request error before execution: `{ errors: [{ message, extensions: { code } }] }`. */
-function errorBody(message, code = GraphQLErrorCode.BadRequest) {
-	return { errors: [{
-		message,
-		extensions: { code }
-	}] };
-}
-/** A reply of `status` carrying a GraphQL error body in the negotiated JSON type (`application/json` before negotiation). */
-function errorReply(media, status, body, headers) {
-	const type = media === Media.GraphQLJson ? GRAPHQL_JSON_TYPE : JSON_TYPE;
-	return new HttpResponse(body, {
-		status,
-		headers: {
-			...headers,
-			"content-type": type
-		}
-	});
-}
-const NOT_ACCEPTABLE = errorReply(Media.Json, 406, errorBody("None of the accepted media types can be produced: accept application/graphql-response+json, application/json or text/event-stream"));
-const GET_NOT_ALLOWED = errorReply(Media.Json, 405, errorBody("GraphQL operations are sent with POST on this endpoint"), Object.freeze({ allow: "POST" }));
-/** `content-type` values of JSON bodies seen most often, compared before parsing. */
-function isJsonRequest(contentType) {
-	if (contentType === "application/json" || contentType === "application/json; charset=utf-8") return true;
-	const media = parseMediaType(contentType);
-	if (media === void 0 || media.type !== "application/json") return false;
-	return media.charset === void 0 || media.charset === "utf-8" || media.charset === "utf8";
-}
-/** Why the parameters of a request are invalid, `undefined` when they are valid. */
-function invalidParams(params) {
-	const query = params["query"];
-	if (typeof query !== "string") return query === void 0 || query === null ? "Missing query: send { query, variables?, operationName?, extensions? }" : "The query must be a string";
-	const operationName = params["operationName"];
-	if (operationName !== void 0 && operationName !== null && typeof operationName !== "string") return "operationName must be a string";
-	if (!isMapOrNull(params["variables"])) return "variables must be an object";
-	if (!isMapOrNull(params["extensions"])) return "extensions must be an object";
-}
-/** The parameters of a GraphQL `GET` request. */
-const GET_PARAMS = [
-	"query",
-	"operationName",
-	"variables",
-	"extensions"
-];
-/** A query string component decoded like `URLSearchParams` (`+` is a space); `undefined` when malformed. */
-function decodeComponent(text) {
-	if (text.indexOf("%") === -1 && text.indexOf("+") === -1) return text;
-	try {
-		return decodeURIComponent(text.replaceAll("+", " "));
-	} catch {
-		return;
-	}
-}
-/**
-* The GraphQL parameters of a request target, read directly: `ctx.query` builds a record of every
-* parameter through `URLSearchParams` (about 0.35 µs of a `GET` on Node.js, 0.15 µs on Bun, see
-* `test/bench/http.bench.ts`). A repeated parameter
-* becomes an array, like `ctx.query`. `undefined` when a component is malformed percent-encoding:
-* the caller falls back to `ctx.query` (which keeps such sequences as they are).
-*/
-function readGetParams(url) {
-	const params = {};
-	const mark = url.indexOf("?");
-	if (mark === -1) return params;
-	const length = url.length;
-	let start = mark + 1;
-	while (start < length) {
-		let end = url.indexOf("&", start);
-		if (end === -1) end = length;
-		if (end > start) {
-			let equals = url.indexOf("=", start);
-			if (equals === -1 || equals > end) equals = end;
-			const name = decodeComponent(url.slice(start, equals));
-			if (name === void 0) return void 0;
-			if (name === "query" || name === "operationName" || name === "variables" || name === "extensions") {
-				const value = equals === end ? "" : decodeComponent(url.slice(equals + 1, end));
-				if (value === void 0) return void 0;
-				const existing = params[name];
-				if (existing === void 0) params[name] = value;
-				else params[name] = typeof existing === "string" ? [existing, value] : [...existing, value];
-			}
-		}
-		start = end + 1;
-	}
-	return params;
-}
-function isMapOrNull(value) {
-	return value === void 0 || value === null || typeof value === "object" && !Array.isArray(value);
-}
-function isPromise$1(value) {
-	return typeof value?.then === "function";
-}
-/** The handlers of the GraphQL endpoint. */
-var HttpTransport = class {
-	#resolveExecutor;
-	#executor;
-	#getQueries;
-	#sse;
-	#post;
-	#get;
-	/** The GraphiQL page, `undefined` when disabled. */
-	#graphiql;
+// src/transport/builtin.ts
+/** The name of the built-in transport (`GraphQLOperationEvent.driver`), reserved. */
+const BUILTIN_DRIVER = "builtin";
+/** The built-in GraphQL-over-HTTP and SSE endpoint. */
+var BuiltinDriver = class {
+	name = BUILTIN_DRIVER;
+	#options;
 	constructor(options) {
-		this.#resolveExecutor = options.executor;
-		this.#getQueries = options.get;
-		this.#sse = options.sse;
-		const json = 1 << Media.GraphQLJson | 1 << Media.Json | (options.sse === false ? 0 : 1 << Media.EventStream);
-		this.#post = new Negotiator(json);
-		this.#get = new Negotiator(options.graphiql ? json | 1 << Media.Html : json);
-		if (options.graphiql) {
-			const page = renderGraphiQL(options.endpoint);
-			this.#graphiql = new HttpResponse(new TextEncoder().encode(page.html), {
-				status: 200,
-				headers: {
-					"content-type": "text/html; charset=utf-8",
-					"content-security-policy": page.csp,
-					"cache-control": "no-store"
-				}
-			});
-		}
-	}
-	/** `POST path`. */
-	post = (ctx) => {
-		const headers = ctx.headers;
-		const negotiated = this.#post.choose(headers["accept"]);
-		const media = negotiated & 7;
-		if (media === Media.None) return NOT_ACCEPTABLE;
-		if (!isJsonRequest(headers["content-type"])) return errorReply(media, 415, errorBody("Send GraphQL requests as application/json (content-type: application/json)"));
-		const encoding = headers["content-encoding"];
-		if (encoding !== void 0 && encoding.trim().toLowerCase() !== "identity" && encoding.trim() !== "") return errorReply(media, 415, errorBody(`Unsupported content encoding "${encoding}"`));
-		return ctx.rawBody().then((bytes) => this.#posted(ctx, bytes, media, negotiated >= 8), (error) => transportError(error, media));
-	};
-	/** `GET path`. */
-	get = (ctx) => {
-		const media = this.#get.choose(ctx.headers["accept"]) & 7;
-		if (media === Media.Html) return this.#graphiql;
-		if (media === Media.None) return NOT_ACCEPTABLE;
-		if (!this.#getQueries) return GET_NOT_ALLOWED;
-		const params = readGetParams(ctx.url) ?? ctx.query;
-		const request = {};
-		for (const name of GET_PARAMS) {
-			const value = params[name];
-			if (value === void 0) continue;
-			if (typeof value !== "string") return errorReply(media, 400, errorBody(`Repeated ${name} parameter`));
-			if (name === "variables" || name === "extensions") try {
-				request[name] = JSON.parse(value);
-			} catch {
-				return errorReply(media, 400, errorBody(`The ${name} parameter must be JSON`));
-			}
-			else request[name] = value;
-		}
-		const invalid = invalidParams(request);
-		if (invalid !== void 0) return errorReply(media, 400, errorBody(invalid));
-		if (media === Media.EventStream) return this.#stream(ctx, request, true);
-		return this.#execute(ctx, request, media, true, false);
-	};
-	/** A `POST` body read: parsed, checked, executed or streamed. */
-	#posted(ctx, bytes, media, streamable) {
-		if (bytes.byteLength === 0) return errorReply(media, 400, errorBody("Missing request body: send { query, variables?, operationName? }"));
-		let body;
-		try {
-			body = JSON.parse(UTF8.decode(bytes));
-		} catch {
-			return errorReply(media, 400, errorBody("Malformed JSON body"));
-		}
-		if (body === null || typeof body !== "object") return errorReply(media, 400, errorBody("The body must be a JSON object: { query, variables?, operationName? }"));
-		if (Array.isArray(body)) return errorReply(media, 400, errorBody("Operation batching is not supported: send one operation per request"));
-		const invalid = invalidParams(body);
-		if (invalid !== void 0) return errorReply(media, 400, errorBody(invalid));
-		if (media === Media.EventStream) return this.#stream(ctx, body, false);
-		return this.#execute(ctx, body, media, false, streamable);
+		this.#options = options;
 	}
-	/**
-	* Executes a query or a mutation; synchronous while the execution is. A subscription is streamed
-	* when the client accepts an event stream (`streamable`), a 400 otherwise.
-	*/
-	#execute(ctx, request, media, get, streamable) {
-		const executor = this.#executor ?? this.#bind();
-		const abort = new DeferredAbort();
-		const options = {
-			transport: "http",
-			http: ctx,
-			abortSignal: abort.asSignal(),
-			queriesOnly: get,
-			streamSubscriptions: streamable
-		};
-		const response = executor.execute(request, options);
-		if (response === SUBSCRIBE) return this.#stream(ctx, request, get);
-		if (!isPromise$1(response)) return reply(response, media, get);
-		abort.follow(() => ctx.signal);
-		return response.then((settled) => reply(settled, media, get), (error) => {
-			if (!abort.aborted || error !== abort.reason) throw error;
-			return errorReply(media, 503, errorBody("The request was aborted", GraphQLErrorCode.ServiceUnavailable));
+	/** `POST` on the path, and `GET` when queries over `GET` or GraphiQL are on (the router answers 405 otherwise). */
+	routes(context) {
+		const options = this.#options;
+		const transport = new HttpTransport({
+			executor: options.executor,
+			endpoint: context.endpoint,
+			get: options.get,
+			graphiql: options.graphiql,
+			sse: options.sse
 		});
-	}
-	/** GraphQL over SSE: any operation, its results as `next` events. */
-	#stream(ctx, request, get) {
-		const executor = this.#executor ?? this.#bind();
-		const signal = ctx.signal;
-		const options = {
-			transport: "sse",
-			http: ctx,
-			signal,
-			queriesOnly: get
-		};
-		return executor.subscribe(request, options).then((outcome) => {
-			if ("status" in outcome) return errorReply(Media.Json, outcome.status, outcome.result, outcome.headers);
-			return HttpResponse.sse(new ResultEvents(outcome, signal), this.#sse);
-		}, (error) => {
-			if (!signal.aborted || error !== signal.reason) throw error;
-			return errorReply(Media.Json, 503, errorBody("The request was aborted", GraphQLErrorCode.ServiceUnavailable));
+		const routes = [{
+			method: "POST",
+			path: context.path,
+			name: "handle",
+			handler: transport.post
+		}];
+		if (options.get || options.graphiql) routes.unshift({
+			method: "GET",
+			path: context.path,
+			name: "handle",
+			handler: transport.get
 		});
+		return routes;
 	}
-	#bind() {
-		this.#executor = this.#resolveExecutor();
-		return this.#executor;
-	}
+	/** Nothing to start: the handlers read the executor on the first request. */
+	start() {}
 };
-/**
-* The HTTP reply of an executor response. `application/json` answers 200 to every well-formed
-* request (request errors included); `application/graphql-response+json` keeps the status.
-*/
-function reply(response, media, get) {
-	const status = response.status;
-	const result = response.result;
-	if (media === Media.Json) {
-		if (status === 200 || status === 400) return get ? result : new HttpResponse(result, JSON_200);
-		return errorReply(media, status, result, response.headers);
-	}
-	if (response.headers === void 0) {
-		if (status === 200) return new HttpResponse(result, GRAPHQL_JSON_200);
-		if (status === 400) return new HttpResponse(result, GRAPHQL_JSON_400);
-	}
-	return errorReply(media, status, result, response.headers);
-}
-/** A failure reading the body (413 past the body limit, 400 for an aborted body) with a GraphQL error body. */
-function transportError(error, media) {
-	if (!isHttpException(error)) throw error;
-	return errorReply(media, error.status, errorBody(error.message));
-}
-/** Checks the SSE options once (`HttpResponse.sse()` validates them): `undefined` when they are valid. */
-function checkSseOptions(options) {
-	try {
-		HttpResponse.sse([], options);
-		return;
-	} catch (error) {
-		return error instanceof Error ? error.message : String(error);
-	}
-}
 // src/plugin.ts
 let readExecutor;
 let readEndpoint;
@@ -3045,6 +1411,10 @@ var GraphQLPlugin = class GraphQLPlugin {
 	#runtime;
 	#stop;
 	#endpoint;
+	/** The driver serving the schema: the `driver` option, or the built-in transport. */
+	#driver;
+	/** The driver was started (`onBootstrap`): `onStop` stops it. */
+	#started = false;
 	#active = false;
 	constructor(options) {
 		this.#options = options;
@@ -3097,6 +1467,8 @@ var GraphQLPlugin = class GraphQLPlugin {
 		this.#runtime = void 0;
 		this.#ownPubSub = void 0;
 		this.#endpoint = void 0;
+		this.#driver = void 0;
+		this.#started = false;
 		this.#container = ctx.container;
 		this.#metadata = ctx.metadata;
 		this.#logger = ctx.logger;
@@ -3113,48 +1485,54 @@ var GraphQLPlugin = class GraphQLPlugin {
 		ctx.container.registerValue(GraphQLTokens.Plugin, this);
 	}
 	/**
-	* The `PluginHttpRoutes` contract of `@znight/http`: the GraphQL endpoint (`GET` and `POST` on
-	* `path`). `[]` with `http: false`.
+	* The `PluginHttpRoutes` contract of `@znight/http`: the routes of the driver, with the `http`
+	* option's meta and guards, and its body limit on the routes that are not `GET`. For the built-in
+	* transport, the GraphQL endpoint (`GET` and `POST` on `path`). `[]` with `http: false`.
 	*/
 	httpRoutes(context) {
 		this.#container ??= context.container;
 		const options = this.#resolve();
 		const http = options.http;
 		if (http === false) return [];
+		const driver = this.#driverOf(options);
+		if (driver.routes === void 0) return [];
 		const endpoint = endpointPath(context.prefix, options.path);
-		const transport = new HttpTransport({
-			executor: () => this.#ready().executor,
-			endpoint,
-			get: http.get,
-			graphiql: options.graphiql,
-			sse: sseOptions(options)
-		});
-		this.#endpoint = endpoint;
-		const common = {
-			name: "handle",
+		const routes = driver.routes({
 			path: options.path,
-			...http.meta.length === 0 ? {} : { meta: http.meta },
-			...http.guards.length === 0 ? {} : { guards: http.guards }
-		};
-		const routes = [{
-			...common,
-			method: "POST",
-			handler: transport.post,
-			bodyLimit: http.bodyLimit
-		}];
-		if (http.get || options.graphiql) routes.unshift({
-			...common,
-			method: "GET",
-			handler: transport.get
+			endpoint
 		});
-		return routes;
+		if (!Array.isArray(routes)) throw invalidOption(`routes() of the ${driver.name} driver`, "an array of routes", routes);
+		this.#endpoint = endpoint;
+		return routes.map((route) => mount(route, http, driver));
 	}
 	onBootstrap(ctx) {
 		this.#container = ctx.container;
 		const options = this.#resolve();
 		if (typeof this.#options === "function") this.#checkHttp(ctx, options);
-		this.#checkSse(options);
-		this.#runtime = this.#build(ctx, options);
+		if (options.driver === void 0) this.#checkSse(options);
+		const runtime = this.#build(ctx, options);
+		this.#runtime = runtime;
+		const driver = this.#driverOf(options);
+		if (options.driver === void 0) return;
+		let started;
+		try {
+			started = driver.start(runtime.engine, {
+				logger: ctx.logger,
+				container: ctx.container,
+				http: ctx.getPlugin("http")
+			});
+		} catch (error) {
+			throw driverFailed(driver, error);
+		}
+		if (!isPromise(started)) {
+			this.#started = true;
+			return;
+		}
+		return started.then(() => {
+			this.#started = true;
+		}, (error) => {
+			throw driverFailed(driver, error);
+		});
 	}
 	onStart(ctx) {
 		const runtime = this.#runtime;
@@ -3170,11 +1548,36 @@ var GraphQLPlugin = class GraphQLPlugin {
 			...details
 		});
 	}
+	/**
+	* The `PluginHttpRoutes` contract: `HttpPlugin` starts draining, whatever the plugin order. The
+	* subscriptions of the engine end (a route-mounted driver serves them as streamed responses
+	* `HttpPlugin` does not close), and new ones are refused (503); queries and mutations in flight
+	* are served. Built-in SSE streams are closed by `HttpPlugin` itself.
+	*/
+	onHttpDrain() {
+		return this.#runtime?.executor.stopEngineStreams();
+	}
 	async onStop() {
 		this.#stop?.abort(/* @__PURE__ */ new Error("The application is stopping"));
-		await this.#runtime?.executor.stopDirect();
+		await this.#runtime?.executor.stopStreams();
+		if (this.#driver?.routes === void 0) await this.#stopDriver();
 	}
 	onDispose() {
+		if (!this.#started) {
+			this.#release();
+			return;
+		}
+		this.#stop?.abort(/* @__PURE__ */ new Error("The application is stopping"));
+		return Promise.resolve(this.#runtime?.executor.stopStreams()).then(() => this.#stopDriver()).finally(() => this.#release());
+	}
+	/** Stops the driver started in onBootstrap (once). */
+	#stopDriver() {
+		const driver = this.#driver;
+		if (!this.#started) return;
+		this.#started = false;
+		return driver?.stop?.();
+	}
+	#release() {
 		this.#active = false;
 		this.#ownPubSub?.close();
 		this.#ownPubSub = void 0;
@@ -3187,6 +1590,14 @@ var GraphQLPlugin = class GraphQLPlugin {
 	get schema() {
 		return this.#ready().schema;
 	}
+	/**
+	* The GraphQL engine (after bootstrap, RFC 0009): graphql-js-shaped `parse`, `validate`, `execute`
+	* and `subscribe` running this plugin's schema with its guards, loaders, request scope, error
+	* formatting and hook. What drivers receive in `start()`; any GraphQL server can call it.
+	*/
+	get engine() {
+		return this.#ready().engine;
+	}
 	/** The SDL of the schema (graphql-js `printSchema`). */
 	printSchema() {
 		return printSchema(this.#ready().schema);
@@ -3239,6 +1650,21 @@ var GraphQLPlugin = class GraphQLPlugin {
 		this.#resolved = resolveGraphQLOptions(resolveOptions(this.#options, container));
 		return this.#resolved;
 	}
+	/** The driver of the application: the `driver` option, or the built-in transport. */
+	#driverOf(options) {
+		let driver = this.#driver;
+		if (driver === void 0) {
+			const http = options.http;
+			driver = options.driver ?? new BuiltinDriver({
+				executor: () => this.#ready().executor,
+				get: http !== false && http.get,
+				graphiql: options.graphiql,
+				sse: sseOptions(options)
+			});
+			this.#driver = driver;
+		}
+		return driver;
+	}
 	/** The SSE options are those of `HttpResponse.sse()` (heartbeat and maxDuration from 1 000 ms): checked at boot. */
 	#checkSse(options) {
 		const sse = sseOptions(options);
@@ -3247,6 +1673,8 @@ var GraphQLPlugin = class GraphQLPlugin {
 		if (problem !== void 0) throw invalidOption("subscriptions", `valid event stream options (${problem})`, sse);
 	}
 	#checkHttp(ctx, options) {
+		const driver = options.driver;
+		if (options.http === false && driver?.routes !== void 0) throw new ZnightError(ErrorCode.InvalidGraphQLSetup, `GraphQLPlugin: the ${driver.name} driver serves routes, which http: false turns off`, { hints: ["Remove http: false: the driver serves the endpoint through HttpPlugin"] });
 		if (options.http !== false && ctx.getPlugin("http") === void 0) throw new ZnightError(ErrorCode.InvalidGraphQLSetup, "GraphQLPlugin serves its endpoint through HttpPlugin, which is not registered", { hints: ["Add HttpPlugin.configure() to the plugins of the application", "Or set http: false to use the schema and execute() only"] });
 	}
 	#build(ctx, options) {
@@ -3296,6 +1724,7 @@ var GraphQLPlugin = class GraphQLPlugin {
 			globalGuards: globalGuards.map((guard) => guard.resolvable),
 			guard: (token, coordinate) => providers.token(token, `guard of ${coordinate}`, "canResolve"),
 			resolver: (binding, coordinate) => providers.token(binding.token, `resolver of ${coordinate}`, binding.method),
+			paramResolver: (token, coordinate) => providers.token(token, `parameter resolver of ${coordinate}`, "resolve"),
 			inputs,
 			results: (field, coordinate) => results.recover(field, coordinate)
 		}));
@@ -3321,8 +1750,22 @@ var GraphQLPlugin = class GraphQLPlugin {
 			limits: options.limits,
 			introspection: options.introspection,
 			documentCache: options.documentCache,
-			maxActiveSubscriptions: options.subscriptions === false ? void 0 : options.subscriptions.maxActive
+			maxActiveSubscriptions: options.subscriptions === false ? void 0 : options.subscriptions.maxActive,
+			subscriptions: options.subscriptions !== false
 		});
+		const http = ctx.getPlugin("http");
+		const engine = new Engine(executor, {
+			path: this.#endpoint ?? endpointPath(options.http === false || http === void 0 ? "" : http.prefix, options.path),
+			introspection: options.introspection,
+			ide: options.graphiql,
+			exposeErrors: options.exposeErrors,
+			maxTokens: options.limits.maxTokens,
+			subscriptions: options.subscriptions === false ? false : { maxActive: options.subscriptions.maxActive },
+			http: options.http === false ? false : {
+				get: options.http.get,
+				bodyLimit: options.http.bodyLimit
+			}
+		}, options.driver?.name ?? "builtin");
 		ctx.logger.debug("GraphQL schema built", {
 			types: types.length,
 			schemaHash: section.schemaHash,
@@ -3331,7 +1774,8 @@ var GraphQLPlugin = class GraphQLPlugin {
 		return {
 			schema,
 			section,
-			executor
+			executor,
+			engine
 		};
 	}
 };
@@ -3344,6 +1788,26 @@ function direct(options) {
 	};
 }
 const DIRECT = Object.freeze({ transport: "direct" });
+/** A route of the driver as a plugin route: the `http` option's meta and guards, its body limit unless `GET`. */
+function mount(route, http, driver) {
+	if (route === null || typeof route !== "object" || typeof route.handler !== "function") throw invalidOption(`routes() of the ${driver.name} driver`, "routes { method, path, name, handler }", route);
+	return {
+		method: route.method,
+		path: route.path,
+		name: route.name,
+		handler: route.handler,
+		...http.meta.length === 0 ? {} : { meta: http.meta },
+		...http.guards.length === 0 ? {} : { guards: http.guards },
+		...route.method === "GET" || route.method === "HEAD" ? {} : { bodyLimit: http.bodyLimit }
+	};
+}
+/** ZNIGHT066 for a driver whose `start()` failed, the original error as `cause`. */
+function driverFailed(driver, error) {
+	return new ZnightError(ErrorCode.InvalidGraphQLSetup, `GraphQLPlugin: the ${driver.name} driver failed to start`, {
+		cause: error,
+		hints: ["See the cause: the driver could not create its server"]
+	});
+}
 /** `prefix` (`''`, `/api`) joined with `path` (`/graphql`), without trailing slash: `/api/graphql`. */
 function endpointPath(prefix, path) {
 	const joined = `${prefix.replace(/\/+$/, "")}/${path.replace(/^\/+|\/+$/g, "")}`;
@@ -3440,6 +1904,6 @@ var DeferredPubSub = class extends PubSub {
 		return this.#target().subscribe(topic, options);
 	}
 };
-export { MemoryPubSub as a, GraphQLErrorCode as c, GraphQLTokens as i, GraphQLException as l, endpointOf as n, PubSub as o, executorOf as r, orderByKeys as s, GraphQLPlugin as t };
+export { PubSub as a, MemoryPubSub as i, endpointOf as n, orderByKeys as o, executorOf as r, GraphQLPlugin as t };
 
-//# sourceMappingURL=plugin-CR_wVfRU.mjs.map
+//# sourceMappingURL=plugin-BssB7wtn.mjs.map