@fruggr/zendesk-mcp-server 3.7.0 → 3.8.0

package/dist/index.js

@@ -7911,6 +7911,11 @@ const ConfigSchema = object({
 	oauthMasterSecretFile: string().min(1).optional(),
 	/** HTTP only: the grant store URI; defaults to a file in the config dir. */
 	oauthStore: string().url().optional(),
+	/**
+	* HTTP only: where the admins' instructions, prompts and skills live
+	* (`file://<dir>` or `memory://`); defaults to a folder in the config dir.
+	*/
+	customizationStore: string().url().optional(),
 	/** HTTP only: CIMD client ids added to the consent-skip allowlist. */
 	oauthTrustedClients: array(string().url()).default([]),
 	/** HTTP only: whether the built-in allowlist (claude.ai, ChatGPT) applies. */
@@ -8014,6 +8019,7 @@ const CLI_OPTIONS = {
 	"callback-port": { type: "string" },
 	"oauth-master-secret-file": { type: "string" },
 	"oauth-store": { type: "string" },
+	"customization-store": { type: "string" },
 	"oauth-trusted-client": {
 		type: "string",
 		multiple: true
@@ -8045,6 +8051,7 @@ const FIELD_BY_FLAG = /* @__PURE__ */ new Map([
 	["cors-origin", "corsOrigins"],
 	["oauth-master-secret-file", "oauthMasterSecretFile"],
 	["oauth-store", "oauthStore"],
+	["customization-store", "customizationStore"],
 	["oauth-trusted-client", "oauthTrustedClients"],
 	["sla-reply-thresholds", "slaReplyThresholds"],
 	["sla-wait-thresholds", "slaWaitThresholds"],
@@ -8112,6 +8119,7 @@ const resolveOAuthServerSettings = (cli) => ({
 	oauthMasterSecret: requireNonEmptyEnv("OAUTH_MASTER_SECRET"),
 	oauthMasterSecretFile: cli.oauthMasterSecretFile ?? requireNonEmptyEnv("OAUTH_MASTER_SECRET_FILE"),
 	oauthStore: cli.oauthStore ?? requireNonEmptyEnv("OAUTH_STORE"),
+	customizationStore: cli.customizationStore ?? requireNonEmptyEnv("CUSTOMIZATION_STORE"),
 	oauthTrustedClients: [...cli.oauthTrustedClients ?? [], ...splitList(readEnv("OAUTH_TRUSTED_CLIENTS").value)],
 	defaultTrustedClients: cli.defaultTrustedClients
 });
@@ -8383,7 +8391,7 @@ const buildHelpCenterInstructions = (config) => {
 	].join("\n");
 };
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+server@2.3.1/node_modules/@modelcontextprotocol/server/dist/chunk-Br0eD_fh.mjs
+//#region node_modules/.pnpm/@modelcontextprotocol+server@2.4.0/node_modules/@modelcontextprotocol/server/dist/chunk-vYduTEsO.mjs
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -8415,7 +8423,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+server@2.3.1/node_modules/@modelcontextprotocol/server/dist/dialects-DoSzNhcb.mjs
+//#region node_modules/.pnpm/@modelcontextprotocol+server@2.4.0/node_modules/@modelcontextprotocol/server/dist/dialects-CDpMbily.mjs
 /**
 * Canonical `$schema` URIs per supported dialect (http + https variants, trailing-`#` stripped).
 */
@@ -9875,6 +9883,8 @@ const ServerResultSchema = union([
 	ListToolsResultSchema,
 	SubscriptionsListenResultSchema
 ]);
+//#endregion
+//#region node_modules/.pnpm/@modelcontextprotocol+core@2.4.0/node_modules/@modelcontextprotocol/core/dist/auth-UMQCo-ad.mjs
 /**
 * Reusable URL validation that disallows `javascript:` scheme
 */
@@ -10078,7 +10088,7 @@ const OAuthTokenRevocationRequestSchema = object({
 	token_type_hint: string().optional()
 }).strip();
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+server@2.3.1/node_modules/@modelcontextprotocol/server/dist/src-Cqbh3MYc.mjs
+//#region node_modules/.pnpm/@modelcontextprotocol+server@2.4.0/node_modules/@modelcontextprotocol/server/dist/src-DdvbAHrR.mjs
 /**
 * Cross-bundle `instanceof` support for the SDK error classes.
 *
@@ -14457,25 +14467,22 @@ const X_MCP_HEADER_KEY = "x-mcp-header";
 */
 const RFC9110_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
 /**
-* JSON Schema `type` values the spec admits on an `x-mcp-header` property.
-*
-* The spec text names `integer`, `string`, `boolean` and explicitly excludes
-* `number`. The published conformance referee at the pinned release ships its
-* `http-custom-headers` scenario with two `type: "number"` `x-mcp-header`
-* parameters and expects the client to mirror them, so `number` is accepted
-* here so that the conformance gate passes; the discrepancy is tracked
-* upstream. Everything else (`object`, `array`, `null`, absent) is rejected.
+* JSON Schema `type` values the spec admits on an `x-mcp-header` property:
+* `integer`, `string` and `boolean`. `number` is explicitly not permitted
+* (2026-07-28 Streamable HTTP, "Schema Extension"), so a tool that annotates a
+* `number`-typed property is invalid (the server still checks its headers).
+* Everything else (`object`, `array`, `null`, absent) is rejected too.
 */
 const PERMITTED_X_MCP_HEADER_TYPES = /* @__PURE__ */ new Set([
 	"string",
 	"integer",
-	"boolean",
-	"number"
+	"boolean"
 ]);
 /**
 * Scan a tool's JSON-serialized `inputSchema` for `x-mcp-header` declarations
 * and validate every constraint the spec places on them. Returns either the
-* collected declarations (possibly empty) or the first violated constraint.
+* collected declarations (possibly empty) or the first violated constraint
+* (with the declarations too, when `number`-typed declarations are the only fault).
 *
 * The walk descends through `properties` at any depth (the spec's "any nesting
 * depth" clause). The static-reachability MUST is enforced as a structural
@@ -14488,6 +14495,7 @@ const PERMITTED_X_MCP_HEADER_TYPES = /* @__PURE__ */ new Set([
 function scanXMcpHeaderDeclarations(inputSchema) {
 	const declarations = [];
 	const seenLower = /* @__PURE__ */ new Map();
+	let numberFault;
 	const visit = (node, path, reachable) => {
 		if (node === null || typeof node !== "object") return void 0;
 		const schema = node;
@@ -14497,7 +14505,11 @@ function scanXMcpHeaderDeclarations(inputSchema) {
 			if (typeof raw !== "string" || raw.length === 0) return `${pathName(path)}: x-mcp-header MUST be a non-empty string`;
 			if (!RFC9110_TOKEN.test(raw)) return `${pathName(path)}: x-mcp-header '${raw}' is not a valid RFC 9110 token (no spaces, control characters or HTTP delimiters)`;
 			const type = typeof schema.type === "string" ? schema.type : void 0;
-			if (type === void 0 || !PERMITTED_X_MCP_HEADER_TYPES.has(type)) return `${pathName(path)}: x-mcp-header is only permitted on primitive-typed properties (string, integer, boolean); got ${type ?? "<none>"}`;
+			if (type === void 0 || !PERMITTED_X_MCP_HEADER_TYPES.has(type)) {
+				const fault$1 = `${pathName(path)}: x-mcp-header is only permitted on primitive-typed properties (string, integer, boolean); got ${type ?? "<none>"}`;
+				if (type !== "number") return fault$1;
+				numberFault ??= fault$1;
+			}
 			const lower = raw.toLowerCase();
 			const prior = seenLower.get(lower);
 			if (prior !== void 0) return `x-mcp-header '${raw}' is not case-insensitively unique (also declared as '${prior}')`;
@@ -14524,12 +14536,17 @@ function scanXMcpHeaderDeclarations(inputSchema) {
 		}
 	};
 	const fault = visit(inputSchema, [], true);
-	return fault === void 0 ? {
+	if (fault !== void 0) return {
+		valid: false,
+		reason: numberFault ?? fault
+	};
+	return numberFault === void 0 ? {
 		valid: true,
 		declarations
 	} : {
 		valid: false,
-		reason: fault
+		reason: numberFault,
+		declarations
 	};
 }
 /**
@@ -14632,7 +14649,7 @@ function valueAtPath(root, path) {
 * A sentinel-carrying header whose payload is not canonical Base64 / valid
 * UTF-8 is rejected as invalid characters.
 *
-* Integer-typed declarations are compared numerically (the spec's SHOULD —
+* Integer- and number-typed declarations are compared numerically (the spec's SHOULD —
 * `42.0` and `42` are equal); everything else is compared as decoded strings.
 *
 * Returns `undefined` when every check passes, or an
@@ -15202,22 +15219,26 @@ function standardSchemaToJsonSchema(schema, io = "input") {
 		...result
 	};
 }
+const LOCAL_DEFINITION_REF = /^#\/(\$defs|definitions)\/([^/~%]+)$/;
 /**
 * A typeless JSON Schema root is "provably object-shaped" when either it carries object keywords
 * directly (`properties`/`patternProperties`/`additionalProperties`/`required`), or it is a
 * composition (`oneOf`/`anyOf`/`allOf`) whose every member is itself `type:'object'` or recursively
-* provably object-shaped (e.g. a nested `discriminatedUnion`). `$ref` is not followed. Used to
+* provably object-shaped (e.g. a nested `discriminatedUnion`). A `$ref` is followed one hop, to an
+* entry of the root's `$defs`/`definitions` that is itself `type:'object'`. Used to
 * decide whether stamping `type:'object'` is safe (redundant-but-valid) versus self-contradictory.
 */
-function isProvablyObjectShapedRoot(schema) {
+function isProvablyObjectShapedRoot(schema, root = schema) {
 	if ("properties" in schema || "patternProperties" in schema || "additionalProperties" in schema || "required" in schema) return true;
+	const ref = typeof schema.$ref === "string" && LOCAL_DEFINITION_REF.exec(schema.$ref);
+	if (ref && root[ref[1]]?.[ref[2]]?.type === "object") return true;
 	for (const key of [
 		"oneOf",
 		"anyOf",
 		"allOf"
 	]) {
 		const members = schema[key];
-		if (Array.isArray(members) && members.length > 0) return members.every((m) => m !== null && typeof m === "object" && (m.type === "object" || isProvablyObjectShapedRoot(m)));
+		if (Array.isArray(members) && members.length > 0) return members.every((m) => m !== null && typeof m === "object" && (m.type === "object" || isProvablyObjectShapedRoot(m, "$id" in m ? {} : root)));
 	}
 	return false;
 }
@@ -17187,7 +17208,7 @@ function normalizeRawShapeSchema(schema) {
 	return schema;
 }
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+server@2.3.1/node_modules/@modelcontextprotocol/server/dist/ajvProvider-CEoC__sr.mjs
+//#region node_modules/.pnpm/@modelcontextprotocol+server@2.4.0/node_modules/@modelcontextprotocol/server/dist/ajvProvider-DyjnscPj.mjs
 var require_code$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = void 0;
@@ -19865,6 +19886,28 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
 	/** @type {(value: string) => boolean} */
 	const isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+	/** @type {(value: string) => boolean} */
+	const isPort = RegExp.prototype.test.bind(/^\d*$/u);
+	/** @type {(value: string) => boolean} */
+	const isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
+	/** @type {(value: string) => boolean} */
+	const isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
+	/** @type {(value: string) => boolean} */
+	const isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
+	/** @type {(value: string) => boolean} */
+	const isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
+	/** @type {(value: string) => boolean} */
+	const isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
+	const BYTE_HEX = new Array(256);
+	{
+		const HEX_DIGITS = "0123456789ABCDEF";
+		for (let i = 0; i < 256; i++) BYTE_HEX[i] = "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
+	}
+	function percentEncodeNonAscii(cp) {
+		if (cp < 2048) return BYTE_HEX[192 | cp >> 6] + BYTE_HEX[128 | cp & 63];
+		if (cp < 65536) return BYTE_HEX[224 | cp >> 12] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+		return BYTE_HEX[240 | cp >> 18] + BYTE_HEX[128 | cp >> 12 & 63] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+	}
 	/**
 	* @param {Array<string>} input
 	* @returns {string}
@@ -19887,119 +19930,162 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 		return acc;
 	}
-	/**
-	* @typedef {Object} GetIPV6Result
-	* @property {boolean} error - Indicates if there was an error parsing the IPv6 address.
-	* @property {string} address - The parsed IPv6 address.
-	* @property {string} [zone] - The zone identifier, if present.
-	*/
+	/** @type {(value: string) => boolean} */
+	const isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
+	/** @type {(value: string) => boolean} */
+	const isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
+	/** @type {(value: string) => boolean} */
+	const isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
 	/**
 	* @param {string} value
 	* @returns {boolean}
 	*/
 	const nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
 	/**
-	* @param {Array<string>} buffer
+	* @param {string} zone
 	* @returns {boolean}
 	*/
-	function consumeIsZone(buffer) {
-		buffer.length = 0;
+	function isZoneIdentifier(zone) {
+		if (zone.length === 0) return false;
+		for (let i = 0; i < zone.length; i++) {
+			if (isZoneCharacter(zone[i])) continue;
+			if (zone[i] === "%" && i + 2 < zone.length && isHexPair(zone.slice(i + 1, i + 3))) {
+				i += 2;
+				continue;
+			}
+			return false;
+		}
 		return true;
 	}
 	/**
-	* @param {Array<string>} buffer
-	* @param {Array<string>} address
-	* @param {GetIPV6Result} output
-	* @returns {boolean}
+	* Compresses the longest run of zero hextets to "::" per RFC 5952. A run of a
+	* single zero hextet is left uncompressed. On ties the leftmost run wins.
+	*
+	* @param {string[]} hextets
+	* @returns {string}
 	*/
-	function consumeHextets(buffer, address, output) {
-		if (buffer.length) {
-			const hex = stringArrayToHexStripped(buffer);
-			if (hex !== "") address.push(hex);
-			else {
-				output.error = true;
-				return false;
+	function compressIPv6ZeroRun(hextets) {
+		let bestStart = -1;
+		let bestLength = 0;
+		let runStart = -1;
+		let runLength = 0;
+		for (let i = 0; i < hextets.length; i++) if (hextets[i] === "0") {
+			if (runStart === -1) runStart = i;
+			runLength++;
+			if (runLength > bestLength) {
+				bestLength = runLength;
+				bestStart = runStart;
 			}
-			buffer.length = 0;
+		} else {
+			runStart = -1;
+			runLength = 0;
 		}
-		return true;
+		if (bestLength < 2) return hextets.join(":");
+		const head = hextets.slice(0, bestStart).join(":");
+		const tail = hextets.slice(bestStart + bestLength).join(":");
+		return head + "::" + tail;
 	}
 	/**
+	* Validates an IPv6 address against the alternatives in RFC 3986 section
+	* 3.2.2 and returns the same address with leading hextet zeroes removed.
+	* An embedded IPv4 address counts as two hextets and is only valid at the end.
+	*
 	* @param {string} input
-	* @returns {GetIPV6Result}
-	*/
-	function getIPV6(input) {
-		let tokenCount = 0;
-		const output = {
-			error: false,
-			address: "",
-			zone: ""
-		};
-		/** @type {Array<string>} */
-		const address = [];
-		/** @type {Array<string>} */
-		const buffer = [];
-		let endipv6Encountered = false;
-		let endIpv6 = false;
-		let consume = consumeHextets;
-		for (let i = 0; i < input.length; i++) {
-			const cursor = input[i];
-			if (cursor === "[" || cursor === "]") continue;
-			if (cursor === ":") {
-				if (endipv6Encountered === true) endIpv6 = true;
-				if (!consume(buffer, address, output)) break;
-				if (++tokenCount > 7) {
-					output.error = true;
-					break;
-				}
-				if (i > 0 && input[i - 1] === ":") endipv6Encountered = true;
-				address.push(":");
-				continue;
-			} else if (cursor === "%") {
-				if (!consume(buffer, address, output)) break;
-				consume = consumeIsZone;
-			} else {
-				buffer.push(cursor);
+	* @returns {string|undefined}
+	*/
+	function normalizeIPv6Address(input) {
+		const compression = input.indexOf("::");
+		if (compression !== -1 && input.indexOf("::", compression + 1) !== -1) return void 0;
+		const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
+		const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
+		if (compression !== -1) {
+			if (left.length === 1 && left[0] === "") left.length = 0;
+			if (right.length === 1 && right[0] === "") right.length = 0;
+		}
+		const parts = left.concat(right);
+		let hextetCount = 0;
+		for (let i = 0; i < parts.length; i++) {
+			const part = parts[i];
+			if (part === "") return void 0;
+			if (part.indexOf(".") !== -1) {
+				if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part)) return void 0;
+				hextetCount += 2;
 				continue;
 			}
+			if (!isHextet(part)) return void 0;
+			parts[i] = parseInt(part, 16).toString(16);
+			hextetCount++;
 		}
-		if (buffer.length) if (consume === consumeIsZone) output.zone = buffer.join("");
-		else if (endIpv6) address.push(buffer.join(""));
-		else address.push(stringArrayToHexStripped(buffer));
-		output.address = address.join("");
-		return output;
+		if (compression === -1) {
+			if (hextetCount !== 8) return void 0;
+			return compressIPv6ZeroRun(parts);
+		}
+		if (hextetCount >= 8) return void 0;
+		const expanded = parts.slice(0, left.length);
+		for (let i = hextetCount; i < 8; i++) expanded.push("0");
+		for (let i = left.length; i < parts.length; i++) expanded.push(parts[i]);
+		return compressIPv6ZeroRun(expanded);
 	}
 	/**
 	* @typedef {Object} NormalizeIPv6Result
 	* @property {string} host - The normalized host.
 	* @property {string} [escapedHost] - The escaped host.
 	* @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.
+	* @property {boolean} [isIPVFuture] - Indicates if the host is an IPvFuture literal.
+	* @property {boolean} [error] - Indicates if a bracketed IP literal is malformed.
 	*/
 	/**
+	* Validates and normalizes a bracketed IP literal. Raw zone separators remain
+	* accepted for backwards compatibility, while encoded separators and zone
+	* contents follow RFC 6874.
+	*
 	* @param {string} host
 	* @returns {NormalizeIPv6Result}
 	*/
 	function normalizeIPv6(host) {
-		if (findToken(host, ":") < 2) return {
+		const bracketed = host[0] === "[" && host[host.length - 1] === "]";
+		if ((host[0] === "[" || host[host.length - 1] === "]") && !bracketed) return {
 			host,
-			isIPV6: false
+			isIPV6: false,
+			error: true
 		};
-		const ipv6 = getIPV6(host);
-		if (!ipv6.error) {
-			let newHost = ipv6.address;
-			let escapedHost = ipv6.address;
-			if (ipv6.zone) {
-				newHost += "%" + ipv6.zone;
-				escapedHost += "%25" + ipv6.zone;
-			}
+		let input = bracketed ? host.slice(1, -1) : host;
+		if (bracketed && isIPvFuture(input)) {
+			input = input.toLowerCase();
 			return {
-				host: newHost,
-				isIPV6: true,
-				escapedHost
+				host: `[${input}]`,
+				escapedHost: input,
+				isIPV6: false,
+				isIPVFuture: true
+			};
+		}
+		if (findToken(input, ":") < 2) return {
+			host,
+			isIPV6: false,
+			error: bracketed
+		};
+		let zoneIdentifier = "";
+		const zoneSeparator = input.indexOf("%");
+		if (zoneSeparator !== -1) {
+			const separatorLength = input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
+			zoneIdentifier = input.slice(zoneSeparator + separatorLength);
+			if (!isZoneIdentifier(zoneIdentifier)) return {
+				host,
+				isIPV6: false,
+				error: true
 			};
-		} else return {
+			input = input.slice(0, zoneSeparator);
+		}
+		const address = normalizeIPv6Address(input);
+		if (address === void 0) return {
 			host,
-			isIPV6: false
+			isIPV6: false,
+			error: true
+		};
+		return {
+			host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
+			escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
+			isIPV6: true
 		};
 	}
 	/**
@@ -20087,19 +20173,264 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		return output.join("");
 	}
 	/**
-	* @param {import('../types/index').URIComponent} component
-	* @param {boolean} esc
-	* @returns {import('../types/index').URIComponent}
+	* Re-escape RFC 3986 gen-delims that must not appear literally in the host.
+	* After the URI regex parses, these characters cannot be literal in the host
+	* field, so any that appear after decoding came from percent-encoding and
+	* must be restored to prevent authority structure changes.
+	*
+	* @param {string} host
+	* @param {boolean} isIP - true for IPv4/IPv6 hosts (skip colon re-escaping)
+	* @returns {string}
 	*/
-	function normalizeComponentEncoding(component, esc) {
-		const func = esc !== true ? escape : unescape;
-		if (component.scheme !== void 0) component.scheme = func(component.scheme);
-		if (component.userinfo !== void 0) component.userinfo = func(component.userinfo);
-		if (component.host !== void 0) component.host = func(component.host);
-		if (component.path !== void 0) component.path = func(component.path);
-		if (component.query !== void 0) component.query = func(component.query);
-		if (component.fragment !== void 0) component.fragment = func(component.fragment);
-		return component;
+	const HOST_DELIMS = {
+		"@": "%40",
+		"/": "%2F",
+		"?": "%3F",
+		"#": "%23",
+		":": "%3A"
+	};
+	const HOST_DELIM_RE = /[@/?#:]/g;
+	const HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
+	function reescapeHostDelimiters(host, isIP) {
+		const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
+		re.lastIndex = 0;
+		return host.replace(re, (ch) => HOST_DELIMS[ch]);
+	}
+	/**
+	* Normalizes percent escapes and optionally decodes only unreserved ASCII bytes.
+	* Reserved delimiters such as `%2F` stay escaped; `%2E` is unreserved.
+	*
+	* @param {string} input
+	* @param {boolean} [decodeUnreserved=false]
+	* @returns {string}
+	*/
+	function normalizePercentEncoding(input, decodeUnreserved = false) {
+		if (input.indexOf("%") === -1) return input;
+		let output = "";
+		for (let i = 0; i < input.length; i++) {
+			if (input[i] === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					const normalizedHex = hex.toUpperCase();
+					const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+					if (decodeUnreserved && isUnreserved(decoded)) output += decoded;
+					else output += "%" + normalizedHex;
+					i += 2;
+					continue;
+				}
+			}
+			output += input[i];
+		}
+		return output;
+	}
+	/**
+	* Normalizes path data without turning reserved escapes into live path syntax.
+	* Valid escapes are uppercased, raw unsafe characters are escaped, and only
+	* unreserved bytes that are not `.` are decoded.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function normalizePathEncoding(input) {
+		let output = "";
+		for (let i = 0; i < input.length; i++) {
+			const ch = input[i];
+			if (ch === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					const normalizedHex = hex.toUpperCase();
+					const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+					if (decoded !== "." && isUnreserved(decoded)) output += decoded;
+					else output += "%" + normalizedHex;
+					i += 2;
+					continue;
+				}
+			}
+			if (isPathCharacter(ch)) output += ch;
+			else {
+				const code = input.charCodeAt(i);
+				if (code < 128) output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+				else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
+				else if (code <= 56319 && i + 1 < input.length) {
+					const low = input.charCodeAt(i + 1);
+					if (low >= 56320 && low <= 57343) {
+						output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+						i++;
+					} else output += percentEncodeNonAscii(65533);
+				} else output += percentEncodeNonAscii(65533);
+			}
+		}
+		return output;
+	}
+	/**
+	* Serializes a path without rewriting reserved data. Raw RFC 3986 path
+	* characters remain literal, valid escapes are preserved and uppercased, and
+	* everything else is UTF-8 percent-encoded. In a path-noscheme, a colon in the
+	* first segment must be escaped so the result cannot be parsed as a scheme.
+	*
+	* @param {string} input
+	* @param {boolean} [pathNoScheme=false]
+	* @returns {string}
+	*/
+	function serializePathEncoding(input, pathNoScheme = false) {
+		let output = "";
+		let firstSegment = pathNoScheme && input[0] !== "/";
+		for (let i = 0; i < input.length; i++) {
+			const ch = input[i];
+			if (ch === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					output += "%" + hex.toUpperCase();
+					i += 2;
+					continue;
+				}
+			}
+			if (ch === "/") firstSegment = false;
+			if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) output += ch;
+			else {
+				const code = input.charCodeAt(i);
+				if (code < 128) output += BYTE_HEX[code];
+				else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
+				else if (code <= 56319 && i + 1 < input.length) {
+					const low = input.charCodeAt(i + 1);
+					if (low >= 56320 && low <= 57343) {
+						output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+						i++;
+					} else output += percentEncodeNonAscii(65533);
+				} else output += percentEncodeNonAscii(65533);
+			}
+		}
+		return output;
+	}
+	/**
+	* Percent-encodes a URI component using its RFC 3986 literal character set.
+	* Existing valid escapes are preserved and normalized to uppercase hex.
+	*
+	* @param {string} input
+	* @param {(value: string) => boolean} isAllowed
+	* @returns {string}
+	*/
+	function encodeComponent(input, isAllowed) {
+		let output = "";
+		for (let i = 0; i < input.length; i++) {
+			const ch = input[i];
+			if (ch === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					output += "%" + hex.toUpperCase();
+					i += 2;
+					continue;
+				}
+			}
+			if (isAllowed(ch)) output += ch;
+			else {
+				const code = input.charCodeAt(i);
+				if (code < 128) output += BYTE_HEX[code];
+				else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
+				else if (code <= 56319 && i + 1 < input.length) {
+					const low = input.charCodeAt(i + 1);
+					if (low >= 56320 && low <= 57343) {
+						output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+						i++;
+					} else output += percentEncodeNonAscii(65533);
+				} else output += percentEncodeNonAscii(65533);
+			}
+		}
+		return output;
+	}
+	/**
+	* Encodes userinfo while preserving its RFC 3986 §3.2.1 literal characters.
+	* In particular, authority delimiters such as `@`, `/`, `?`, and `#` are data.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function encodeUserinfo(input) {
+		return encodeComponent(input, isUserinfoCharacter);
+	}
+	/**
+	* Encodes query data using the RFC 3986 §3.4 grammar. A literal `#` must be
+	* escaped because it would otherwise begin the fragment component.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function encodeQuery(input) {
+		return encodeComponent(input, isQueryFragmentCharacter);
+	}
+	/**
+	* Encodes fragment data using the RFC 3986 §3.5 grammar.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function encodeFragment(input) {
+		return encodeComponent(input, isQueryFragmentCharacter);
+	}
+	function isEscapeSafe(cp) {
+		return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 42 || cp === 43 || cp === 45 || cp === 46 || cp === 47 || cp === 64 || cp === 95;
+	}
+	/**
+	* Normalizes the percent-encoding of a query or fragment component.
+	*
+	* Like `normalizePathEncoding`, but uses the query/fragment character set
+	* (which additionally allows `?`) and decodes `.` since it has no dot-segment
+	* meaning outside of a path.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function normalizeQueryFragmentEncoding(input) {
+		let output = "";
+		for (let i = 0; i < input.length; i++) {
+			const ch = input[i];
+			if (ch === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					const normalizedHex = hex.toUpperCase();
+					const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+					if (isUnreserved(decoded)) output += decoded;
+					else output += "%" + normalizedHex;
+					i += 2;
+					continue;
+				}
+			}
+			if (isQueryFragmentCharacter(ch)) output += ch;
+			else {
+				const code = input.charCodeAt(i);
+				if (code < 128) output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+				else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
+				else if (code <= 56319 && i + 1 < input.length) {
+					const low = input.charCodeAt(i + 1);
+					if (low >= 56320 && low <= 57343) {
+						output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+						i++;
+					} else output += percentEncodeNonAscii(65533);
+				} else output += percentEncodeNonAscii(65533);
+			}
+		}
+		return output;
+	}
+	/**
+	* Escapes a component while preserving existing valid percent escapes.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function escapePreservingEscapes(input) {
+		let output = "";
+		for (let i = 0; i < input.length; i++) {
+			if (input[i] === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					output += "%" + hex.toUpperCase();
+					i += 2;
+					continue;
+				}
+			}
+			output += escape(input[i]);
+		}
+		return output;
 	}
 	/**
 	* @param {import('../types/index').URIComponent} component
@@ -20108,28 +20439,42 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	function recomposeAuthority(component) {
 		const uriTokens = [];
 		if (component.userinfo !== void 0) {
-			uriTokens.push(component.userinfo);
+			uriTokens.push(encodeUserinfo(component.userinfo));
 			uriTokens.push("@");
 		}
 		if (component.host !== void 0) {
-			let host = unescape(component.host);
+			let host = component.host;
 			if (!isIPv4(host)) {
-				const ipV6res = normalizeIPv6(host);
-				if (ipV6res.isIPV6 === true) host = `[${ipV6res.escapedHost}]`;
-				else host = component.host;
+				let ipV6res = normalizeIPv6(host);
+				if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
+					host = normalizePercentEncoding(host, true);
+					ipV6res = normalizeIPv6(host);
+				}
+				if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) host = `[${ipV6res.escapedHost}]`;
+				else host = reescapeHostDelimiters(host, false);
 			}
 			uriTokens.push(host);
 		}
 		if (typeof component.port === "number" || typeof component.port === "string") {
+			const port = String(component.port);
+			if (!isPort(port)) throw new TypeError("URI port is malformed.");
 			uriTokens.push(":");
-			uriTokens.push(String(component.port));
+			uriTokens.push(port);
 		}
 		return uriTokens.length ? uriTokens.join("") : void 0;
 	}
 	module.exports = {
 		nonSimpleDomain,
 		recomposeAuthority,
-		normalizeComponentEncoding,
+		reescapeHostDelimiters,
+		normalizePercentEncoding,
+		normalizePathEncoding,
+		serializePathEncoding,
+		normalizeQueryFragmentEncoding,
+		encodeUserinfo,
+		encodeQuery,
+		encodeFragment,
+		escapePreservingEscapes,
 		removeDotSegments,
 		isIPv4,
 		isUUID,
@@ -20139,7 +20484,7 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 var require_schemes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { isUUID } = require_utils();
-	const URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+	const URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
 	const supportedSchemeNames = [
 		"http",
 		"https",
@@ -20210,9 +20555,10 @@ var require_schemes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			wsComponent.secure = void 0;
 		}
 		if (wsComponent.resourceName) {
-			const [path, query] = wsComponent.resourceName.split("?");
+			const queryIndex = wsComponent.resourceName.indexOf("?");
+			const path = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
 			wsComponent.path = path && path !== "/" ? path : void 0;
-			wsComponent.query = query;
+			wsComponent.query = queryIndex === -1 ? void 0 : wsComponent.resourceName.slice(queryIndex + 1);
 			wsComponent.resourceName = void 0;
 		}
 		wsComponent.fragment = void 0;
@@ -20225,7 +20571,7 @@ var require_schemes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			return urnComponent;
 		}
 		const matches = urnComponent.path.match(URN_REG);
-		if (matches) {
+		if (matches && matches[0] === urnComponent.path) {
 			const scheme = options.scheme || urnComponent.scheme || "urn";
 			urnComponent.nid = matches[1].toLowerCase();
 			urnComponent.nss = matches[2];
@@ -20319,8 +20665,19 @@ var require_schemes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
+	const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
 	const { SCHEMES, getSchemeHandler } = require_schemes();
+	const VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
+	const MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
+	/**
+	* @param {string} scheme
+	* @returns {string}
+	*/
+	function decodeValidScheme(scheme) {
+		const decodedScheme = unescape(String(scheme));
+		if (!VALID_SCHEME.test(decodedScheme)) throw new TypeError(MALFORMED_SCHEME_ERROR);
+		return decodedScheme;
+	}
 	/**
 	* @template {import('./types/index').URIComponent|string} T
 	* @param {T} uri
@@ -20328,7 +20685,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @returns {T}
 	*/
 	function normalize(uri, options) {
-		if (typeof uri === "string") uri = serialize(parse(uri, options), options);
+		if (typeof uri === "string") uri = normalizeString(uri, options);
 		else if (typeof uri === "object") uri = parse(serialize(uri, options), options);
 		return uri;
 	}
@@ -20340,7 +20697,16 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	*/
 	function resolve(baseURI, relativeURI, options) {
 		const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-		const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
+		const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed, malformedPercentEncoding: baseMalformedPercentEncoding, malformedSchemeSpecific: baseMalformedSchemeSpecific, malformedHost: baseMalformedHost, malformedScheme: baseMalformedScheme } = parseWithStatus(baseURI, schemelessOptions);
+		const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed, malformedPercentEncoding: relativeMalformedPercentEncoding, malformedSchemeSpecific: relativeMalformedSchemeSpecific, malformedHost: relativeMalformedHost, malformedScheme: relativeMalformedScheme } = parseWithStatus(relativeURI, schemelessOptions);
+		if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
+		const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
+		const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
+		const resolvedHost = resolved.host;
+		const resolvedHostIsIP = resolvedHost !== void 0 && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+		canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
+		const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !/\P{ASCII}/u.test(resolvedHost);
+		if (resolved.error && !encodedASCIIHost) throw new Error(resolved.error);
 		schemelessOptions.skipEscape = true;
 		return serialize(resolved, schemelessOptions);
 	}
@@ -20404,27 +20770,9 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @returns {boolean}
 	*/
 	function equal(uriA, uriB, options) {
-		if (typeof uriA === "string") {
-			uriA = unescape(uriA);
-			uriA = serialize(normalizeComponentEncoding(parse(uriA, options), true), {
-				...options,
-				skipEscape: true
-			});
-		} else if (typeof uriA === "object") uriA = serialize(normalizeComponentEncoding(uriA, true), {
-			...options,
-			skipEscape: true
-		});
-		if (typeof uriB === "string") {
-			uriB = unescape(uriB);
-			uriB = serialize(normalizeComponentEncoding(parse(uriB, options), true), {
-				...options,
-				skipEscape: true
-			});
-		} else if (typeof uriB === "object") uriB = serialize(normalizeComponentEncoding(uriB, true), {
-			...options,
-			skipEscape: true
-		});
-		return uriA.toLowerCase() === uriB.toLowerCase();
+		const normalizedA = normalizeComparableURI(uriA, options);
+		const normalizedB = normalizeComparableURI(uriB, options);
+		return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA === normalizedB;
 	}
 	/**
 	* @param {Readonly<import('./types/index').URIComponent>} cmpts
@@ -20450,13 +20798,17 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		};
 		const options = Object.assign({}, opts);
 		const uriTokens = [];
+		if (component.scheme) component.scheme = decodeValidScheme(component.scheme);
 		const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
 		if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
-		if (component.path !== void 0) if (!options.skipEscape) {
-			component.path = escape(component.path);
-			if (component.scheme !== void 0) component.path = component.path.split("%3A").join(":");
-		} else component.path = unescape(component.path);
-		if (options.reference !== "suffix" && component.scheme) uriTokens.push(component.scheme, ":");
+		const hasAuthority = component.userinfo !== void 0 || component.host !== void 0 || component.port !== void 0;
+		const pathNoScheme = !options.skipEscape && component.scheme === void 0 && !hasAuthority;
+		if (component.path !== void 0) if (!options.skipEscape) component.path = serializePathEncoding(component.path, pathNoScheme);
+		else component.path = normalizePercentEncoding(component.path);
+		if (options.reference !== "suffix" && component.scheme) {
+			component.scheme = decodeValidScheme(component.scheme);
+			uriTokens.push(component.scheme, ":");
+		}
 		const authority = recomposeAuthority(component);
 		if (authority !== void 0) {
 			if (options.reference !== "suffix") uriTokens.push("//");
@@ -20466,20 +20818,84 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		if (component.path !== void 0) {
 			let s = component.path;
 			if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) s = removeDotSegments(s);
+			if (pathNoScheme) s = serializePathEncoding(s, true);
 			if (authority === void 0 && s[0] === "/" && s[1] === "/") s = "/%2F" + s.slice(2);
 			uriTokens.push(s);
 		}
-		if (component.query !== void 0) uriTokens.push("?", component.query);
-		if (component.fragment !== void 0) uriTokens.push("#", component.fragment);
+		if (component.query !== void 0) uriTokens.push("?", encodeQuery(component.query));
+		if (component.fragment !== void 0) uriTokens.push("#", encodeFragment(component.fragment));
 		return uriTokens.join("");
 	}
 	const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
+	const AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
+	const AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
+	/**
+	* @param {import('./types/index').URIComponent} parsed
+	* @param {RegExpMatchArray} matches
+	* @returns {string|undefined}
+	*/
+	function getParseError(parsed, matches) {
+		if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") return "URI path must start with \"/\" when authority is present.";
+		if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) return "URI port is malformed.";
+	}
+	/**
+	* Checks percent syntax without decoding the represented octets. RFC 3986
+	* percent-encoding is byte-oriented, so sequences such as `%FF` are valid even
+	* though they are not independently valid UTF-8.
+	*
+	* @param {string|undefined} component
+	* @returns {boolean}
+	*/
+	function hasMalformedPercentEncoding(component) {
+		if (component === void 0) return false;
+		let percent = component.indexOf("%");
+		while (percent !== -1) {
+			if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) return true;
+			percent = component.indexOf("%", percent + 3);
+		}
+		return false;
+	}
+	/**
+	* Whether the host is a bracketed IP literal (RFC 3986 `IP-literal`).
+	* An unterminated `[` is not a literal, so it must still be validated as a
+	* reg-name instead of being waved through as an IP.
+	*
+	* @param {string} host
+	* @returns {boolean}
+	*/
+	function isIPLiteral(host) {
+		return host[0] === "[" && host[host.length - 1] === "]";
+	}
+	/**
+	* @param {RegExpMatchArray} matches
+	* @returns {boolean}
+	*/
+	function hasMalformedComponentPercentEncoding(matches) {
+		const host = matches[4];
+		return hasMalformedPercentEncoding(matches[3]) || host !== void 0 && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
+	}
+	/**
+	* @param {import('./types/index').URIComponent} parsed
+	* @param {import('./types/index').Options} options
+	* @param {{ domainHost?: boolean, unicodeSupport?: boolean }|undefined} schemeHandler
+	* @param {boolean} isIP
+	* @returns {boolean} whether host conversion failed
+	*/
+	function canonicalizeHost(parsed, options, schemeHandler, isIP) {
+		if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) try {
+			parsed.host = new URL("http://" + parsed.host).hostname;
+		} catch (e) {
+			parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
+			return true;
+		}
+		return false;
+	}
 	/**
 	* @param {string} uri
 	* @param {import('./types/index').Options} [opts]
-	* @returns
+	* @returns {{ parsed: import('./types/index').URIComponent, malformedAuthorityOrPort: boolean, malformedPercentEncoding: boolean, malformedSchemeSpecific: boolean, malformedHost: boolean, malformedScheme: boolean }}
 	*/
-	function parse(uri, opts) {
+	function parseWithStatus(uri, opts) {
 		const options = Object.assign({}, opts);
 		/** @type {import('./types/index').URIComponent} */
 		const parsed = {
@@ -20491,9 +20907,34 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			query: void 0,
 			fragment: void 0
 		};
+		let malformedAuthorityOrPort = false;
+		let malformedPercentEncoding = false;
+		let malformedSchemeSpecific = false;
+		let malformedHost = false;
+		let malformedIPLiteral = false;
+		let malformedScheme = false;
 		let isIP = false;
 		if (options.reference === "suffix") if (options.scheme) uri = options.scheme + ":" + uri;
 		else uri = "//" + uri;
+		const authorityMatch = uri.match(AUTHORITY_PREFIX);
+		if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
+			parsed.error = "URI authority must not contain a literal backslash.";
+			malformedAuthorityOrPort = true;
+		}
+		const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
+		if (introducerMatch !== null) {
+			const region = introducerMatch[1];
+			const normalizedRegion = region.replace(/[\t\n\r]/g, "");
+			if (normalizedRegion.length >= 2) {
+				if (normalizedRegion.slice(0, 2) !== "//") {
+					parsed.error = parsed.error || "URI authority must not contain a literal backslash.";
+					malformedAuthorityOrPort = true;
+				} else if (region.length !== normalizedRegion.length) {
+					parsed.error = parsed.error || "URI authority introducer must not contain whitespace.";
+					malformedAuthorityOrPort = true;
+				}
+			}
+		}
 		const matches = uri.match(URI_PARSE);
 		if (matches) {
 			parsed.scheme = matches[1];
@@ -20503,11 +20944,33 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			parsed.path = matches[6] || "";
 			parsed.query = matches[7];
 			parsed.fragment = matches[8];
+			if (parsed.scheme !== void 0) {
+				const decodedScheme = unescape(parsed.scheme);
+				if (VALID_SCHEME.test(decodedScheme)) parsed.scheme = decodedScheme.toLowerCase();
+				else {
+					parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
+					malformedScheme = true;
+				}
+			}
+			malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
+			if (malformedPercentEncoding) parsed.error = parsed.error || "URI contains malformed percent-encoding.";
 			if (isNaN(parsed.port)) parsed.port = matches[5];
+			const parseError = getParseError(parsed, matches);
+			if (parseError !== void 0) {
+				parsed.error = parsed.error || parseError;
+				malformedAuthorityOrPort = true;
+			}
 			if (parsed.host) if (isIPv4(parsed.host) === false) {
+				const bracketedIPLiteral = isIPLiteral(parsed.host);
+				const hasIPLiteralBracket = parsed.host.indexOf("[") !== -1 || parsed.host.indexOf("]") !== -1;
 				const ipv6result = normalizeIPv6(parsed.host);
-				parsed.host = ipv6result.host.toLowerCase();
-				isIP = ipv6result.isIPV6;
+				isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
+				malformedIPLiteral = hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true);
+				parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
+				if (malformedIPLiteral) {
+					parsed.error = parsed.error || "URI host is malformed.";
+					malformedAuthorityOrPort = true;
+				}
 			} else isIP = true;
 			if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) parsed.reference = "same-document";
 			else if (parsed.scheme === void 0) parsed.reference = "relative";
@@ -20515,24 +20978,78 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			else parsed.reference = "uri";
 			if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
 			const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
-			if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-				if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) try {
-					parsed.host = URL.domainToASCII(parsed.host.toLowerCase());
-				} catch (e) {
-					parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
-				}
+			if (!malformedIPLiteral) malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
+			if (uri.indexOf("%") !== -1 && parsed.host !== void 0 && !malformedIPLiteral) {
+				let host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+				if (!isIP) host = normalizePercentEncoding(host.toLowerCase());
+				parsed.host = reescapeHostDelimiters(host, isIP);
 			}
 			if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-				if (uri.indexOf("%") !== -1) {
-					if (parsed.scheme !== void 0) parsed.scheme = unescape(parsed.scheme);
-					if (parsed.host !== void 0) parsed.host = unescape(parsed.host);
-				}
-				if (parsed.path) parsed.path = escape(unescape(parsed.path));
-				if (parsed.fragment) parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+				if (parsed.path) parsed.path = normalizePathEncoding(parsed.path);
+				if (parsed.query) parsed.query = normalizeQueryFragmentEncoding(parsed.query);
+				if (parsed.fragment) parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
+			}
+			if (schemeHandler && schemeHandler.parse) {
+				schemeHandler.parse(parsed, options);
+				if (schemeHandler === SCHEMES.urn && parsed.nid === void 0) malformedSchemeSpecific = true;
 			}
-			if (schemeHandler && schemeHandler.parse) schemeHandler.parse(parsed, options);
 		} else parsed.error = parsed.error || "URI can not be parsed.";
-		return parsed;
+		return {
+			parsed,
+			malformedAuthorityOrPort,
+			malformedPercentEncoding,
+			malformedSchemeSpecific,
+			malformedHost,
+			malformedScheme
+		};
+	}
+	/**
+	* @param {string} uri
+	* @param {import('./types/index').Options} [opts]
+	* @returns
+	*/
+	function parse(uri, opts) {
+		return parseWithStatus(uri, opts).parsed;
+	}
+	/**
+	* @param {string} uri
+	* @param {import('./types/index').Options} [opts]
+	* @returns {string}
+	*/
+	function normalizeString(uri, opts) {
+		return normalizeStringWithStatus(uri, opts).normalized;
+	}
+	/**
+	* @param {string} uri
+	* @param {import('./types/index').Options} [opts]
+	* @returns {{ normalized: string, malformedAuthorityOrPort: boolean, malformedPercentEncoding: boolean, malformedSchemeSpecific: boolean, malformedHost: boolean, malformedScheme: boolean }}
+	*/
+	function normalizeStringWithStatus(uri, opts) {
+		const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
+		return {
+			normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
+			malformedAuthorityOrPort,
+			malformedPercentEncoding,
+			malformedSchemeSpecific,
+			malformedHost,
+			malformedScheme
+		};
+	}
+	/**
+	* @param {import ('./types/index').URIComponent|string} uri
+	* @param {import('./types/index').Options} [opts]
+	* @returns {string|undefined}
+	*/
+	function normalizeComparableURI(uri, opts) {
+		if (typeof uri !== "string" && typeof uri !== "object") return;
+		let value;
+		try {
+			value = typeof uri === "string" ? uri : serialize(uri, opts);
+		} catch {
+			return;
+		}
+		const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
+		return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? void 0 : normalized;
 	}
 	const fastUri = {
 		SCHEMES,
@@ -24322,7 +24839,7 @@ var AjvJsonSchemaValidator = class {
 };
 import_ajv.Ajv;
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+server@2.3.1/node_modules/@modelcontextprotocol/server/dist/mcp-DIH4cS6P.mjs
+//#region node_modules/.pnpm/@modelcontextprotocol+server@2.4.0/node_modules/@modelcontextprotocol/server/dist/mcp-oHn3ureC.mjs
 const COMPLETABLE_SYMBOL = Symbol.for("mcp.completable");
 /**
 * Checks if a schema is completable (has completion metadata).
@@ -24344,604 +24861,425 @@ function armSseKeepAlive(intervalMs, onTick) {
 	timer.unref?.();
 	return timer;
 }
+let readClassification;
 /**
-* A `ServerEventBus` backed by an in-process listener set.
+* The per-request micro-transport: a real, connected `Transport` whose whole
+* lifetime is one HTTP exchange. See the module documentation for the
+* response shapes it produces.
 *
-* `publish()` delivers synchronously to the live listener set (a listener
-* unsubscribing itself mid-dispatch is safe; the entry's listen-router
-* listeners never unsubscribe peers). A throwing listener does not stop
-* delivery to the others.
+* Connecting a `Server` binds the instance to the classified modern revision
+* when its `supportedProtocolVersions` lists it and the SDK implements it.
 */
-var InMemoryServerEventBus = class {
-	_listeners = /* @__PURE__ */ new Set();
+var PerRequestHTTPServerTransport = class {
+	static {
+		readClassification = (transport) => transport._classification;
+	}
+	onclose;
+	onerror;
+	onmessage;
+	_classification;
+	_responseMode;
+	_started = false;
+	_used = false;
+	_closed = false;
+	_terminalDelivered = false;
 	/**
-	* @param onerror - Optional callback for errors thrown by listeners
-	*   during dispatch.
+	* `true` only while the inbound message is being delivered synchronously
+	* to the connected protocol layer. The pre-handler gates (the era
+	* registry gate, the edge→instance handoff check, the missing-handler
+	* rejection) answer inside this window; request handlers always run
+	* after it (the protocol layer defers them to a microtask). An error
+	* sent inside the window is therefore ladder-originated, and an error
+	* sent after it is handler-produced.
 	*/
-	constructor(onerror) {
-		this.onerror = onerror;
+	_dispatchWindowOpen = false;
+	_requestId;
+	_deferredResponse;
+	_sse;
+	_abortCleanup;
+	_keepAliveMs;
+	constructor(options) {
+		this._classification = options.classification;
+		this._responseMode = options.responseMode ?? "auto";
+		this._keepAliveMs = options.keepAliveMs ?? 15e3;
 	}
-	publish(event) {
-		for (const listener of this._listeners) try {
-			listener(event);
-		} catch (error) {
-			this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+	async start() {
+		if (this._started) throw new Error("PerRequestHTTPServerTransport is already started");
+		this._started = true;
+	}
+	/**
+	* Serves the single exchange: delivers the classified message to the
+	* connected server instance and resolves with the HTTP response.
+	*
+	* Throws when called a second time (the transport is strictly
+	* single-use), or before a server has been connected to the transport.
+	* The returned promise rejects with a connection-closed error when the
+	* transport is closed before a response was produced (for example because
+	* the client disconnected).
+	*/
+	async handleMessage(message, extra) {
+		if (this._used) throw new Error("PerRequestHTTPServerTransport serves exactly one exchange; construct a new transport per request");
+		if (!this._started || this.onmessage === void 0) throw new Error("PerRequestHTTPServerTransport is not connected: connect a server to this transport before handling a message");
+		if (this._closed) throw new Error("PerRequestHTTPServerTransport is closed");
+		this._used = true;
+		const signal = extra?.request?.signal;
+		if (signal?.aborted) {
+			await this.close();
+			throw new SdkError(SdkErrorCode.ConnectionClosed, "The request was aborted before it could be handled");
+		}
+		const messageExtra = {
+			classification: this._classification,
+			...extra?.request !== void 0 && { request: extra.request },
+			...extra?.authInfo !== void 0 && { authInfo: extra.authInfo }
+		};
+		if (isJSONRPCRequest(message)) {
+			this._requestId = message.id;
+			let resolve;
+			let reject;
+			const promise = new Promise((promiseResolve, promiseReject) => {
+				resolve = promiseResolve;
+				reject = promiseReject;
+			});
+			this._deferredResponse = {
+				promise,
+				resolve,
+				reject,
+				settled: false
+			};
+			if (signal !== void 0) {
+				const onAbort = () => void this.close();
+				signal.addEventListener("abort", onAbort, { once: true });
+				this._abortCleanup = () => signal.removeEventListener("abort", onAbort);
+			}
+			this._dispatchWindowOpen = true;
+			try {
+				this.onmessage(message, messageExtra);
+			} finally {
+				this._dispatchWindowOpen = false;
+			}
+			if (this._responseMode === "sse" && !this._closed && !this._deferredResponse.settled) this.upgradeToSse();
+			return promise;
 		}
+		this.onmessage(message, messageExtra);
+		return new Response(null, { status: 202 });
 	}
-	subscribe(listener) {
-		this._listeners.add(listener);
-		let live = true;
-		return () => {
-			if (!live) return;
-			live = false;
-			this._listeners.delete(listener);
+	async send(message, options) {
+		if (this._closed) return;
+		const isResponse = isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message);
+		const relatedId = isResponse ? message.id : options?.relatedRequestId;
+		if (this._requestId === void 0 || relatedId === void 0 || relatedId !== this._requestId) {
+			if (isResponse) this.onerror?.(/* @__PURE__ */ new Error(`Received a response for an unknown request id: ${String(message.id)}`));
+			return;
+		}
+		if (isResponse) {
+			if (this._terminalDelivered) return;
+			this._terminalDelivered = true;
+			const errorCode = isJSONRPCErrorResponse(message) ? message.error.code : void 0;
+			const ladderStatus = errorCode !== void 0 && (this._dispatchWindowOpen || errorCode === ProtocolErrorCode.MissingRequiredClientCapability) ? LADDER_ERROR_HTTP_STATUS[errorCode] : void 0;
+			if (ladderStatus !== void 0 && this._sse === void 0) {
+				this.settleResponse(Response.json(message, {
+					status: ladderStatus,
+					headers: { "Content-Type": "application/json" }
+				}));
+				queueMicrotask(() => void this.close());
+				return;
+			}
+			if (this._sse !== void 0 || this._responseMode === "sse") {
+				if (this._sse === void 0) this.upgradeToSse();
+				this.writeMessageFrame(message);
+				this.finalizeStream();
+				return;
+			}
+			this.settleResponse(Response.json(message, {
+				status: 200,
+				headers: { "Content-Type": "application/json" }
+			}));
+			queueMicrotask(() => void this.close());
+			return;
+		}
+		if (this._responseMode === "json") return;
+		if (this._sse === void 0) this.upgradeToSse();
+		this.writeMessageFrame(message);
+	}
+	/**
+	* Writes an SSE comment frame (a keep-alive heartbeat). Dropped when the
+	* exchange is not currently streaming.
+	*/
+	writeCommentFrame(comment) {
+		if (this._closed || this._sse === void 0 || this._sse.closed) return;
+		const frame = comment.split("\n").map((line) => `: ${line}`).join("\n");
+		this.writeFrame(`${frame}\n\n`);
+	}
+	async close() {
+		if (this._closed) return;
+		this._closed = true;
+		this._abortCleanup?.();
+		this._abortCleanup = void 0;
+		if (this._sse?.keepAliveTimer !== void 0) clearInterval(this._sse.keepAliveTimer);
+		if (this._sse !== void 0 && !this._sse.closed) {
+			this._sse.closed = true;
+			try {
+				this._sse.controller.close();
+			} catch {}
+		}
+		if (this._deferredResponse !== void 0 && !this._deferredResponse.settled) {
+			this._deferredResponse.settled = true;
+			this._deferredResponse.reject(new SdkError(SdkErrorCode.ConnectionClosed, "Connection closed before a response was produced"));
+		}
+		this.onclose?.();
+	}
+	settleResponse(response) {
+		if (this._deferredResponse === void 0 || this._deferredResponse.settled) return;
+		this._deferredResponse.settled = true;
+		this._deferredResponse.resolve(response);
+	}
+	upgradeToSse() {
+		let controller;
+		const readable = new ReadableStream({
+			start: (streamController) => {
+				controller = streamController;
+			},
+			cancel: () => {
+				this.close();
+			}
+		});
+		this._sse = {
+			controller,
+			encoder: new TextEncoder(),
+			closed: false
 		};
+		this._sse.keepAliveTimer = armSseKeepAlive(this._keepAliveMs, () => this.writeCommentFrame("keepalive"));
+		this.settleResponse(new Response(readable, {
+			status: 200,
+			headers: {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache, no-transform",
+				Connection: "keep-alive",
+				"X-Accel-Buffering": "no"
+			}
+		}));
 	}
-	/** The number of currently registered listeners (test/introspection only — the routers track capacity via their own open-subscription set). */
-	get listenerCount() {
-		return this._listeners.size;
+	finalizeStream() {
+		if (this._sse?.keepAliveTimer !== void 0) clearInterval(this._sse.keepAliveTimer);
+		if (this._sse !== void 0 && !this._sse.closed) {
+			this._sse.closed = true;
+			try {
+				this._sse.controller.close();
+			} catch {}
+		}
+		queueMicrotask(() => void this.close());
+	}
+	writeMessageFrame(message) {
+		this.writeFrame(`event: message\ndata: ${JSON.stringify(message)}\n\n`);
+	}
+	writeFrame(frame) {
+		if (this._sse === void 0 || this._sse.closed) return;
+		try {
+			this._sse.controller.enqueue(this._sse.encoder.encode(frame));
+		} catch (error) {
+			this.onerror?.(/* @__PURE__ */ new Error(`Failed to write to the response stream: ${error}`));
+		}
 	}
 };
-/** Build a {@linkcode ServerNotifier} over a bus. */
-function createServerNotifier(bus) {
-	return {
-		toolsChanged: () => bus.publish({ kind: "tools_list_changed" }),
-		promptsChanged: () => bus.publish({ kind: "prompts_list_changed" }),
-		resourcesChanged: () => bus.publish({ kind: "resources_list_changed" }),
-		resourceUpdated: (uri) => bus.publish({
-			kind: "resource_updated",
-			uri
-		})
-	};
+/** Package-internal: the classification a per-request transport serves; `undefined` for any other transport. Not public API. */
+function perRequestClassificationOf(transport) {
+	return transport instanceof PerRequestHTTPServerTransport ? readClassification(transport) : void 0;
+}
+function comparableResource(value) {
+	const text = String(value);
+	const hash = text.indexOf("#");
+	return (hash === -1 ? text : text.slice(0, hash)).replace(/\/$/, "");
+}
+function sameResource(reported, expected) {
+	if (!reported) return false;
+	return comparableResource(reported) === comparableResource(expected);
+}
+function headerQuotedValue(value) {
+	return value.replaceAll(/[\\"]/g, String.raw`\$&`).replaceAll(/[^\u0020-\u007E]/g, " ");
 }
 /**
-* Whether a `subscriptions/listen` filter accepts a given change event.
-*
-* Pure: no I/O, no mutation. The filter governs ONLY the four
-* subscription-gated change types — non-gated notifications never reach the
-* bus and are not modeled here.
+* Build a `WWW-Authenticate: Bearer …` challenge header value (RFC 6750).
 *
-* `resource_updated` matches only when `resourceSubscriptions` is present and
-* contains the event's URI exactly (per the spec: "for these resource URIs").
-*/
-function listenFilterAccepts(filter, event) {
-	switch (event.kind) {
-		case "tools_list_changed": return filter.toolsListChanged === true;
-		case "prompts_list_changed": return filter.promptsListChanged === true;
-		case "resources_list_changed": return filter.resourcesListChanged === true;
-		case "resource_updated": return filter.resourceSubscriptions !== void 0 && filter.resourceSubscriptions.includes(event.uri);
+* The single formatter behind every challenge this package emits — the
+* bearer-auth 401/403 answers and the per-operation scope-challenge 403 — so
+* all challenges from one server agree on parameter order and quoting. Every
+* parameter value is emitted as an HTTP quoted-string with `\` and `"`
+* escaped and non-printable characters replaced.
+*/
+function buildWwwAuthenticateHeader(errorCode, description, requiredScopes, resourceMetadataUrl) {
+	let header = `Bearer error="${headerQuotedValue(errorCode)}", error_description="${headerQuotedValue(description)}"`;
+	if (requiredScopes.length > 0) header += `, scope="${headerQuotedValue(requiredScopes.join(" "))}"`;
+	if (resourceMetadataUrl) header += `, resource_metadata="${headerQuotedValue(resourceMetadataUrl)}"`;
+	return header;
+}
+/**
+* Validate a raw `Authorization` header value as a Bearer token and return
+* the verified {@link AuthInfo}.
+*
+* The runtime-neutral core of Bearer authentication: it parses the header,
+* runs the verifier, compares the token's resource with `expectedResource`,
+* enforces `requiredScopes`, and rejects tokens without an
+* expiration or past it. On any failure it throws an {@link OAuthError} —
+* pass that to {@link bearerAuthChallengeResponse} for the matching HTTP
+* answer, or use {@link requireBearerAuth} to get both steps as one call.
+*
+* Framework adapters build on this: `requireBearerAuth` from
+* `@modelcontextprotocol/express` feeds it `req.headers.authorization`.
+*/
+async function verifyBearerToken(authorizationHeader, options) {
+	const { verifier, requiredScopes = [], expectedResource } = options;
+	if (!authorizationHeader) throw new OAuthError(OAuthErrorCode.InvalidToken, "Missing Authorization header");
+	const [type, token] = authorizationHeader.split(" ");
+	if (type?.toLowerCase() !== "bearer" || !token) throw new OAuthError(OAuthErrorCode.InvalidToken, "Invalid Authorization header format, expected 'Bearer TOKEN'");
+	const authInfo = await verifier.verifyAccessToken(token);
+	if (expectedResource !== void 0 && !sameResource(authInfo.resource, expectedResource)) throw new OAuthError(OAuthErrorCode.InvalidToken, "Token was not issued for this resource");
+	if (requiredScopes.length > 0) {
+		if (!requiredScopes.every((scope) => authInfo.scopes.includes(scope))) throw new OAuthError(OAuthErrorCode.InsufficientScope, "Insufficient scope");
 	}
+	if (typeof authInfo.expiresAt !== "number" || Number.isNaN(authInfo.expiresAt)) throw new OAuthError(OAuthErrorCode.InvalidToken, "Token has no expiration time");
+	else if (authInfo.expiresAt < Date.now() / 1e3) throw new OAuthError(OAuthErrorCode.InvalidToken, "Token has expired");
+	if (options.resourceMetadataUrl !== void 0 && authInfo.resourceMetadataUrl === void 0) return {
+		...authInfo,
+		resourceMetadataUrl: options.resourceMetadataUrl
+	};
+	return authInfo;
 }
 /**
-* The honored subset of a requested filter: keeps only the fields the client
-* explicitly opted in to (drops `false` and absent fields), narrowed against
-* the server's declared capabilities when supplied. The serving entry sends
-* this back in `notifications/subscriptions/acknowledged` so the ack reflects
-* what the server can actually deliver.
+* Build the HTTP answer for a Bearer authentication failure.
 *
-* - `toolsListChanged` is honored only when `capabilities.tools.listChanged`
-*   is advertised; likewise `promptsListChanged` / `resourcesListChanged`.
-* - `resourceSubscriptions` is honored only when
-*   `capabilities.resources.subscribe` is advertised.
+* Maps an {@link OAuthError} to its status — `401` for `invalid_token` and
+* `403` for `insufficient_scope` (both carrying the `WWW-Authenticate: Bearer …`
+* challenge, with `resource_metadata` when configured so clients can discover
+* the Authorization Server), `500` for `server_error`, `400` for anything
+* else. A non-`OAuthError` value answers `500 server_error`. The body is the
+* OAuth error JSON.
+*/
+function bearerAuthChallengeResponse(error, options) {
+	const { requiredScopes = [], resourceMetadataUrl } = options ?? {};
+	if (!(error instanceof OAuthError)) {
+		const serverError = new OAuthError(OAuthErrorCode.ServerError, "Internal Server Error");
+		return Response.json(serverError.toResponseObject(), { status: 500 });
+	}
+	switch (error.code) {
+		case OAuthErrorCode.InvalidToken: {
+			const challenge = buildWwwAuthenticateHeader(error.code, error.message, requiredScopes, resourceMetadataUrl);
+			return Response.json(error.toResponseObject(), {
+				status: 401,
+				headers: { "WWW-Authenticate": challenge }
+			});
+		}
+		case OAuthErrorCode.InsufficientScope: {
+			const challenge = buildWwwAuthenticateHeader(error.code, error.message, requiredScopes, resourceMetadataUrl);
+			return Response.json(error.toResponseObject(), {
+				status: 403,
+				headers: { "WWW-Authenticate": challenge }
+			});
+		}
+		case OAuthErrorCode.ServerError: return Response.json(error.toResponseObject(), { status: 500 });
+		default: return Response.json(error.toResponseObject(), { status: 400 });
+	}
+}
+/**
+* Builds the RFC 9728 Protected Resource Metadata URL for a given MCP server
+* URL by inserting `/.well-known/oauth-protected-resource` ahead of the path.
 *
-* `capabilities` is optional on this pure helper for test convenience only —
-* both wired routers REQUIRE capabilities at the call site (the HTTP router's
-* `serve()` takes a required parameter; `StdioListenRouter.serve()` throws
-* before `setServerCapabilities()` was called), so the fail-open
-* `undefined → honor everything` branch is never reachable on a wired entry.
+* @example
+* ```ts
+* getOAuthProtectedResourceMetadataUrl(new URL('https://api.example.com/mcp'))
+* // → 'https://api.example.com/.well-known/oauth-protected-resource/mcp'
+* ```
 */
-function honoredSubset(requested, capabilities) {
-	const honored = {};
-	const allow = (bit) => capabilities === void 0 || bit === true;
-	if (requested.toolsListChanged === true && allow(capabilities?.tools?.listChanged)) honored.toolsListChanged = true;
-	if (requested.promptsListChanged === true && allow(capabilities?.prompts?.listChanged)) honored.promptsListChanged = true;
-	if (requested.resourcesListChanged === true && allow(capabilities?.resources?.listChanged)) honored.resourcesListChanged = true;
-	if (requested.resourceSubscriptions !== void 0 && requested.resourceSubscriptions.length > 0 && allow(capabilities?.resources?.subscribe)) honored.resourceSubscriptions = [...requested.resourceSubscriptions];
-	return honored;
+function getOAuthProtectedResourceMetadataUrl(serverUrl) {
+	const metadataUrl = new URL(serverUrl);
+	metadataUrl.pathname = protectedResourceMetadataPath(serverUrl);
+	metadataUrl.hash = "";
+	return metadataUrl.href;
 }
-/** Map a {@linkcode ServerEvent} onto its wire notification `{method, params}`. */
-function serverEventToNotification(event) {
-	switch (event.kind) {
-		case "tools_list_changed": return { method: "notifications/tools/list_changed" };
-		case "prompts_list_changed": return { method: "notifications/prompts/list_changed" };
-		case "resources_list_changed": return { method: "notifications/resources/list_changed" };
-		case "resource_updated": return {
-			method: "notifications/resources/updated",
-			params: { uri: event.uri }
-		};
+/** The RFC 9728 path-aware well-known path for a resource URL. */
+function protectedResourceMetadataPath(resourceServerUrl) {
+	const rsPath = stripTrailingSlash(resourceServerUrl.pathname);
+	return `/.well-known/oauth-protected-resource${rsPath === "/" ? "" : rsPath}`;
+}
+function stripTrailingSlash(path) {
+	return path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
+}
+/** @internal */
+function supportsScopeChallengeResolver(transport) {
+	return typeof transport === "object" && transport !== null && "setScopeChallengeResolver" in transport && typeof transport.setScopeChallengeResolver === "function";
+}
+function assertScope(scope, location) {
+	if (typeof scope !== "string" || !/^[\u0021\u0023-\u005B\u005D-\u007E]+$/.test(scope)) throw new TypeError(`${location} must satisfy the OAuth scope-token grammar`);
+}
+function validateScopeChallenge(challenge) {
+	if (challenge === null || typeof challenge !== "object" || !Array.isArray(challenge.scopes) || challenge.scopes.length === 0) throw new TypeError("scope challenge must contain at least one scope");
+	for (const [index, scope] of challenge.scopes.entries()) assertScope(scope, `scope challenge scopes[${index}]`);
+	if (challenge.errorDescription !== void 0 && typeof challenge.errorDescription !== "string") throw new TypeError("scope challenge errorDescription must be a string");
+	if (challenge.errorDescription !== void 0 && !/^[\u0020-\u0021\u0023-\u005B\u005D-\u007E]+$/.test(challenge.errorDescription)) throw new TypeError("scope challenge errorDescription must satisfy the RFC 6750 error-description grammar");
+	return challenge;
+}
+/** @internal */
+async function findScopeChallenge(requests, authInfo, resolve) {
+	for (const request of requests) {
+		const challenge = await resolve({
+			request,
+			...authInfo !== void 0 && { authInfo }
+		});
+		if (challenge !== void 0) return validateScopeChallenge(challenge);
 	}
 }
-/** Default capacity guard: refuse a new subscription when this many are already open. */
-const DEFAULT_MAX_SUBSCRIPTIONS = 1024;
-function jsonRpcError(id, code, message) {
-	return Response.json({
-		jsonrpc: "2.0",
-		error: {
-			code,
-			message
-		},
-		id
-	}, { status: 200 });
+/**
+* The RFC 9728 Protected Resource Metadata URL to advertise on a scope
+* challenge, derived from the verified {@link AuthInfo}: the URL the
+* authentication gate stamped (`authInfo.resourceMetadataUrl`, set by the
+* bearer-auth helpers from their `resourceMetadataUrl` option), falling back
+* to the well-known location for an HTTP(S) RFC 8707 `resource` identifier, or
+* `undefined` when neither is available (the `resource_metadata` parameter is
+* then omitted, matching the bearer-auth challenges).
+*
+* @internal
+*/
+function scopeChallengeResourceMetadataUrl(authInfo) {
+	if (authInfo?.resourceMetadataUrl !== void 0) return authInfo.resourceMetadataUrl;
+	if (authInfo?.resource?.protocol === "https:" || authInfo?.resource?.protocol === "http:") return getOAuthProtectedResourceMetadataUrl(authInfo.resource);
 }
-/** Stamp the subscription id onto a notification's `_meta`. Non-mutating. */
-function stampSubscriptionId(notification, subscriptionId) {
+/** @internal */
+function createScopeChallengeResponse(challenge, resourceMetadataUrl) {
+	return bearerAuthChallengeResponse(new OAuthError(OAuthErrorCode.InsufficientScope, challenge.errorDescription ?? "Insufficient scope"), {
+		requiredScopes: [...challenge.scopes],
+		resourceMetadataUrl
+	});
+}
+/**
+* Default handler re-entries per originating request — tighter than the
+* client driver's 10 because the shim holds a live wire request open.
+*/
+const DEFAULT_LEGACY_SHIM_MAX_ROUNDS = 8;
+/** Default per-leg timeout: legs are human-paced, so the 60s protocol default is wrong. */
+const DEFAULT_LEGACY_SHIM_ROUND_TIMEOUT_MS = 6e5;
+/** Resolves and validates `ServerOptions.inputRequired`, failing loudly at construction time. */
+function resolveLegacyShimOptions(options) {
+	if (options?.maxRounds !== void 0 && (!Number.isInteger(options.maxRounds) || options.maxRounds < 1)) throw new RangeError(`inputRequired.maxRounds must be a positive integer (got ${options.maxRounds})`);
+	if (options?.roundTimeoutMs !== void 0 && (!Number.isFinite(options.roundTimeoutMs) || options.roundTimeoutMs <= 0)) throw new RangeError(`inputRequired.roundTimeoutMs must be a positive number (got ${options.roundTimeoutMs})`);
 	return {
-		method: notification.method,
-		params: {
-			...notification.params,
-			_meta: {
-				...notification.params?._meta,
-				[SUBSCRIPTION_ID_META_KEY]: subscriptionId
-			}
-		}
+		maxRounds: options?.maxRounds ?? DEFAULT_LEGACY_SHIM_MAX_ROUNDS,
+		roundTimeoutMs: options?.roundTimeoutMs ?? DEFAULT_LEGACY_SHIM_ROUND_TIMEOUT_MS,
+		legacyShim: options?.legacyShim ?? true
 	};
 }
 /**
-* Read the requested filter off a `subscriptions/listen` request body.
-* Returns the validated filter, or `undefined` when `params.notifications`
-* is absent or fails the schema (the caller answers `-32602` — the spec
-* marks `notifications` REQUIRED on the listen request).
+* Validates one `inputRequests` entry: malformed or unknown kinds are server
+* bugs and fail loudly on both eras. Shared by the modern seam's capability
+* check and the shim's gate.
 */
-function parseListenFilter(message) {
-	const outcome = codecForVersion(MODERN_WIRE_REVISION).validateRequest("subscriptions/listen", message);
-	return outcome.ok ? outcome.value.params?.notifications : void 0;
-}
-function createListenRouter(options) {
-	const { bus, onerror } = options;
-	const maxSubscriptions = options.maxSubscriptions ?? 1024;
-	const keepAliveMs = options.keepAliveMs ?? 15e3;
-	const open = /* @__PURE__ */ new Set();
-	function serve(message, signal, capabilities, serverInfo) {
-		if (open.size >= maxSubscriptions) {
-			onerror?.(/* @__PURE__ */ new Error(`subscriptions/listen refused: subscription limit reached (${maxSubscriptions})`));
-			return jsonRpcError(message.id, -32603, "Subscription limit reached");
-		}
-		const filter = parseListenFilter(message);
-		if (filter === void 0) return jsonRpcError(message.id, -32602, "Invalid params: 'notifications' is required and must be a valid SubscriptionFilter");
-		const honored = honoredSubset(filter, capabilities);
-		const subscriptionId = message.id;
-		const encoder = new TextEncoder();
-		let controller;
-		let closed = false;
-		let unsubscribe;
-		let keepAliveTimer;
-		let abortCleanup;
-		const writeFrame = (frame) => {
-			if (closed) return;
-			try {
-				controller.enqueue(encoder.encode(frame));
-			} catch (error) {
-				onerror?.(error instanceof Error ? error : new Error(String(error)));
-			}
-		};
-		const writeNotification = (method, params) => {
-			writeFrame(`event: message\ndata: ${JSON.stringify({
-				jsonrpc: "2.0",
-				method,
-				params
-			})}\n\n`);
-		};
-		const teardown = (graceful) => {
-			if (closed) return;
-			if (graceful) writeFrame(`event: message\ndata: ${JSON.stringify({
-				jsonrpc: "2.0",
-				id: subscriptionId,
-				result: {
-					resultType: "complete",
-					_meta: {
-						[SUBSCRIPTION_ID_META_KEY]: subscriptionId,
-						[SERVER_INFO_META_KEY]: serverInfo
-					}
-				}
-			})}\n\n`);
-			closed = true;
-			try {
-				unsubscribe?.();
-			} catch (error) {
-				onerror?.(error instanceof Error ? error : new Error(String(error)));
-			}
-			if (keepAliveTimer !== void 0) clearInterval(keepAliveTimer);
-			abortCleanup?.();
-			open.delete(teardown);
-			try {
-				controller.close();
-			} catch {}
-		};
-		const readable = new ReadableStream({
-			start(streamController) {
-				controller = streamController;
-				const ack = stampSubscriptionId({
-					method: "notifications/subscriptions/acknowledged",
-					params: { notifications: honored }
-				}, subscriptionId);
-				writeNotification(ack.method, ack.params);
-				if (Object.keys(honored).length === 0) {
-					teardown(true);
-					return;
-				}
-				unsubscribe = bus.subscribe((event) => {
-					if (closed || !listenFilterAccepts(honored, event)) return;
-					const note = stampSubscriptionId(serverEventToNotification(event), subscriptionId);
-					writeNotification(note.method, note.params);
-				});
-				keepAliveTimer = armSseKeepAlive(keepAliveMs, () => writeFrame(": keepalive\n\n"));
-				open.add(teardown);
-			},
-			cancel() {
-				teardown(false);
-			}
-		});
-		if (signal !== void 0) if (signal.aborted) teardown(false);
-		else {
-			const onAbort = () => teardown(false);
-			signal.addEventListener("abort", onAbort, { once: true });
-			abortCleanup = () => signal.removeEventListener("abort", onAbort);
-		}
-		return new Response(readable, {
-			status: 200,
-			headers: {
-				"Content-Type": "text/event-stream",
-				"Cache-Control": "no-cache, no-transform",
-				Connection: "keep-alive",
-				"X-Accel-Buffering": "no"
-			}
-		});
-	}
-	return {
-		serve,
-		closeAll() {
-			for (const teardown of open) teardown(true);
-		},
-		get openCount() {
-			return open.size;
-		}
-	};
-}
-const CHANGE_NOTIFICATION_METHODS = /* @__PURE__ */ new Set([
-	"notifications/tools/list_changed",
-	"notifications/prompts/list_changed",
-	"notifications/resources/list_changed",
-	"notifications/resources/updated"
-]);
-/**
-* Per-connection listen state for the stdio entry. One instance is held by
-* `serveStdio` for the connection lifetime; it routes inbound
-* `subscriptions/listen` / `notifications/cancelled` and rewrites outbound
-* change notifications onto the active subscriptions. No bus — the long-lived
-* pinned instance's existing `send*ListChanged()` calls feed straight into
-* `routeOutbound()`.
-*/
-var StdioListenRouter = class {
-	/** Active subscriptions, keyed by the listen request's JSON-RPC id verbatim. */
-	_subs = /* @__PURE__ */ new Map();
-	/**
-	* The serving instance's declared capabilities. Filled in by the entry
-	* once the modern instance is constructed (the router is created before
-	* the instance exists), so the acknowledged filter is narrowed against
-	* what the server can actually deliver.
-	*/
-	_serverCapabilities;
-	/**
-	* The serving instance's identity, stamped onto the graceful-close
-	* results' `_meta` (the spec's `SubscriptionsListenResultMetaObject` extends
-	* `ResultMetaObject`). Handed over together with the capabilities.
-	*/
-	_serverInfo;
-	constructor(_maxSubscriptions = DEFAULT_MAX_SUBSCRIPTIONS, serverCapabilities, serverInfo) {
-		this._maxSubscriptions = _maxSubscriptions;
-		this._serverCapabilities = serverCapabilities;
-		this._serverInfo = serverInfo;
-	}
-	/**
-	* Record the serving instance's declared capabilities and identity once
-	* it has been constructed. Called by `serveStdio`'s connect path;
-	* subsequent `serve()` calls narrow the honored filter against the
-	* capabilities, and `teardownAll()` stamps the identity.
-	*/
-	setServerCapabilities(capabilities, serverInfo) {
-		this._serverCapabilities = capabilities;
-		if (serverInfo !== void 0) this._serverInfo = serverInfo;
-	}
-	/** Whether `id` is an active listen subscription on this connection. */
-	has(id) {
-		return this._subs.has(id);
-	}
-	/**
-	* Serve one inbound `subscriptions/listen` request: registers the
-	* subscription and returns the stamped acknowledged notification (or, on
-	* capacity / params rejection, the in-band JSON-RPC error response).
-	*
-	* @throws when called before {@linkcode setServerCapabilities} (or the
-	* constructor) has supplied the serving instance's capabilities. Honoring a
-	* filter without knowing the server's advertised capabilities would fail
-	* open (deliver unadvertised types); the entry guarantees capabilities are
-	* set before any listen request is routed here.
-	*/
-	serve(message) {
-		if (this._serverCapabilities === void 0) throw new Error("StdioListenRouter.serve() called before setServerCapabilities(); refusing to honor a filter without capabilities");
-		if (this._subs.size >= this._maxSubscriptions) return {
-			jsonrpc: "2.0",
-			id: message.id,
-			error: {
-				code: -32603,
-				message: "Subscription limit reached"
-			}
-		};
-		const filter = parseListenFilter(message);
-		if (filter === void 0) return {
-			jsonrpc: "2.0",
-			id: message.id,
-			error: {
-				code: -32602,
-				message: "Invalid params: 'notifications' is required and must be a valid SubscriptionFilter"
-			}
-		};
-		const honored = honoredSubset(filter, this._serverCapabilities);
-		this._subs.set(message.id, honored);
-		return stampSubscriptionId({
-			method: "notifications/subscriptions/acknowledged",
-			params: { notifications: honored }
-		}, message.id);
-	}
-	/**
-	* Tear down one subscription (inbound `notifications/cancelled`). Returns
-	* `true` when a subscription was removed. After this call NOTHING further
-	* is delivered for that subscription id (the post-cancel hardening).
-	*/
-	cancel(id) {
-		return this._subs.delete(id);
-	}
-	/**
-	* Route an outbound notification through the active subscriptions.
-	*
-	* - For a subscription-gated change notification, returns one stamped copy
-	*   per subscription that opted in to it (an empty array means it is
-	*   dropped — the modern era never delivers an un-requested change type).
-	* - For any other outbound message, returns `'passthrough'` (the entry
-	*   forwards it as-is).
-	*/
-	routeOutbound(message) {
-		if (!CHANGE_NOTIFICATION_METHODS.has(message.method)) return "passthrough";
-		const uriParam = message.params?.["uri"];
-		const uri = typeof uriParam === "string" ? uriParam : void 0;
-		const event = notificationToServerEvent(message.method, uri);
-		const out = [];
-		for (const [subscriptionId, filter] of this._subs) if (listenFilterAccepts(filter, event)) out.push(stampSubscriptionId({
-			method: message.method,
-			params: message.params ?? {}
-		}, subscriptionId));
-		return out;
-	}
-	/**
-	* Server-side graceful teardown of every active subscription: returns the
-	* empty `subscriptions/listen` JSON-RPC result for each subscription id —
-	* the spec's graceful-close signal, `_meta` carrying the subscription id
-	* and the serving instance's identity — for the entry to emit before
-	* closing the wire. Clears the set so nothing further is delivered.
-	*/
-	teardownAll() {
-		const out = [];
-		for (const id of this._subs.keys()) out.push({
-			jsonrpc: "2.0",
-			id,
-			result: {
-				resultType: "complete",
-				_meta: {
-					[SUBSCRIPTION_ID_META_KEY]: id,
-					...this._serverInfo !== void 0 && { ["io.modelcontextprotocol/serverInfo"]: this._serverInfo }
-				}
-			}
-		});
-		this._subs.clear();
-		return out;
-	}
-};
-function notificationToServerEvent(method, uri) {
-	switch (method) {
-		case "notifications/tools/list_changed": return { kind: "tools_list_changed" };
-		case "notifications/prompts/list_changed": return { kind: "prompts_list_changed" };
-		case "notifications/resources/list_changed": return { kind: "resources_list_changed" };
-		default: return {
-			kind: "resource_updated",
-			uri: uri ?? ""
-		};
-	}
-}
-function comparableResource(value) {
-	const text = String(value);
-	const hash = text.indexOf("#");
-	return (hash === -1 ? text : text.slice(0, hash)).replace(/\/$/, "");
-}
-function sameResource(reported, expected) {
-	if (!reported) return false;
-	return comparableResource(reported) === comparableResource(expected);
-}
-function headerQuotedValue(value) {
-	return value.replaceAll(/[\\"]/g, String.raw`\$&`).replaceAll(/[^\u0020-\u007E]/g, " ");
-}
-/**
-* Build a `WWW-Authenticate: Bearer …` challenge header value (RFC 6750).
-*
-* The single formatter behind every challenge this package emits — the
-* bearer-auth 401/403 answers and the per-operation scope-challenge 403 — so
-* all challenges from one server agree on parameter order and quoting. Every
-* parameter value is emitted as an HTTP quoted-string with `\` and `"`
-* escaped and non-printable characters replaced.
-*/
-function buildWwwAuthenticateHeader(errorCode, description, requiredScopes, resourceMetadataUrl) {
-	let header = `Bearer error="${headerQuotedValue(errorCode)}", error_description="${headerQuotedValue(description)}"`;
-	if (requiredScopes.length > 0) header += `, scope="${headerQuotedValue(requiredScopes.join(" "))}"`;
-	if (resourceMetadataUrl) header += `, resource_metadata="${headerQuotedValue(resourceMetadataUrl)}"`;
-	return header;
-}
-/**
-* Validate a raw `Authorization` header value as a Bearer token and return
-* the verified {@link AuthInfo}.
-*
-* The runtime-neutral core of Bearer authentication: it parses the header,
-* runs the verifier, compares the token's resource with `expectedResource`,
-* enforces `requiredScopes`, and rejects tokens without an
-* expiration or past it. On any failure it throws an {@link OAuthError} —
-* pass that to {@link bearerAuthChallengeResponse} for the matching HTTP
-* answer, or use {@link requireBearerAuth} to get both steps as one call.
-*
-* Framework adapters build on this: `requireBearerAuth` from
-* `@modelcontextprotocol/express` feeds it `req.headers.authorization`.
-*/
-async function verifyBearerToken(authorizationHeader, options) {
-	const { verifier, requiredScopes = [], expectedResource } = options;
-	if (!authorizationHeader) throw new OAuthError(OAuthErrorCode.InvalidToken, "Missing Authorization header");
-	const [type, token] = authorizationHeader.split(" ");
-	if (type?.toLowerCase() !== "bearer" || !token) throw new OAuthError(OAuthErrorCode.InvalidToken, "Invalid Authorization header format, expected 'Bearer TOKEN'");
-	const authInfo = await verifier.verifyAccessToken(token);
-	if (expectedResource !== void 0 && !sameResource(authInfo.resource, expectedResource)) throw new OAuthError(OAuthErrorCode.InvalidToken, "Token was not issued for this resource");
-	if (requiredScopes.length > 0) {
-		if (!requiredScopes.every((scope) => authInfo.scopes.includes(scope))) throw new OAuthError(OAuthErrorCode.InsufficientScope, "Insufficient scope");
-	}
-	if (typeof authInfo.expiresAt !== "number" || Number.isNaN(authInfo.expiresAt)) throw new OAuthError(OAuthErrorCode.InvalidToken, "Token has no expiration time");
-	else if (authInfo.expiresAt < Date.now() / 1e3) throw new OAuthError(OAuthErrorCode.InvalidToken, "Token has expired");
-	if (options.resourceMetadataUrl !== void 0 && authInfo.resourceMetadataUrl === void 0) return {
-		...authInfo,
-		resourceMetadataUrl: options.resourceMetadataUrl
-	};
-	return authInfo;
-}
-/**
-* Build the HTTP answer for a Bearer authentication failure.
-*
-* Maps an {@link OAuthError} to its status — `401` for `invalid_token` and
-* `403` for `insufficient_scope` (both carrying the `WWW-Authenticate: Bearer …`
-* challenge, with `resource_metadata` when configured so clients can discover
-* the Authorization Server), `500` for `server_error`, `400` for anything
-* else. A non-`OAuthError` value answers `500 server_error`. The body is the
-* OAuth error JSON.
-*/
-function bearerAuthChallengeResponse(error, options) {
-	const { requiredScopes = [], resourceMetadataUrl } = options ?? {};
-	if (!(error instanceof OAuthError)) {
-		const serverError = new OAuthError(OAuthErrorCode.ServerError, "Internal Server Error");
-		return Response.json(serverError.toResponseObject(), { status: 500 });
-	}
-	switch (error.code) {
-		case OAuthErrorCode.InvalidToken: {
-			const challenge = buildWwwAuthenticateHeader(error.code, error.message, requiredScopes, resourceMetadataUrl);
-			return Response.json(error.toResponseObject(), {
-				status: 401,
-				headers: { "WWW-Authenticate": challenge }
-			});
-		}
-		case OAuthErrorCode.InsufficientScope: {
-			const challenge = buildWwwAuthenticateHeader(error.code, error.message, requiredScopes, resourceMetadataUrl);
-			return Response.json(error.toResponseObject(), {
-				status: 403,
-				headers: { "WWW-Authenticate": challenge }
-			});
-		}
-		case OAuthErrorCode.ServerError: return Response.json(error.toResponseObject(), { status: 500 });
-		default: return Response.json(error.toResponseObject(), { status: 400 });
-	}
-}
-/**
-* Builds the RFC 9728 Protected Resource Metadata URL for a given MCP server
-* URL by inserting `/.well-known/oauth-protected-resource` ahead of the path.
-*
-* @example
-* ```ts
-* getOAuthProtectedResourceMetadataUrl(new URL('https://api.example.com/mcp'))
-* // → 'https://api.example.com/.well-known/oauth-protected-resource/mcp'
-* ```
-*/
-function getOAuthProtectedResourceMetadataUrl(serverUrl) {
-	const metadataUrl = new URL(serverUrl);
-	metadataUrl.pathname = protectedResourceMetadataPath(serverUrl);
-	metadataUrl.hash = "";
-	return metadataUrl.href;
-}
-/** The RFC 9728 path-aware well-known path for a resource URL. */
-function protectedResourceMetadataPath(resourceServerUrl) {
-	const rsPath = stripTrailingSlash(resourceServerUrl.pathname);
-	return `/.well-known/oauth-protected-resource${rsPath === "/" ? "" : rsPath}`;
-}
-function stripTrailingSlash(path) {
-	return path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
-}
-/** @internal */
-function supportsScopeChallengeResolver(transport) {
-	return typeof transport === "object" && transport !== null && "setScopeChallengeResolver" in transport && typeof transport.setScopeChallengeResolver === "function";
-}
-function assertScope(scope, location) {
-	if (typeof scope !== "string" || !/^[\u0021\u0023-\u005B\u005D-\u007E]+$/.test(scope)) throw new TypeError(`${location} must satisfy the OAuth scope-token grammar`);
-}
-function validateScopeChallenge(challenge) {
-	if (challenge === null || typeof challenge !== "object" || !Array.isArray(challenge.scopes) || challenge.scopes.length === 0) throw new TypeError("scope challenge must contain at least one scope");
-	for (const [index, scope] of challenge.scopes.entries()) assertScope(scope, `scope challenge scopes[${index}]`);
-	if (challenge.errorDescription !== void 0 && typeof challenge.errorDescription !== "string") throw new TypeError("scope challenge errorDescription must be a string");
-	if (challenge.errorDescription !== void 0 && !/^[\u0020-\u0021\u0023-\u005B\u005D-\u007E]+$/.test(challenge.errorDescription)) throw new TypeError("scope challenge errorDescription must satisfy the RFC 6750 error-description grammar");
-	return challenge;
-}
-/** @internal */
-async function findScopeChallenge(requests, authInfo, resolve) {
-	for (const request of requests) {
-		const challenge = await resolve({
-			request,
-			...authInfo !== void 0 && { authInfo }
-		});
-		if (challenge !== void 0) return validateScopeChallenge(challenge);
-	}
-}
-/**
-* The RFC 9728 Protected Resource Metadata URL to advertise on a scope
-* challenge, derived from the verified {@link AuthInfo}: the URL the
-* authentication gate stamped (`authInfo.resourceMetadataUrl`, set by the
-* bearer-auth helpers from their `resourceMetadataUrl` option), falling back
-* to the well-known location for an HTTP(S) RFC 8707 `resource` identifier, or
-* `undefined` when neither is available (the `resource_metadata` parameter is
-* then omitted, matching the bearer-auth challenges).
-*
-* @internal
-*/
-function scopeChallengeResourceMetadataUrl(authInfo) {
-	if (authInfo?.resourceMetadataUrl !== void 0) return authInfo.resourceMetadataUrl;
-	if (authInfo?.resource?.protocol === "https:" || authInfo?.resource?.protocol === "http:") return getOAuthProtectedResourceMetadataUrl(authInfo.resource);
-}
-/** @internal */
-function createScopeChallengeResponse(challenge, resourceMetadataUrl) {
-	return bearerAuthChallengeResponse(new OAuthError(OAuthErrorCode.InsufficientScope, challenge.errorDescription ?? "Insufficient scope"), {
-		requiredScopes: [...challenge.scopes],
-		resourceMetadataUrl
-	});
-}
-/**
-* Default handler re-entries per originating request — tighter than the
-* client driver's 10 because the shim holds a live wire request open.
-*/
-const DEFAULT_LEGACY_SHIM_MAX_ROUNDS = 8;
-/** Default per-leg timeout: legs are human-paced, so the 60s protocol default is wrong. */
-const DEFAULT_LEGACY_SHIM_ROUND_TIMEOUT_MS = 6e5;
-/** Resolves and validates `ServerOptions.inputRequired`, failing loudly at construction time. */
-function resolveLegacyShimOptions(options) {
-	if (options?.maxRounds !== void 0 && (!Number.isInteger(options.maxRounds) || options.maxRounds < 1)) throw new RangeError(`inputRequired.maxRounds must be a positive integer (got ${options.maxRounds})`);
-	if (options?.roundTimeoutMs !== void 0 && (!Number.isFinite(options.roundTimeoutMs) || options.roundTimeoutMs <= 0)) throw new RangeError(`inputRequired.roundTimeoutMs must be a positive number (got ${options.roundTimeoutMs})`);
-	return {
-		maxRounds: options?.maxRounds ?? DEFAULT_LEGACY_SHIM_MAX_ROUNDS,
-		roundTimeoutMs: options?.roundTimeoutMs ?? DEFAULT_LEGACY_SHIM_ROUND_TIMEOUT_MS,
-		legacyShim: options?.legacyShim ?? true
-	};
-}
-/**
-* Validates one `inputRequests` entry: malformed or unknown kinds are server
-* bugs and fail loudly on both eras. Shared by the modern seam's capability
-* check and the shim's gate.
-*/
-function coerceEmbeddedInputRequest(method, key, entry) {
-	if (entry === null || typeof entry !== "object" || typeof entry.method !== "string") throw new ProtocolError(ProtocolErrorCode.InternalError, `Handler for ${method} returned an invalid input request '${key}': each inputRequests entry must be an embedded elicitation/create, sampling/createMessage, or roots/list request`);
-	const embedded = entry;
-	const required = requiredClientCapabilitiesForInputRequest(embedded);
-	if (required === void 0) throw new ProtocolError(ProtocolErrorCode.InternalError, `Handler for ${method} returned an input request '${key}' of kind '${embedded.method}', which is not an embedded request the 2026-07-28 revision defines`);
-	return {
-		embedded,
-		required
-	};
+function coerceEmbeddedInputRequest(method, key, entry) {
+	if (entry === null || typeof entry !== "object" || typeof entry.method !== "string") throw new ProtocolError(ProtocolErrorCode.InternalError, `Handler for ${method} returned an invalid input request '${key}': each inputRequests entry must be an embedded elicitation/create, sampling/createMessage, or roots/list request`);
+	const embedded = entry;
+	const required = requiredClientCapabilitiesForInputRequest(embedded);
+	if (required === void 0) throw new ProtocolError(ProtocolErrorCode.InternalError, `Handler for ${method} returned an input request '${key}' of kind '${embedded.method}', which is not an embedded request the 2026-07-28 revision defines`);
+	return {
+		embedded,
+		required
+	};
 }
 /**
 * The 2025-11-25 URL-mode wire shape requires an `elicitationId`; the 2026
@@ -25129,6 +25467,7 @@ var Server = class extends Protocol {
 	_requestStateVerify;
 	_inputRequiredServing;
 	_legacyShim;
+	_boundFromTransport = false;
 	/** Lazily-built legacy shim; the loop lives in legacyInputRequiredShim.ts behind a narrow host contract. */
 	_legacyInputRequiredShim() {
 		return this._legacyShim ??= new LegacyInputRequiredShim({
@@ -25168,6 +25507,15 @@ var Server = class extends Protocol {
 	/** Attaches to the given transport; rejects while this instance is connected to another one. */
 	async connect(transport) {
 		if (this.transport !== void 0) throw new SdkError(SdkErrorCode.AlreadyConnected, "Use a separate Server instance per connection: this instance is already connected to a transport. To connect it to a new transport, call close() first.");
+		if (this._boundFromTransport) {
+			this._boundFromTransport = false;
+			this._negotiatedProtocolVersion = void 0;
+		}
+		const revision = perRequestClassificationOf(transport)?.revision;
+		if (revision !== void 0 && !this._servedModernEra() && SUPPORTED_MODERN_PROTOCOL_VERSIONS.includes(revision) && modernProtocolVersions(this._supportedProtocolVersions).includes(revision)) {
+			this._negotiatedProtocolVersion = revision;
+			this._boundFromTransport = true;
+		}
 		await super.connect(transport);
 	}
 	/**
@@ -25478,8 +25826,8 @@ var Server = class extends Protocol {
 	* @deprecated Read client identity from the per-request handler context instead: on
 	* 2026-07-28 (per-request envelope) requests `ctx.mcpReq.envelope` carries the client's
 	* declared capabilities, while on 2025-era connections this accessor keeps returning the
-	* `initialize`-scoped value. The accessor remains functional — instances serving the
-	* 2026-07-28 era are backfilled per request from the validated envelope.
+	* `initialize`-scoped value. The accessor remains functional where `createMcpHandler`
+	* serves the 2026-07-28 era: it backfills it per request from the validated envelope.
 	*/
 	getClientCapabilities() {
 		return this._clientCapabilities;
@@ -25490,8 +25838,8 @@ var Server = class extends Protocol {
 	* @deprecated Read client identity from the per-request handler context instead: on
 	* 2026-07-28 (per-request envelope) requests `ctx.mcpReq.envelope` carries the client's
 	* name and version, while on 2025-era connections this accessor keeps returning the
-	* `initialize`-scoped value. The accessor remains functional — instances serving the
-	* 2026-07-28 era are backfilled per request from the validated envelope.
+	* `initialize`-scoped value. The accessor remains functional where `createMcpHandler`
+	* serves the 2026-07-28 era: it backfills it per request from the validated envelope.
 	*/
 	getClientVersion() {
 		return this._clientVersion;
@@ -26084,8 +26432,14 @@ var McpServer = class {
 					if (updates.uri) this._registeredResources[updates.uri] = registeredResource;
 				}
 				if (updates.name !== void 0) registeredResource.name = updates.name;
-				if (updates.title !== void 0) registeredResource.title = updates.title;
 				if (updates.metadata !== void 0) registeredResource.metadata = updates.metadata;
+				if (updates.title !== void 0) {
+					registeredResource.title = updates.title;
+					registeredResource.metadata = {
+						...registeredResource.metadata,
+						title: updates.title
+					};
+				}
 				if (updates.callback !== void 0) registeredResource.readCallback = updates.callback;
 				if (updates.scopeChallenge !== void 0) registeredResource.scopeChallenge = updates.scopeChallenge === null ? void 0 : updates.scopeChallenge;
 				if (updates.enabled !== void 0) registeredResource.enabled = updates.enabled;
@@ -26111,9 +26465,15 @@ var McpServer = class {
 					delete this._registeredResourceTemplates[name];
 					if (updates.name) this._registeredResourceTemplates[updates.name] = registeredResourceTemplate;
 				}
-				if (updates.title !== void 0) registeredResourceTemplate.title = updates.title;
 				if (updates.template !== void 0) registeredResourceTemplate.resourceTemplate = updates.template;
 				if (updates.metadata !== void 0) registeredResourceTemplate.metadata = updates.metadata;
+				if (updates.title !== void 0) {
+					registeredResourceTemplate.title = updates.title;
+					registeredResourceTemplate.metadata = {
+						...registeredResourceTemplate.metadata,
+						title: updates.title
+					};
+				}
 				if (updates.callback !== void 0) registeredResourceTemplate.readCallback = updates.callback;
 				if (updates.scopeChallenge !== void 0) registeredResourceTemplate.scopeChallenge = updates.scopeChallenge === null ? void 0 : updates.scopeChallenge;
 				if (updates.enabled !== void 0) registeredResourceTemplate.enabled = updates.enabled;
@@ -26372,234 +26732,298 @@ function convertOutputSchemaJson(outputSchema) {
 		return;
 	}
 }
-/**
-* Creates a type-safe prompt handler that captures the schema and callback in a closure.
-* This eliminates the need for type assertions at the call site.
-*/
-function createPromptHandler(name, argsSchema, callback) {
-	if (argsSchema) {
-		const typedCallback = callback;
-		return async (args, ctx) => {
-			const parseResult = await validateStandardSchema(argsSchema, args ?? {});
-			if (!parseResult.success) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid arguments for prompt ${name}: ${parseResult.error}`);
-			return typedCallback(parseResult.data, ctx);
+/**
+* Creates a type-safe prompt handler that captures the schema and callback in a closure.
+* This eliminates the need for type assertions at the call site.
+*/
+function createPromptHandler(name, argsSchema, callback) {
+	if (argsSchema) {
+		const typedCallback = callback;
+		return async (args, ctx) => {
+			const parseResult = await validateStandardSchema(argsSchema, args ?? {});
+			if (!parseResult.success) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid arguments for prompt ${name}: ${parseResult.error}`);
+			return typedCallback(parseResult.data, ctx);
+		};
+	} else {
+		const typedCallback = callback;
+		return async (_args, ctx) => {
+			return typedCallback(ctx);
+		};
+	}
+}
+function createCompletionResult(suggestions) {
+	return { completion: {
+		values: suggestions.map(String).slice(0, 100),
+		total: suggestions.length,
+		hasMore: suggestions.length > 100
+	} };
+}
+const EMPTY_COMPLETION_RESULT = { completion: {
+	values: [],
+	hasMore: false
+} };
+/** @internal Gets the shape of a Zod object schema */
+function getSchemaShape(schema) {
+	const candidate = schema;
+	if (candidate.shape && typeof candidate.shape === "object") return candidate.shape;
+}
+/** @internal Checks if a Zod schema is optional */
+function isOptionalSchema(schema) {
+	return schema?.type === "optional";
+}
+/** @internal Unwraps an optional Zod schema */
+function unwrapOptionalSchema(schema) {
+	if (!isOptionalSchema(schema)) return schema;
+	return schema.def?.innerType ?? schema;
+}
+//#endregion
+//#region node_modules/.pnpm/@modelcontextprotocol+server@2.4.0/node_modules/@modelcontextprotocol/server/dist/listenRouter-Bartj63y.mjs
+/**
+* A `ServerEventBus` backed by an in-process listener set.
+*
+* `publish()` delivers synchronously to the live listener set (a listener
+* unsubscribing itself mid-dispatch is safe; the entry's listen-router
+* listeners never unsubscribe peers). A throwing listener does not stop
+* delivery to the others.
+*/
+var InMemoryServerEventBus = class {
+	_listeners = /* @__PURE__ */ new Set();
+	/**
+	* @param onerror - Optional callback for errors thrown by listeners
+	*   during dispatch.
+	*/
+	constructor(onerror) {
+		this.onerror = onerror;
+	}
+	publish(event) {
+		for (const listener of this._listeners) try {
+			listener(event);
+		} catch (error) {
+			this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+	subscribe(listener) {
+		this._listeners.add(listener);
+		let live = true;
+		return () => {
+			if (!live) return;
+			live = false;
+			this._listeners.delete(listener);
+		};
+	}
+	/** The number of currently registered listeners (test/introspection only — the routers track capacity via their own open-subscription set). */
+	get listenerCount() {
+		return this._listeners.size;
+	}
+};
+/** Build a {@linkcode ServerNotifier} over a bus. */
+function createServerNotifier(bus) {
+	return {
+		toolsChanged: () => bus.publish({ kind: "tools_list_changed" }),
+		promptsChanged: () => bus.publish({ kind: "prompts_list_changed" }),
+		resourcesChanged: () => bus.publish({ kind: "resources_list_changed" }),
+		resourceUpdated: (uri) => bus.publish({
+			kind: "resource_updated",
+			uri
+		})
+	};
+}
+/**
+* Whether a `subscriptions/listen` filter accepts a given change event.
+*
+* Pure: no I/O, no mutation. The filter governs ONLY the four
+* subscription-gated change types — non-gated notifications never reach the
+* bus and are not modeled here.
+*
+* `resource_updated` matches only when `resourceSubscriptions` is present and
+* contains the event's URI exactly (per the spec: "for these resource URIs").
+*/
+function listenFilterAccepts(filter, event) {
+	switch (event.kind) {
+		case "tools_list_changed": return filter.toolsListChanged === true;
+		case "prompts_list_changed": return filter.promptsListChanged === true;
+		case "resources_list_changed": return filter.resourcesListChanged === true;
+		case "resource_updated": return filter.resourceSubscriptions !== void 0 && filter.resourceSubscriptions.includes(event.uri);
+	}
+}
+/**
+* The honored subset of a requested filter: keeps only the fields the client
+* explicitly opted in to (drops `false` and absent fields), narrowed against
+* the server's declared capabilities when supplied. The serving entry sends
+* this back in `notifications/subscriptions/acknowledged` so the ack reflects
+* what the server can actually deliver.
+*
+* - `toolsListChanged` is honored only when `capabilities.tools.listChanged`
+*   is advertised; likewise `promptsListChanged` / `resourcesListChanged`.
+* - `resourceSubscriptions` is honored only when
+*   `capabilities.resources.subscribe` is advertised.
+*
+* `capabilities` is optional on this pure helper for test convenience only —
+* both wired routers REQUIRE capabilities at the call site (the HTTP router's
+* `serve()` takes a required parameter; `StdioListenRouter.serve()` throws
+* before `setServerCapabilities()` was called), so the fail-open
+* `undefined → honor everything` branch is never reachable on a wired entry.
+*/
+function honoredSubset(requested, capabilities) {
+	const honored = {};
+	const allow = (bit) => capabilities === void 0 || bit === true;
+	if (requested.toolsListChanged === true && allow(capabilities?.tools?.listChanged)) honored.toolsListChanged = true;
+	if (requested.promptsListChanged === true && allow(capabilities?.prompts?.listChanged)) honored.promptsListChanged = true;
+	if (requested.resourcesListChanged === true && allow(capabilities?.resources?.listChanged)) honored.resourcesListChanged = true;
+	if (requested.resourceSubscriptions !== void 0 && requested.resourceSubscriptions.length > 0 && allow(capabilities?.resources?.subscribe)) honored.resourceSubscriptions = [...requested.resourceSubscriptions];
+	return honored;
+}
+/** Map a {@linkcode ServerEvent} onto its wire notification `{method, params}`. */
+function serverEventToNotification(event) {
+	switch (event.kind) {
+		case "tools_list_changed": return {
+			method: "notifications/tools/list_changed",
+			...event.params !== void 0 && { params: event.params }
 		};
-	} else {
-		const typedCallback = callback;
-		return async (_args, ctx) => {
-			return typedCallback(ctx);
+		case "prompts_list_changed": return {
+			method: "notifications/prompts/list_changed",
+			...event.params !== void 0 && { params: event.params }
+		};
+		case "resources_list_changed": return {
+			method: "notifications/resources/list_changed",
+			...event.params !== void 0 && { params: event.params }
+		};
+		case "resource_updated": return {
+			method: "notifications/resources/updated",
+			params: {
+				...event.params,
+				uri: event.uri
+			}
 		};
 	}
 }
-function createCompletionResult(suggestions) {
-	return { completion: {
-		values: suggestions.map(String).slice(0, 100),
-		total: suggestions.length,
-		hasMore: suggestions.length > 100
-	} };
-}
-const EMPTY_COMPLETION_RESULT = { completion: {
-	values: [],
-	hasMore: false
-} };
-/** @internal Gets the shape of a Zod object schema */
-function getSchemaShape(schema) {
-	const candidate = schema;
-	if (candidate.shape && typeof candidate.shape === "object") return candidate.shape;
-}
-/** @internal Checks if a Zod schema is optional */
-function isOptionalSchema(schema) {
-	return schema?.type === "optional";
+/** Default capacity guard: refuse a new subscription when this many are already open. */
+const DEFAULT_MAX_SUBSCRIPTIONS = 1024;
+function jsonRpcError(id, code, message) {
+	return Response.json({
+		jsonrpc: "2.0",
+		error: {
+			code,
+			message
+		},
+		id
+	}, { status: 200 });
 }
-/** @internal Unwraps an optional Zod schema */
-function unwrapOptionalSchema(schema) {
-	if (!isOptionalSchema(schema)) return schema;
-	return schema.def?.innerType ?? schema;
+/** Stamp the subscription id onto a notification's `_meta`. Non-mutating. */
+function stampSubscriptionId(notification, subscriptionId) {
+	return {
+		method: notification.method,
+		params: {
+			...notification.params,
+			_meta: {
+				...notification.params?._meta,
+				[SUBSCRIPTION_ID_META_KEY]: subscriptionId
+			}
+		}
+	};
 }
-//#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+server@2.3.1/node_modules/@modelcontextprotocol/server/dist/index.mjs
 /**
-* The per-request micro-transport: a real, connected `Transport` whose whole
-* lifetime is one HTTP exchange. See the module documentation for the
-* response shapes it produces.
+* Read the requested filter off a `subscriptions/listen` request body.
+* Returns the validated filter, or `undefined` when `params.notifications`
+* is absent or fails the schema (the caller answers `-32602` — the spec
+* marks `notifications` REQUIRED on the listen request).
 */
-var PerRequestHTTPServerTransport = class {
-	onclose;
-	onerror;
-	onmessage;
-	_classification;
-	_responseMode;
-	_started = false;
-	_used = false;
-	_closed = false;
-	_terminalDelivered = false;
-	/**
-	* `true` only while the inbound message is being delivered synchronously
-	* to the connected protocol layer. The pre-handler gates (the era
-	* registry gate, the edge→instance handoff check, the missing-handler
-	* rejection) answer inside this window; request handlers always run
-	* after it (the protocol layer defers them to a microtask). An error
-	* sent inside the window is therefore ladder-originated, and an error
-	* sent after it is handler-produced.
-	*/
-	_dispatchWindowOpen = false;
-	_requestId;
-	_deferredResponse;
-	_sse;
-	_abortCleanup;
-	_keepAliveMs;
-	constructor(options) {
-		this._classification = options.classification;
-		this._responseMode = options.responseMode ?? "auto";
-		this._keepAliveMs = options.keepAliveMs ?? 15e3;
-	}
-	async start() {
-		if (this._started) throw new Error("PerRequestHTTPServerTransport is already started");
-		this._started = true;
-	}
-	/**
-	* Serves the single exchange: delivers the classified message to the
-	* connected server instance and resolves with the HTTP response.
-	*
-	* Throws when called a second time (the transport is strictly
-	* single-use), or before a server has been connected to the transport.
-	* The returned promise rejects with a connection-closed error when the
-	* transport is closed before a response was produced (for example because
-	* the client disconnected).
-	*/
-	async handleMessage(message, extra) {
-		if (this._used) throw new Error("PerRequestHTTPServerTransport serves exactly one exchange; construct a new transport per request");
-		if (!this._started || this.onmessage === void 0) throw new Error("PerRequestHTTPServerTransport is not connected: connect a server to this transport before handling a message");
-		if (this._closed) throw new Error("PerRequestHTTPServerTransport is closed");
-		this._used = true;
-		const signal = extra?.request?.signal;
-		if (signal?.aborted) {
-			await this.close();
-			throw new SdkError(SdkErrorCode.ConnectionClosed, "The request was aborted before it could be handled");
+function parseListenFilter(message) {
+	const outcome = codecForVersion(MODERN_WIRE_REVISION).validateRequest("subscriptions/listen", message);
+	return outcome.ok ? outcome.value.params?.notifications : void 0;
+}
+function createListenRouter(options) {
+	const { bus, onerror } = options;
+	const maxSubscriptions = options.maxSubscriptions ?? 1024;
+	const keepAliveMs = options.keepAliveMs ?? 15e3;
+	const open = /* @__PURE__ */ new Set();
+	function serve(message, signal, capabilities, serverInfo) {
+		if (open.size >= maxSubscriptions) {
+			onerror?.(/* @__PURE__ */ new Error(`subscriptions/listen refused: subscription limit reached (${maxSubscriptions})`));
+			return jsonRpcError(message.id, -32603, "Subscription limit reached");
 		}
-		const messageExtra = {
-			classification: this._classification,
-			...extra?.request !== void 0 && { request: extra.request },
-			...extra?.authInfo !== void 0 && { authInfo: extra.authInfo }
-		};
-		if (isJSONRPCRequest(message)) {
-			this._requestId = message.id;
-			let resolve;
-			let reject;
-			const promise = new Promise((promiseResolve, promiseReject) => {
-				resolve = promiseResolve;
-				reject = promiseReject;
-			});
-			this._deferredResponse = {
-				promise,
-				resolve,
-				reject,
-				settled: false
-			};
-			if (signal !== void 0) {
-				const onAbort = () => void this.close();
-				signal.addEventListener("abort", onAbort, { once: true });
-				this._abortCleanup = () => signal.removeEventListener("abort", onAbort);
-			}
-			this._dispatchWindowOpen = true;
+		const filter = parseListenFilter(message);
+		if (filter === void 0) return jsonRpcError(message.id, -32602, "Invalid params: 'notifications' is required and must be a valid SubscriptionFilter");
+		const honored = honoredSubset(filter, capabilities);
+		const subscriptionId = message.id;
+		const encoder = new TextEncoder();
+		let controller;
+		let closed = false;
+		let unsubscribe;
+		let keepAliveTimer;
+		let abortCleanup;
+		const writeFrame = (frame) => {
+			if (closed) return;
 			try {
-				this.onmessage(message, messageExtra);
-			} finally {
-				this._dispatchWindowOpen = false;
-			}
-			if (this._responseMode === "sse" && !this._closed && !this._deferredResponse.settled) this.upgradeToSse();
-			return promise;
-		}
-		this.onmessage(message, messageExtra);
-		return new Response(null, { status: 202 });
-	}
-	async send(message, options) {
-		if (this._closed) return;
-		const isResponse = isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message);
-		const relatedId = isResponse ? message.id : options?.relatedRequestId;
-		if (this._requestId === void 0 || relatedId === void 0 || relatedId !== this._requestId) {
-			if (isResponse) this.onerror?.(/* @__PURE__ */ new Error(`Received a response for an unknown request id: ${String(message.id)}`));
-			return;
-		}
-		if (isResponse) {
-			if (this._terminalDelivered) return;
-			this._terminalDelivered = true;
-			const errorCode = isJSONRPCErrorResponse(message) ? message.error.code : void 0;
-			const ladderStatus = errorCode !== void 0 && (this._dispatchWindowOpen || errorCode === ProtocolErrorCode.MissingRequiredClientCapability) ? LADDER_ERROR_HTTP_STATUS[errorCode] : void 0;
-			if (ladderStatus !== void 0 && this._sse === void 0) {
-				this.settleResponse(Response.json(message, {
-					status: ladderStatus,
-					headers: { "Content-Type": "application/json" }
-				}));
-				queueMicrotask(() => void this.close());
-				return;
-			}
-			if (this._sse !== void 0 || this._responseMode === "sse") {
-				if (this._sse === void 0) this.upgradeToSse();
-				this.writeMessageFrame(message);
-				this.finalizeStream();
-				return;
+				controller.enqueue(encoder.encode(frame));
+			} catch (error) {
+				onerror?.(error instanceof Error ? error : new Error(String(error)));
 			}
-			this.settleResponse(Response.json(message, {
-				status: 200,
-				headers: { "Content-Type": "application/json" }
-			}));
-			queueMicrotask(() => void this.close());
-			return;
-		}
-		if (this._responseMode === "json") return;
-		if (this._sse === void 0) this.upgradeToSse();
-		this.writeMessageFrame(message);
-	}
-	/**
-	* Writes an SSE comment frame (a keep-alive heartbeat). Dropped when the
-	* exchange is not currently streaming.
-	*/
-	writeCommentFrame(comment) {
-		if (this._closed || this._sse === void 0 || this._sse.closed) return;
-		const frame = comment.split("\n").map((line) => `: ${line}`).join("\n");
-		this.writeFrame(`${frame}\n\n`);
-	}
-	async close() {
-		if (this._closed) return;
-		this._closed = true;
-		this._abortCleanup?.();
-		this._abortCleanup = void 0;
-		if (this._sse?.keepAliveTimer !== void 0) clearInterval(this._sse.keepAliveTimer);
-		if (this._sse !== void 0 && !this._sse.closed) {
-			this._sse.closed = true;
+		};
+		const writeNotification = (method, params) => {
+			writeFrame(`event: message\ndata: ${JSON.stringify({
+				jsonrpc: "2.0",
+				method,
+				params
+			})}\n\n`);
+		};
+		const teardown = (graceful) => {
+			if (closed) return;
+			if (graceful) writeFrame(`event: message\ndata: ${JSON.stringify({
+				jsonrpc: "2.0",
+				id: subscriptionId,
+				result: {
+					resultType: "complete",
+					_meta: {
+						[SUBSCRIPTION_ID_META_KEY]: subscriptionId,
+						[SERVER_INFO_META_KEY]: serverInfo
+					}
+				}
+			})}\n\n`);
+			closed = true;
 			try {
-				this._sse.controller.close();
+				unsubscribe?.();
+			} catch (error) {
+				onerror?.(error instanceof Error ? error : new Error(String(error)));
+			}
+			if (keepAliveTimer !== void 0) clearInterval(keepAliveTimer);
+			abortCleanup?.();
+			open.delete(teardown);
+			try {
+				controller.close();
 			} catch {}
-		}
-		if (this._deferredResponse !== void 0 && !this._deferredResponse.settled) {
-			this._deferredResponse.settled = true;
-			this._deferredResponse.reject(new SdkError(SdkErrorCode.ConnectionClosed, "Connection closed before a response was produced"));
-		}
-		this.onclose?.();
-	}
-	settleResponse(response) {
-		if (this._deferredResponse === void 0 || this._deferredResponse.settled) return;
-		this._deferredResponse.settled = true;
-		this._deferredResponse.resolve(response);
-	}
-	upgradeToSse() {
-		let controller;
+		};
 		const readable = new ReadableStream({
-			start: (streamController) => {
+			start(streamController) {
 				controller = streamController;
+				const ack = stampSubscriptionId({
+					method: "notifications/subscriptions/acknowledged",
+					params: { notifications: honored }
+				}, subscriptionId);
+				writeNotification(ack.method, ack.params);
+				if (Object.keys(honored).length === 0) {
+					teardown(true);
+					return;
+				}
+				unsubscribe = bus.subscribe((event) => {
+					if (closed || !listenFilterAccepts(honored, event)) return;
+					const note = stampSubscriptionId(serverEventToNotification(event), subscriptionId);
+					writeNotification(note.method, note.params);
+				});
+				keepAliveTimer = armSseKeepAlive(keepAliveMs, () => writeFrame(": keepalive\n\n"));
+				open.add(teardown);
 			},
-			cancel: () => {
-				this.close();
+			cancel() {
+				teardown(false);
 			}
 		});
-		this._sse = {
-			controller,
-			encoder: new TextEncoder(),
-			closed: false
-		};
-		this._sse.keepAliveTimer = armSseKeepAlive(this._keepAliveMs, () => this.writeCommentFrame("keepalive"));
-		this.settleResponse(new Response(readable, {
+		if (signal !== void 0) if (signal.aborted) teardown(false);
+		else {
+			const onAbort = () => teardown(false);
+			signal.addEventListener("abort", onAbort, { once: true });
+			abortCleanup = () => signal.removeEventListener("abort", onAbort);
+		}
+		return new Response(readable, {
 			status: 200,
 			headers: {
 				"Content-Type": "text/event-stream",
@@ -26607,30 +27031,170 @@ var PerRequestHTTPServerTransport = class {
 				Connection: "keep-alive",
 				"X-Accel-Buffering": "no"
 			}
-		}));
+		});
 	}
-	finalizeStream() {
-		if (this._sse?.keepAliveTimer !== void 0) clearInterval(this._sse.keepAliveTimer);
-		if (this._sse !== void 0 && !this._sse.closed) {
-			this._sse.closed = true;
-			try {
-				this._sse.controller.close();
-			} catch {}
+	return {
+		serve,
+		closeAll() {
+			for (const teardown of open) teardown(true);
+		},
+		get openCount() {
+			return open.size;
 		}
-		queueMicrotask(() => void this.close());
+	};
+}
+const CHANGE_NOTIFICATION_METHODS = /* @__PURE__ */ new Set([
+	"notifications/tools/list_changed",
+	"notifications/prompts/list_changed",
+	"notifications/resources/list_changed",
+	"notifications/resources/updated"
+]);
+/**
+* Per-connection listen state for the stdio entry. One instance is held by
+* `serveStdio` for the connection lifetime; it routes inbound
+* `subscriptions/listen` / `notifications/cancelled` and rewrites outbound
+* change notifications onto the active subscriptions. No bus — the long-lived
+* pinned instance's existing `send*ListChanged()` calls feed straight into
+* `routeOutbound()`.
+*/
+var StdioListenRouter = class {
+	/** Active subscriptions, keyed by the listen request's JSON-RPC id verbatim. */
+	_subs = /* @__PURE__ */ new Map();
+	/**
+	* The serving instance's declared capabilities. Filled in by the entry
+	* once the modern instance is constructed (the router is created before
+	* the instance exists), so the acknowledged filter is narrowed against
+	* what the server can actually deliver.
+	*/
+	_serverCapabilities;
+	/**
+	* The serving instance's identity, stamped onto the graceful-close
+	* results' `_meta` (the spec's `SubscriptionsListenResultMetaObject` extends
+	* `ResultMetaObject`). Handed over together with the capabilities.
+	*/
+	_serverInfo;
+	constructor(_maxSubscriptions = DEFAULT_MAX_SUBSCRIPTIONS, serverCapabilities, serverInfo) {
+		this._maxSubscriptions = _maxSubscriptions;
+		this._serverCapabilities = serverCapabilities;
+		this._serverInfo = serverInfo;
 	}
-	writeMessageFrame(message) {
-		this.writeFrame(`event: message\ndata: ${JSON.stringify(message)}\n\n`);
+	/**
+	* Record the serving instance's declared capabilities and identity once
+	* it has been constructed. Called by `serveStdio`'s connect path;
+	* subsequent `serve()` calls narrow the honored filter against the
+	* capabilities, and `teardownAll()` stamps the identity.
+	*/
+	setServerCapabilities(capabilities, serverInfo) {
+		this._serverCapabilities = capabilities;
+		if (serverInfo !== void 0) this._serverInfo = serverInfo;
 	}
-	writeFrame(frame) {
-		if (this._sse === void 0 || this._sse.closed) return;
-		try {
-			this._sse.controller.enqueue(this._sse.encoder.encode(frame));
-		} catch (error) {
-			this.onerror?.(/* @__PURE__ */ new Error(`Failed to write to the response stream: ${error}`));
-		}
+	/** Whether `id` is an active listen subscription on this connection. */
+	has(id) {
+		return this._subs.has(id);
+	}
+	/**
+	* Serve one inbound `subscriptions/listen` request: registers the
+	* subscription and returns the stamped acknowledged notification (or, on
+	* capacity / params rejection, the in-band JSON-RPC error response).
+	*
+	* @throws when called before {@linkcode setServerCapabilities} (or the
+	* constructor) has supplied the serving instance's capabilities. Honoring a
+	* filter without knowing the server's advertised capabilities would fail
+	* open (deliver unadvertised types); the entry guarantees capabilities are
+	* set before any listen request is routed here.
+	*/
+	serve(message) {
+		if (this._serverCapabilities === void 0) throw new Error("StdioListenRouter.serve() called before setServerCapabilities(); refusing to honor a filter without capabilities");
+		if (this._subs.size >= this._maxSubscriptions) return {
+			jsonrpc: "2.0",
+			id: message.id,
+			error: {
+				code: -32603,
+				message: "Subscription limit reached"
+			}
+		};
+		const filter = parseListenFilter(message);
+		if (filter === void 0) return {
+			jsonrpc: "2.0",
+			id: message.id,
+			error: {
+				code: -32602,
+				message: "Invalid params: 'notifications' is required and must be a valid SubscriptionFilter"
+			}
+		};
+		const honored = honoredSubset(filter, this._serverCapabilities);
+		this._subs.set(message.id, honored);
+		return stampSubscriptionId({
+			method: "notifications/subscriptions/acknowledged",
+			params: { notifications: honored }
+		}, message.id);
+	}
+	/**
+	* Tear down one subscription (inbound `notifications/cancelled`). Returns
+	* `true` when a subscription was removed. After this call NOTHING further
+	* is delivered for that subscription id (the post-cancel hardening).
+	*/
+	cancel(id) {
+		return this._subs.delete(id);
+	}
+	/**
+	* Route an outbound notification through the active subscriptions.
+	*
+	* - For a subscription-gated change notification, returns one stamped copy
+	*   per subscription that opted in to it (an empty array means it is
+	*   dropped — the modern era never delivers an un-requested change type).
+	* - For any other outbound message, returns `'passthrough'` (the entry
+	*   forwards it as-is).
+	*/
+	routeOutbound(message) {
+		if (!CHANGE_NOTIFICATION_METHODS.has(message.method)) return "passthrough";
+		const uriParam = message.params?.["uri"];
+		const uri = typeof uriParam === "string" ? uriParam : void 0;
+		const event = notificationToServerEvent(message.method, uri);
+		const out = [];
+		for (const [subscriptionId, filter] of this._subs) if (listenFilterAccepts(filter, event)) out.push(stampSubscriptionId({
+			method: message.method,
+			params: message.params ?? {}
+		}, subscriptionId));
+		return out;
+	}
+	/**
+	* Server-side graceful teardown of every active subscription: returns the
+	* empty `subscriptions/listen` JSON-RPC result for each subscription id —
+	* the spec's graceful-close signal, `_meta` carrying the subscription id
+	* and the serving instance's identity — for the entry to emit before
+	* closing the wire. Clears the set so nothing further is delivered.
+	*/
+	teardownAll() {
+		const out = [];
+		for (const id of this._subs.keys()) out.push({
+			jsonrpc: "2.0",
+			id,
+			result: {
+				resultType: "complete",
+				_meta: {
+					[SUBSCRIPTION_ID_META_KEY]: id,
+					...this._serverInfo !== void 0 && { ["io.modelcontextprotocol/serverInfo"]: this._serverInfo }
+				}
+			}
+		});
+		this._subs.clear();
+		return out;
 	}
 };
+function notificationToServerEvent(method, uri) {
+	switch (method) {
+		case "notifications/tools/list_changed": return { kind: "tools_list_changed" };
+		case "notifications/prompts/list_changed": return { kind: "prompts_list_changed" };
+		case "notifications/resources/list_changed": return { kind: "resources_list_changed" };
+		default: return {
+			kind: "resource_updated",
+			uri: uri ?? ""
+		};
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/@modelcontextprotocol+server@2.4.0/node_modules/@modelcontextprotocol/server/dist/index.mjs
 /**
 * Serves one classified inbound message on the given server instance and
 * returns the HTTP response for the exchange.
@@ -27430,7 +27994,10 @@ function jsonRpcErrorResponse(httpStatus, code, message, data, id = null) {
 			...data !== void 0 && { data }
 		},
 		id
-	}, { status: httpStatus });
+	}, {
+		status: httpStatus,
+		...httpStatus === 405 && { headers: { Allow: "POST" } }
+	});
 }
 function rejectionResponse(rejection, id = null) {
 	return jsonRpcErrorResponse(rejection.httpStatus, rejection.code, rejection.message, rejection.data, id);
@@ -27793,7 +28360,7 @@ function createMcpHandler(factory, options = {}) {
 			const inputSchema = toolName === void 0 ? void 0 : product.toolInputSchemaJson(toolName);
 			if (inputSchema !== void 0) {
 				const scan = scanXMcpHeaderDeclarations(inputSchema);
-				if (scan.valid && scan.declarations.length > 0) {
+				if (scan.declarations !== void 0 && scan.declarations.length > 0) {
 					const rejection = validateMcpParamHeaders(scan.declarations, callParams?.arguments, request.headers);
 					if (rejection !== void 0) {
 						product.close().catch(reportError);
@@ -28419,7 +28986,7 @@ const memoisedUntilFailure = (load) => {
 * processes never touch an article, and it is the heaviest code in the bundle.
 * `tests/unit/module-graph.test.ts` keeps it off the static graph.
 */
-const loadArticleFormat = memoisedUntilFailure(() => import("./article-sections-CzTODYsS.js"));
+const loadArticleFormat = memoisedUntilFailure(() => import("./article-sections-DA7_Jm2H.js"));
 //#endregion
 //#region src/utils/formatting.ts
 const truncateIfNeeded = (text, advice = "Use pagination or filters to reduce results.") => {
@@ -33761,9 +34328,9 @@ const registerSingleProxies = (registration, tools) => {
 * (`dev/reload.ts`) can keep this long-lived shell (and its transport/session)
 * alive while swapping the toolset underneath it via `registerToolset`.
 */
-const createServerShell = (config, requestStateCodec = createRequestStateCodec({})) => {
+const createServerShell = (config, requestStateCodec = createRequestStateCodec({}), extraInstructions) => {
 	const pkg = readPackageInfo();
-	const instructions = buildInstructions(config);
+	const instructions = [buildInstructions(config), extraInstructions].filter((block) => block !== void 0).join("\n\n") || void 0;
 	return new McpServer({
 		name: pkg.name,
 		version: pkg.version
@@ -34081,8 +34648,8 @@ const toolEnv = (config) => ({
 	subdomain: config.subdomain,
 	brandIds: config.brandIds
 });
-const createMcpServer = (config, getToken, logger = silentLogger, onUnauthorized, { caches = createServerCaches(config, getToken, onUnauthorized), requestStateCodec, slaRuntime = createSlaRuntime(config), listens, getBackgroundToken, alertPolling = "server", tools = createAllTools(toolEnv(config)) } = {}) => {
-	const server = createServerShell(config, requestStateCodec);
+const createMcpServer = (config, getToken, logger = silentLogger, onUnauthorized, { caches = createServerCaches(config, getToken, onUnauthorized), requestStateCodec, slaRuntime = createSlaRuntime(config), listens, getBackgroundToken, alertPolling = "server", tools = createAllTools(toolEnv(config)), extraInstructions, decorate } = {}) => {
+	const server = createServerShell(config, requestStateCodec, extraInstructions);
 	const sla = createSlaService(slaSettings(config), slaRuntime, caches.resolveUserId);
 	registerToolset(server, {
 		config,
@@ -34104,9 +34671,12 @@ const createMcpServer = (config, getToken, logger = silentLogger, onUnauthorized
 			installAlertSubscriptions(server, config, reader, logger, listens);
 		}
 	}
+	decorate?.(server);
 	return server;
 };
-const defaultServerFactory = ({ config, getToken, logger, onUnauthorized, caches, tools, requestStateCodec, slaRuntime, listens, getBackgroundToken, alertPolling }) => createMcpServer(config, getToken, logger, onUnauthorized, {
+const defaultServerFactory = ({ config, getToken, logger, onUnauthorized, caches, tools, requestStateCodec, slaRuntime, listens, getBackgroundToken, alertPolling, extraInstructions, decorate }) => createMcpServer(config, getToken, logger, onUnauthorized, {
+	extraInstructions,
+	decorate,
 	...caches ? { caches } : {},
 	...tools ? { tools } : {},
 	...slaRuntime ? { slaRuntime } : {},
@@ -34116,7 +34686,7 @@ const defaultServerFactory = ({ config, getToken, logger, onUnauthorized, caches
 	requestStateCodec
 });
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+server@2.3.1/node_modules/@modelcontextprotocol/server/dist/stdio.mjs
+//#region node_modules/.pnpm/@modelcontextprotocol+server@2.4.0/node_modules/@modelcontextprotocol/server/dist/stdio.mjs
 /**
 * Marks a stdout `'error'` listener that a closed transport left attached purely to
 * swallow late write failures (see {@link StdioServerTransport.close}). A fresh
@@ -35146,7 +35716,7 @@ const installShutdown = (options) => {
 //#endregion
 //#region src/index.ts
 const buildStdioTokenStore = async (config, logger) => {
-	const { createTokenStore } = await import("./token-store-BqwB-30K.js");
+	const { createTokenStore } = await import("./token-store-EwRwZiJO.js");
 	return createTokenStore({
 		subdomain: config.subdomain,
 		oauthClientId: config.oauthClientId,
@@ -35196,7 +35766,7 @@ const main = async () => {
 		logger,
 		cleanup: async () => (await starting?.catch(() => void 0))?.close()
 	});
-	const { startHttpTransport } = await import("./http-D-Xy9BWD.js");
+	const { startHttpTransport } = await import("./http-DuRcQrOc.js");
 	starting = startHttpTransport(config, logger);
 	await starting;
 };
@@ -35206,4 +35776,4 @@ main().catch((error) => {
 	process.exit(1);
 });
 //#endregion
-export { STARTUP_DOCS as A, WebStandardStreamableHTTPServerTransport as C, OAuthError as D, verifyBearerToken as E, errnoCode as M, OAuthErrorCode as O, DEFAULT_MAX_REQUEST_BODY_SIZE as S, isLegacyRequest as T, zendeskGet as _, toolEnv as a, DEFAULT_CALLBACK_PORT as b, clearToken as c, resolveTokenPath as d, saveToken as f, createAllTools as g, silentLogger as h, defaultServerFactory as i, createStartupError as j, compareCodeUnits as k, configDir as l, createRequestStateCodec as m, listenedUris as n, watchGrantAlerts as o, signInRequiredError as p, createServerCaches as r, startSlaRuntime as s, createListenFeed as t, loadToken as u, REQUEST_TIMEOUT_MS as v, createMcpHandler as w, getOAuthUrls as x, deadlineSignal as y };
+export { _enum as $, ResourceTemplate as A, stampErrorBrands as B, DEFAULT_CALLBACK_PORT as C, createMcpHandler as D, WebStandardStreamableHTTPServerTransport as E, ProtocolErrorCode as F, ResultSchema as G, PaginatedRequestParamsSchema as H, ResourceNotFoundError as I, toStrictStandardSchema as J, buildInstructions as K, assertValidCacheHint as L, OAuthError as M, OAuthErrorCode as N, isLegacyRequest as O, ProtocolError as P, errnoCode as Q, brandedHasInstance as R, deadlineSignal as S, DEFAULT_MAX_REQUEST_BODY_SIZE as T, PaginatedResultSchema as U, BaseRequestParamsSchema as V, ResourceSchema as W, STARTUP_DOCS as X, compareCodeUnits as Y, createStartupError as Z, createAllTools as _, toolEnv as a, object as at, zendeskGet as b, clearToken as c, union as ct, resolveTokenPath as d, array as et, saveToken as f, silentLogger as g, readPackageInfo as h, defaultServerFactory as i, number$1 as it, verifyBearerToken as j, McpServer as k, configDir as l, unknown as lt, createRequestStateCodec as m, listenedUris as n, literal as nt, watchGrantAlerts as o, record as ot, signInRequiredError as p, Namespace as q, createServerCaches as r, looseObject as rt, startSlaRuntime as s, string as st, createListenFeed as t, boolean as tt, loadToken as u, createTopologyProvider as v, getOAuthUrls as w, REQUEST_TIMEOUT_MS as x, ZendeskApiError as y, isModernProtocolVersion as z };