@znight/graphql 0.2.1 → 0.3.0

package/dist/http-BWcayUtH.mjs

@@ -0,0 +1,2165 @@
+import { ErrorCode, ZnightError } from "@znight/core";
+import { HttpResponse, HttpTokens, ValidationException, isHttpException, parseMediaType } from "@znight/http";
+import { AbortedGraphQLExecutionError, GraphQLError, Kind, NoSchemaIntrospectionCustomRule, createSourceEventStream, execute, executeSubscriptionEvent, getNamedType, isObjectType, parse, print, specifiedRules, validate, validateSubscriptionArgs } 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;
+	}
+};
+// 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";
+	}
+	/** The driver that received the operation: `'builtin'` for the built-in transport and direct calls. */
+	get driver() {
+		return this.#options.driver ?? "builtin";
+	}
+	get serverContext() {
+		return this.#options.serverContext;
+	}
+	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;
+}
+/**
+* The limits as a graphql-js validation rule (`GraphQLEngine.rules`, RFC 0009), for GraphQL servers
+* that parse and validate documents themselves: the same check as {@link checkLimits}, run once on
+* the document node. `undefined` when every limit is disabled.
+*/
+function limitsRule(limits) {
+	if (limits.maxDepth === void 0 && limits.maxAliases === void 0 && limits.maxDirectives === void 0) return;
+	const rule = (context) => ({ Document(node) {
+		const errors = checkLimits(node, limits);
+		if (errors !== void 0) for (const error of errors) context.reportError(error);
+		return false;
+	} });
+	Object.defineProperty(rule, "name", { value: "ZnightDocumentLimitsRule" });
+	return rule;
+}
+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/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/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 = Object.freeze({});
+const NO_ERRORS = 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;
+	}
+};
+/** 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;
+	#subscriptions;
+	#streams = /* @__PURE__ */ new Set();
+	/**
+	* The streams the plugin ends in `onStop`: direct subscriptions and those of the engine. The SSE
+	* streams of the built-in transport are ended by `HttpPlugin`'s shutdown (with a `retry` hint).
+	*/
+	#owned = /* @__PURE__ */ new Set();
+	/** The streams of the engine (drivers), a part of {@link #owned}: ended when `HttpPlugin` drains. */
+	#engineStreams = /* @__PURE__ */ new Set();
+	/** The application stops (`HttpPlugin` drains, or the plugin stops): the engine refuses new subscriptions (503). */
+	#closing = false;
+	/** Subscriptions counted against `maxActive` while their source starts (not yet in `#streams`). */
+	#starting = 0;
+	/** The engine's extra rules (`GraphQLEngine.rules`): the limits, introspection. Built on first use. */
+	#engineRules;
+	/** The document limits as a rule, `undefined` when every limit is off. */
+	#limitsRule;
+	/** Documents parsed by {@link parseDocument}: within their limits, not checked again by validation. */
+	#limited = /* @__PURE__ */ new WeakSet();
+	/** Operations of the documents the engine executed, by document (the server's or the cache's). */
+	#documents = /* @__PURE__ */ new WeakMap();
+	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;
+		this.#subscriptions = options.subscriptions !== false;
+		this.#limitsRule = limitsRule(options.limits);
+	}
+	/** The schema operations run against. */
+	get schema() {
+		return this.#schema;
+	}
+	/** The engine's own validation rules (`GraphQLEngine.rules`): the limits, and introspection when it is off. */
+	get engineRules() {
+		let rules = this.#engineRules;
+		if (rules === void 0) {
+			const list = [];
+			if (this.#limitsRule !== void 0) list.push(this.#limitsRule);
+			if (this.#hideSuggestions) list.push(NoSchemaIntrospectionCustomRule);
+			rules = Object.freeze(list);
+			this.#engineRules = rules;
+		}
+		return rules;
+	}
+	/** 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) {
+		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) {
+		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;
+		}
+		if (this.#full()) return this.#reject(overflow(prepared), request, options);
+		const started = await this.#start(prepared, request, options, false);
+		return started instanceof Rejection ? started.response() : started;
+	}
+	/** Every slot of `subscriptions.maxActive` is taken (started streams and starting ones). */
+	#full() {
+		return this.#maxActive !== void 0 && this.#streams.size + this.#starting >= this.#maxActive;
+	}
+	/**
+	* Starts a subscription in the current scope (or in one of its own, open as long as the stream):
+	* the slot reserved, the context and the hook observer created, the source started. A rejection
+	* (variables) is observed and returned for the caller to answer.
+	*/
+	async #start(prepared, request, options, engine) {
+		let reserved = this.#maxActive !== void 0;
+		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, engine));
+			release();
+			if (stream instanceof Rejection) {
+				close();
+				observer?.end("rejected", stream.errors);
+			}
+			return stream;
+		} catch (error) {
+			release();
+			close();
+			observer?.end("error", void 0);
+			throw error;
+		}
+	}
+	/**
+	* Ends every subscription the plugin owns (plugin `onStop`): direct ones and those started
+	* through the engine (drivers). Built-in SSE streams end with `HttpPlugin`'s shutdown.
+	*/
+	async stopStreams() {
+		this.#closing = true;
+		await Promise.all([...this.#owned].map((stream) => stream.return()));
+	}
+	/**
+	* Ends the subscriptions of the engine (`HttpPlugin` drains, `GraphQLPlugin.onHttpDrain()`): a
+	* driver serves them as streamed responses `HttpPlugin` does not close. New ones are refused (503).
+	*/
+	async stopEngineStreams() {
+		this.#closing = true;
+		await Promise.all([...this.#engineStreams].map((stream) => stream.return()));
+	}
+	/** Forgets every cached document. */
+	clear() {
+		this.#cache.clear();
+	}
+	/**
+	* `GraphQLEngine.parse`: the document of the cache for a valid text, otherwise the text parsed
+	* with `maxTokens` and checked against the depth, aliases and directives limits. Throws a
+	* `GraphQLError` (`GRAPHQL_PARSE_FAILED`, `QUERY_TOO_COMPLEX`), observed as a rejected operation.
+	*/
+	parseDocument(source, driver) {
+		const text = typeof source === "string" ? source : source?.body;
+		if (typeof text === "string") {
+			const cached = this.#cache.get(text);
+			if (cached !== void 0) return cached.document;
+		}
+		let document;
+		try {
+			document = parse(source, this.#maxTokens === void 0 ? void 0 : { maxTokens: this.#maxTokens });
+		} catch (error) {
+			if (!(error instanceof GraphQLError)) throw error;
+			const failed = coded(error, GraphQLErrorCode.ParseFailed);
+			this.#rejectedDocument([failed], text, driver);
+			throw failed;
+		}
+		const limited = checkLimits(document, this.#limits);
+		if (limited !== void 0) {
+			this.#rejectedDocument(limited, text, driver);
+			throw limited[0];
+		}
+		this.#limited.add(document);
+		return document;
+	}
+	/**
+	* `GraphQLEngine.validate`: `rules` (default: graphql-js `specifiedRules`) plus the engine's own
+	* (the limits, unless {@link parseDocument} checked them, and introspection), with
+	* `hideSuggestions` when introspection is off. With the default rules on the engine's schema, a
+	* cached document is not validated again, and a valid one enters the document cache. Errors carry
+	* `GRAPHQL_VALIDATION_FAILED` (or the limit's code) and are observed as a rejected operation.
+	*/
+	validateDocument(schema, document, rules, driver) {
+		const standard = rules === void 0 || isSpecifiedRules(rules);
+		const cacheable = standard && schema === this.#schema;
+		const text = document.loc?.source.body;
+		if (cacheable && text !== void 0 && this.#cache.get(text)?.document === document) return NO_ERRORS;
+		const limited = this.#limited.has(document);
+		let all;
+		if (standard) all = limited || this.#limitsRule === void 0 ? this.#rules : [this.#limitsRule, ...this.#rules];
+		else {
+			const merged = new Set(limited ? rules : [...this.engineRules, ...rules]);
+			for (const rule of this.engineRules) merged.add(rule);
+			if (limited && this.#limitsRule !== void 0) merged.delete(this.#limitsRule);
+			all = [...merged];
+		}
+		const errors = validate(schema, document, all, { hideSuggestions: this.#hideSuggestions });
+		if (errors.length === 0) {
+			if (cacheable && text !== void 0) {
+				const entry = new CachedDocument(text, document);
+				this.#cache.set(text, entry);
+				this.#documents.set(document, entry);
+			}
+			return NO_ERRORS;
+		}
+		const failed = errors.map((error) => coded(error, error.extensions["code"] === void 0 ? GraphQLErrorCode.ValidationFailed : void 0));
+		this.#rejectedDocument(failed, text, driver);
+		return failed;
+	}
+	/**
+	* `GraphQLEngine.execute`: a validated query or mutation of `args.document`, in the current
+	* request scope (or one of its own), with the operation's `GraphQLContext` as `contextValue`
+	* (`args.contextValue` becomes `serverContext`). The result is graphql-js's, its errors mapped
+	* and masked, as `GraphQLError` instances without `originalError`. Without `options.signal`, an
+	* execution that turns asynchronous follows `GraphQLContext.signal` (the HTTP request's).
+	*/
+	executeDocument(args, options) {
+		const prepared = this.#prepareDocument(args);
+		if (prepared instanceof Rejection) return asEngineResult(this.#reject(prepared, requestOf(args), options));
+		if (prepared.operation.operation === "subscription") return asEngineResult(this.#reject(new Rejection(400, [requestError("Subscriptions are started with GraphQLEngine.subscribe()", GraphQLErrorCode.BadRequest)], prepared.entry.id, prepared.operation), requestOf(args), options));
+		const request = {
+			query: prepared.entry.query,
+			operationName: args.operationName,
+			variables: args.variableValues
+		};
+		let abort;
+		let effective = options;
+		if (options.signal === void 0) {
+			abort = new DeferredAbort();
+			effective = {
+				...options,
+				abortSignal: abort.asSignal()
+			};
+		}
+		const scope = this.#container.currentScope();
+		const ctx = this.#context(prepared, request, effective, scope);
+		const run = () => this.#runEngine(prepared, request, effective, ctx, args.rootValue);
+		const hooks = this.#hooks;
+		const response = !hooks.hasWrappers(OPERATION_HOOK) && !hooks.hasListeners(OPERATION_HOOK) ? this.#inScope(scope, ctx, run) : this.#inScope(scope, ctx, () => this.#observed(ctx, prepared.entry.id, run));
+		if (!isPromise$1(response)) return response.result;
+		abort?.follow(() => ctx.signal);
+		return response.then(resultOf);
+	}
+	/**
+	* `GraphQLEngine.subscribe`: starts a validated subscription, a stream of graphql-js results (its
+	* loaders renewed per event), or a single error result (rejected, past `maxActive`, a source that
+	* could not start). A query or a mutation is executed: its single result. The stream ends with
+	* `return()`, `options.signal` (default: the HTTP request's), its source, or the plugin's stop.
+	*/
+	async subscribeDocument(args, options) {
+		const prepared = this.#prepareDocument(args);
+		if (prepared instanceof Rejection) return asEngineResult(this.#reject(prepared, requestOf(args), options));
+		if (prepared.operation.operation !== "subscription") return this.executeDocument(args, options);
+		if (!this.#subscriptions) return asEngineResult(this.#reject(new Rejection(400, [requestError("Subscriptions are disabled on this server", GraphQLErrorCode.BadRequest)], prepared.entry.id, prepared.operation), requestOf(args), options));
+		if (this.#full() || this.#closing) return asEngineResult(this.#reject(unavailable(prepared, this.#closing), requestOf(args), options));
+		const request = {
+			query: prepared.entry.query,
+			operationName: args.operationName,
+			variables: args.variableValues
+		};
+		let effective = options;
+		if (options.signal === void 0) {
+			const http = this.#container.currentScope()?.get(HttpTokens.Context);
+			if (http !== void 0) effective = {
+				...options,
+				signal: http.signal
+			};
+		}
+		const started = await this.#start(prepared, request, effective, true);
+		if (started instanceof Rejection) return { errors: started.errors.map(fromFormatted) };
+		return started;
+	}
+	/** The document of `args` and its operation, or a rejection (operation selection). */
+	#prepareDocument(args) {
+		if (args?.schema !== this.#schema) throw new ZnightError(ErrorCode.InvalidGraphQLSetup, "GraphQLEngine: the operation targets another schema than the engine's (ExecutionArgs.schema)", { hints: ["Give the GraphQL server engine.schema: its resolvers are the engine's pipelines"] });
+		const document = args.document;
+		let entry = this.#documents.get(document);
+		if (entry === void 0) {
+			const text = document.loc?.source.body;
+			const cached = text === void 0 ? void 0 : this.#cache.get(text);
+			entry = cached !== void 0 && cached.document === document ? cached : new CachedDocument(text ?? print(document), document);
+			this.#documents.set(document, entry);
+		}
+		const operationName = args.operationName;
+		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);
+		}
+		return {
+			entry,
+			operation
+		};
+	}
+	#runEngine(prepared, request, options, ctx, rootValue) {
+		let result;
+		try {
+			result = execute({
+				schema: this.#schema,
+				document: prepared.entry.document,
+				rootValue,
+				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$1(result)) return result.then((settled) => this.#respondEngine(settled, ctx), (error) => Promise.reject(abortReason(error, options)));
+		return this.#respondEngine(result, ctx);
+	}
+	/** {@link #respond} for the engine: the errors as `GraphQLError` instances. */
+	#respondEngine(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((error) => coded(error, error.extensions["code"] === void 0 ? GraphQLErrorCode.BadUserInput : void 0)) }
+		};
+		return {
+			status: 200,
+			result: {
+				data: result.data,
+				errors: asGraphQLErrors(errors, this.#formatter.format(errors, ctx)),
+				...result.extensions === void 0 ? {} : { extensions: result.extensions }
+			}
+		};
+	}
+	/** A document rejected by {@link parseDocument} or {@link validateDocument}, for the hook. */
+	#rejectedDocument(errors, text, driver) {
+		const hooks = this.#hooks;
+		const wrapped = hooks.hasWrappers(OPERATION_HOOK);
+		if (!wrapped && !hooks.hasListeners(OPERATION_HOOK)) return;
+		const event = {
+			operationType: void 0,
+			operationName: void 0,
+			documentId: text === void 0 ? void 0 : documentId(text),
+			transport: "http",
+			driver,
+			requestId: this.#scopedRequestId(),
+			context: void 0,
+			startTime: performance.now(),
+			outcome: "rejected",
+			errors: summaries(errors)
+		};
+		if (!wrapped) {
+			hooks.emit(OPERATION_HOOK, event);
+			return;
+		}
+		hooks.run(OPERATION_HOOK, event, () => Promise.resolve()).then(() => {
+			if (hooks.hasListeners(OPERATION_HOOK)) hooks.emit(OPERATION_HOOK, event);
+		}, (error) => this.#runtimeLogError("A \"graphql:operation\" hook wrapper failed", error));
+	}
+	/** 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$1(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$1(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)
+		};
+	}
+	/** {@link formatEvent} for the engine: the errors formatted, then given back as `GraphQLError` instances. */
+	engineEvent(result, ctx) {
+		const errors = result.errors;
+		if (errors === void 0) return result;
+		return {
+			..."data" in result ? { data: result.data } : {},
+			errors: asGraphQLErrors(errors, this.#formatter.format(errors, ctx))
+		};
+	}
+	/**
+	* Starts the source of a subscription. `engine`: the results are graphql-js results
+	* ({@link engineEvent}) and a source that could not start is an error result instead of a stream
+	* of one result.
+	*/
+	#startSubscription(prepared, request, options, ctx, observer, run, close, release, engine) {
+		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)) {
+				if (engine) {
+					const result = this.engineEvent(source, ctx);
+					close();
+					observer?.end("error", result.errors);
+					return result;
+				}
+				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),
+				engine,
+				onEnd: (outcome, errors) => {
+					this.#streams.delete(stream);
+					this.#owned.delete(stream);
+					if (engine) this.#engineStreams.delete(stream);
+					close();
+					observer?.end(outcome, errors);
+				}
+			});
+			this.#streams.add(stream);
+			if (engine || ctx.transport === "direct") this.#owned.add(stream);
+			if (engine) {
+				this.#engineStreams.add(stream);
+				if (this.#closing) stream.return();
+			}
+			return stream;
+		};
+		const source = createSourceEventStream(validated);
+		return isPromise$1(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",
+			driver: options.driver ?? "builtin",
+			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$1(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 });
+	}
+};
+/** The 503 of a subscription past `subscriptions.maxActive`. */
+function overflow(prepared) {
+	return new Rejection(503, [requestError("Too many active subscriptions, retry later", GraphQLErrorCode.ServiceUnavailable)], prepared.entry.id, prepared.operation);
+}
+/** The 503 of an engine subscription past `subscriptions.maxActive`, or while the application stops. */
+function unavailable(prepared, closing) {
+	if (!closing) return overflow(prepared);
+	return new Rejection(503, [requestError("The server is shutting down, retry later", GraphQLErrorCode.ServiceUnavailable)], prepared.entry.id, prepared.operation);
+}
+/** Whether `rules` are graphql-js `specifiedRules` (the same list, or a copy of it). */
+function isSpecifiedRules(rules) {
+	if (rules === specifiedRules) return true;
+	if (rules.length !== specifiedRules.length) return false;
+	for (let index = 0; index < rules.length; index++) if (rules[index] !== specifiedRules[index]) return false;
+	return true;
+}
+/** The request of engine arguments, for the hook of a rejection (its operation name). */
+function requestOf(args) {
+	return {
+		query: "",
+		operationName: args.operationName
+	};
+}
+function resultOf(response) {
+	return response.result;
+}
+/** `error` with `extensions.code` set to `code` (as is without code), without its original error. */
+function coded(error, code) {
+	if (code === void 0) return error;
+	return new GraphQLError(error.message, {
+		nodes: error.nodes,
+		source: error.source,
+		positions: error.positions,
+		path: error.path,
+		extensions: {
+			...error.extensions,
+			code
+		}
+	});
+}
+/**
+* The formatted errors of an execution as `GraphQLError` instances (RFC 0009 §4.2, rule 5): the
+* formatted message and extensions, the locations and path of the error they come from, no
+* `originalError` (servers such as Apollo Server wrap anything that is not an `Error`).
+*/
+function asGraphQLErrors(originals, formatted) {
+	const errors = new Array(formatted.length);
+	for (let index = 0; index < formatted.length; index++) {
+		const original = originals[index];
+		const shown = formatted[index];
+		errors[index] = new GraphQLError(shown.message, {
+			nodes: original.nodes,
+			source: original.source,
+			positions: original.positions,
+			path: original.path,
+			extensions: shown.extensions
+		});
+	}
+	return errors;
+}
+/** A request error (formatted, without location) as a `GraphQLError`. */
+function fromFormatted(error) {
+	return new GraphQLError(error.message, {
+		path: error.path,
+		extensions: error.extensions
+	});
+}
+/** A rejection answered to the engine: a result of `GraphQLError`s. */
+function asEngineResult(response) {
+	const settle = (settled) => ({ errors: (settled.result.errors ?? []).map(fromFormatted) });
+	return isPromise$1(response) ? response.then(settle) : settle(response);
+}
+function noop() {}
+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) {
+	return {
+		operationType: ctx.operationType,
+		operationName: ctx.operationName,
+		documentId: id,
+		transport: ctx.transport,
+		driver: ctx.driver,
+		requestId: ctx.requestId,
+		context: ctx,
+		startTime: performance.now()
+	};
+}
+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$1(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`. `R` is
+* `FormattedExecutionResult` for the transports (`GraphQLResultStream`), `ExecutionResult` for the
+* engine (`EngineStream`).
+*
+* 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);
+		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--;
+		}
+	}
+	/** A result of the subscription, formatted for its consumer. */
+	#format(result) {
+		const init = this.#init;
+		return init.engine ? init.executor.engineEvent(result, init.ctx) : init.executor.formatEvent(result, init.ctx);
+	}
+	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 = this.#format({ errors: [new GraphQLError(errorMessage(error), {
+				originalError: asError(error),
+				path: init.field === void 0 ? void 0 : [init.field]
+			})] });
+			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 = this.#format(isPromise$1(executed) ? await executed : executed);
+		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);
+			else await returned;
+		} catch {}
+		return DONE$1;
+	}
+	throw() {
+		return this.return();
+	}
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+	/** `await using`: ends the stream (an `AsyncGenerator` is disposable). */
+	async [Symbol.asyncDispose]() {
+		await this.return();
+	}
+	#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/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" }));
+/**
+* Whether a `POST` body is JSON (`application/json`, UTF-8): the only body the endpoint takes (and
+* the Yoga driver), so that a cross-site request, which cannot send it without a CORS preflight,
+* never executes an operation. `content-type` values seen most often are 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";
+}
+/** The 415 of a `POST` body that is not JSON, in the negotiated JSON type. */
+function notJson(media) {
+	return errorReply(media, 415, errorBody("Send GraphQL requests as application/json (content-type: application/json)"));
+}
+/** 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(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;
+	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 notJson(media);
+		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);
+	}
+	/**
+	* 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(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));
+		});
+	}
+	/** 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));
+		});
+	}
+	#bind() {
+		this.#executor = this.#resolveExecutor();
+		return this.#executor;
+	}
+};
+/**
+* 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);
+	}
+}
+export { Media as a, singleResult as c, resolveIn as d, GraphQLErrorCode as f, notJson as i, GraphQLTokens as l, checkSseOptions as n, negotiate as o, GraphQLException as p, isJsonRequest as r, GraphQLExecutor as s, HttpTransport as t, ErrorFormatter as u };
+
+//# sourceMappingURL=http-BWcayUtH.mjs.map