sunpeak 0.20.64 → 0.20.69

package/dist/mcp/index.cjs

@@ -9,11 +9,8 @@ let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
 let node_zlib = require("node:zlib");
 let zod = require("zod");
-require("http");
-let http2 = require("http2");
-let stream = require("stream");
-let crypto$1 = require("crypto");
-crypto$1 = require_rolldown_runtime.__toESM(crypto$1, 1);
+let node_http2 = require("node:http2");
+let node_stream = require("node:stream");
 let node_crypto = require("node:crypto");
 //#region src/mcp/favicon.ts
 var FAVICON_BASE64 = "iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAOdEVYdFNvZnR3YXJlAEZpZ21hnrGWYwAAA6BJREFUeAHtm09ME0EUxr+lqIDVlMQEI8aAaPRUmwgmeLEcTLxR7ibASY+QqNfSqxfiDU+UhDvlZuKBcpEELpUTBwWCciDRsMGC8Q/W9y0U+29bu922dHZ/yXRndynp++btzLzZeRryCPqA5AigDQKpgBx9aGhSutiQkMoMsBLNvatln94LAX+mG99oUzalRDKF8Py71xuWjykxvgU1oKvjB3zew5Oi7zejBrBhpZGvymF7kReOPaBvRD6mUQVoaNCfxAP/HgLXDwxjea0QFCHxsVVKG96vtyHBIvXqoA0By7G0ABv8rbCJoP+bYfDIw6+mxv4vmzvnEHvnw6vYZamfhY1I3/CrW7Oz9Wl4+PG2cawG8dULmHl7CVEp9tA0TgEWpBZEBVTb8FzoFeOvrxmeUSFxCrCLo86hbHznDzH9bAOh/l3UA3pCZLazkkdDpwApWICtPRf+ICL8Rj0xvGFKvGHJmjdYEoA9eahfx2mCj4O+7yn7e5Y9QBWa4HBcAeBwHC9A0QiE47zPW99hrlI4TBajqACTT7dkPv8FjQznB0ORm6b3TR+B0H294Y0nnK8Um6KbCjD5ZAuqwDjFjIICsOUrDWNPE/QAMy8oKMCwxPGqYeYFeQJ0dfwUtfagGmZekBcL0PUpgopwuS137dENhuBwXAHgcNxgKPOkVqu69YbL62myRoHUmxU4Ae1R30n95BFQaepbikxb3U4QDscVIF0ptXSkEpm2Zg2DAy9uw2m4wRAcjisAHI4bDOVe4NugQM8BVITDX+5ukjwBaPzCyzWoSPewP+9a3iPAUDG+ehGqQbsKTfYK9gGR2StQjRmTrXUFBVDNC9jy0XIEICp5AXeRmWEqAL0gttSORoctX2wLXclYoNFXivSkp+hOdDcYgsNxBYDDcYMhWEClzdKWBDgaWjzGRqp6D5Mc4oYiNywZT+RbnWNyLDtTbO1TC+ZlgtHurV/4zInawPNbWPvcCovotqTMcE9hLb2BcQqn6pkvOa3+KxGgVzxAm4QNcHsdd5hVa5OVjYanGRUBAjJRPsO0OduyRekJY6EdDIpn2JE2x1D2KEK1zXBB2wSWu4/zBu+GZEScQxVg/8CESZY7Pd+Nc7M8IxqrJ5uRWG/ForR2fNVbzTdWo0yhzcgd7p0QVcKoEbmeUdtXc1pEWn/CqGXfYBIlRUh1QU2YST7KlNn0Ba3w3xnZpMNSArCxb6gTnLElpFHnAW9UutKsGdxfpFM6myaou6kAAAAASUVORK5CYII=";
@@ -2751,7 +2748,7 @@ var init_data = require_rolldown_runtime.__esmMin((() => {
 	};
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/utils.js
+//#region ../../node_modules/.pnpm/fast-uri@3.1.4/node_modules/fast-uri/lib/utils.js
 var require_utils = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
 	/** @type {(value: string) => boolean} */
 	var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
@@ -3123,7 +3120,7 @@ var require_utils = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exp
 	};
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/schemes.js
+//#region ../../node_modules/.pnpm/fast-uri@3.1.4/node_modules/fast-uri/lib/schemes.js
 var require_schemes = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
 	var { isUUID } = require_utils();
 	var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
@@ -3306,7 +3303,7 @@ var require_schemes = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((e
 	};
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/index.js
+//#region ../../node_modules/.pnpm/fast-uri@3.1.4/node_modules/fast-uri/index.js
 var require_fast_uri = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
 	var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
 	var { SCHEMES, getSchemeHandler } = require_schemes();
@@ -3445,6 +3442,7 @@ var require_fast_uri = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((
 		return uriTokens.join("");
 	}
 	var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
+	var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
 	/**
 	* @param {import('./types/index').URIComponent} parsed
 	* @param {RegExpMatchArray} matches
@@ -3475,6 +3473,11 @@ var require_fast_uri = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((
 		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 matches = uri.match(URI_PARSE);
 		if (matches) {
 			parsed.scheme = matches[1];
@@ -3503,7 +3506,7 @@ var require_fast_uri = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((
 			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());
+					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;
 				}
@@ -7693,13 +7696,29 @@ var EMPTY_COMPLETION_RESULT = { completion: {
 	hasMore: false
 } };
 //#endregion
-//#region ../../node_modules/.pnpm/@hono+node-server@1.19.14_hono@4.12.27/node_modules/@hono/node-server/dist/index.mjs
+//#region ../../node_modules/.pnpm/@hono+node-server@2.0.11_hono@4.12.27/node_modules/@hono/node-server/dist/index.mjs
 var RequestError = class extends Error {
 	constructor(message, options) {
 		super(message, options);
 		this.name = "RequestError";
 	}
 };
+var reValidRequestUrl = /^\/[!#$&-;=?-\[\]_a-z~]*$/;
+var reDotSegment = /\/\.\.?(?:[/?#]|$)/;
+var reValidHost = /^[a-z0-9._-]+(?::(?:[1-5]\d{3,4}|[6-9]\d{3}))?$/;
+var buildUrl = (scheme, host, incomingUrl) => {
+	const url = `${scheme}://${host}${incomingUrl}`;
+	if (!reValidHost.test(host)) {
+		const urlObj = new URL(url);
+		if (urlObj.hostname.length !== host.length && urlObj.hostname !== (host.includes(":") ? host.replace(/:\d+$/, "") : host).toLowerCase()) throw new RequestError("Invalid host header");
+		return urlObj.href;
+	} else if (incomingUrl.length === 0) return url + "/";
+	else {
+		if (incomingUrl.charCodeAt(0) !== 47) throw new RequestError("Invalid URL");
+		if (!reValidRequestUrl.test(incomingUrl) || reDotSegment.test(incomingUrl)) return new URL(url).href;
+		return url;
+	}
+};
 var toRequestError = (e) => {
 	if (e instanceof RequestError) return e;
 	return new RequestError(e.message, { cause: e });
@@ -7707,21 +7726,73 @@ var toRequestError = (e) => {
 var GlobalRequest = global.Request;
 var Request$1 = class extends GlobalRequest {
 	constructor(input, options) {
-		if (typeof input === "object" && getRequestCache in input) input = input[getRequestCache]();
-		if (typeof options?.body?.getReader !== "undefined") options.duplex ??= "half";
+		if (typeof input === "object" && getRequestCache in input) {
+			const hasReplacementBody = options !== void 0 && "body" in options && options.body != null;
+			if (input[bodyConsumedDirectlyKey] && !hasReplacementBody) throw new TypeError("Cannot construct a Request with a Request object that has already been used.");
+			input = input[getRequestCache]();
+		}
+		if (typeof (options?.body)?.getReader !== "undefined") options.duplex ??= "half";
 		super(input, options);
 	}
 };
 var newHeadersFromIncoming = (incoming) => {
 	const headerRecord = [];
 	const rawHeaders = incoming.rawHeaders;
-	for (let i = 0; i < rawHeaders.length; i += 2) {
-		const { [i]: key, [i + 1]: value } = rawHeaders;
-		if (key.charCodeAt(0) !== 58) headerRecord.push([key, value]);
+	for (let i = 0, len = rawHeaders.length; i < len; i += 2) {
+		const key = rawHeaders[i];
+		if (key.charCodeAt(0) !== 58) headerRecord.push([key, rawHeaders[i + 1]]);
 	}
 	return new Headers(headerRecord);
 };
 var wrapBodyStream = Symbol("wrapBodyStream");
+var byteExactEncodings = /* @__PURE__ */ new Set([
+	"latin1",
+	"binary",
+	"hex",
+	"base64",
+	"base64url"
+]);
+var isByteExactEncoding = (encoding) => encoding === null || byteExactEncodings.has(encoding);
+var bodyBufferedBeforeDisconnectKey = Symbol("bodyBufferedBeforeDisconnect");
+var bodyBufferedLengthBeforeDisconnectKey = Symbol("bodyBufferedLengthBeforeDisconnect");
+var toBufferChunk = (chunk, encoding) => Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding ?? "utf8");
+var isRecoverableDisconnectedIncoming = (incoming) => !(incoming instanceof node_http2.Http2ServerRequest) && !!incoming.complete && !!incoming.readableAborted && typeof incoming.read === "function" && isByteExactEncoding(incoming.readableEncoding);
+var recordBodyBufferedBeforeDisconnect = (incoming) => {
+	if (incoming.readableDidRead || !isRecoverableDisconnectedIncoming(incoming)) return;
+	const incomingWithRecovery = incoming;
+	incomingWithRecovery[bodyBufferedLengthBeforeDisconnectKey] ??= incoming.readableLength;
+};
+var readBodyBufferedBeforeDisconnect = (incoming, chunks) => {
+	if (incoming.readableDidRead && !chunks || !isRecoverableDisconnectedIncoming(incoming)) return;
+	const incomingWithRecovery = incoming;
+	if (incomingWithRecovery[bodyBufferedBeforeDisconnectKey] !== void 0) return incomingWithRecovery[bodyBufferedBeforeDisconnectKey];
+	let result;
+	const errored = incoming.errored;
+	if (errored && errored.code !== "ECONNRESET") result = errored;
+	else if (incomingWithRecovery[bodyBufferedLengthBeforeDisconnectKey] !== void 0 && incoming.readableLength !== incomingWithRecovery[bodyBufferedLengthBeforeDisconnectKey]) result = newBodyUnusableError();
+	else {
+		const bodyChunks = chunks ?? [];
+		const chunk = incoming.read();
+		if (chunk !== null) bodyChunks.push(toBufferChunk(chunk, incoming.readableEncoding));
+		const buffer = bodyChunks.length === 1 ? bodyChunks[0] : Buffer.concat(bodyChunks);
+		result = buffer;
+		const contentLength = incoming.headers["content-length"];
+		if (typeof contentLength === "string" && /^\d+$/.test(contentLength)) {
+			const expectedLength = Number(contentLength);
+			if (Number.isSafeInteger(expectedLength) && buffer.length !== expectedLength) result = newBodyUnusableError();
+		}
+	}
+	incomingWithRecovery[bodyBufferedBeforeDisconnectKey] = result;
+	return result;
+};
+var enqueueBufferedBody = (controller, buffered) => {
+	if (buffered instanceof Error) {
+		controller.error(buffered);
+		return;
+	}
+	if (buffered.length > 0) controller.enqueue(buffered);
+	controller.close();
+};
 var newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
 	const init = {
 		method,
@@ -7744,7 +7815,14 @@ var newRequestFromIncoming = (method, url, headers, incoming, abortController) =
 		let reader;
 		init.body = new ReadableStream({ async pull(controller) {
 			try {
-				reader ||= stream.Readable.toWeb(incoming).getReader();
+				if (!reader) {
+					const buffered = readBodyBufferedBeforeDisconnect(incoming);
+					if (buffered !== void 0) {
+						enqueueBufferedBody(controller, buffered);
+						return;
+					}
+				}
+				reader ||= node_stream.Readable.toWeb(incoming).getReader();
 				const { done, value } = await reader.read();
 				if (done) controller.close();
 				else controller.enqueue(value);
@@ -7752,18 +7830,192 @@ var newRequestFromIncoming = (method, url, headers, incoming, abortController) =
 				controller.error(error);
 			}
 		} });
-	} else init.body = stream.Readable.toWeb(incoming);
+	} else {
+		const buffered = readBodyBufferedBeforeDisconnect(incoming);
+		if (buffered !== void 0) init.body = new ReadableStream({ start(controller) {
+			enqueueBufferedBody(controller, buffered);
+		} });
+		else init.body = node_stream.Readable.toWeb(incoming);
+	}
 	return new Request$1(url, init);
 };
 var getRequestCache = Symbol("getRequestCache");
 var requestCache = Symbol("requestCache");
 var incomingKey = Symbol("incomingKey");
 var urlKey = Symbol("urlKey");
+var methodKey = Symbol("methodKey");
 var headersKey = Symbol("headersKey");
 var abortControllerKey = Symbol("abortControllerKey");
+var getAbortController = Symbol("getAbortController");
+var abortRequest = Symbol("abortRequest");
+var bodyBufferKey = Symbol("bodyBuffer");
+var bodyReadPromiseKey = Symbol("bodyReadPromise");
+var bodyConsumedDirectlyKey = Symbol("bodyConsumedDirectly");
+var bodyLockReaderKey = Symbol("bodyLockReader");
+var abortReasonKey = Symbol("abortReason");
+var newBodyUnusableError = () => {
+	return /* @__PURE__ */ new TypeError("Body is unusable");
+};
+var rejectBodyUnusable = () => {
+	return Promise.reject(newBodyUnusableError());
+};
+var textDecoder = new TextDecoder();
+var consumeBodyDirectOnce = (request) => {
+	if (request[bodyConsumedDirectlyKey]) return rejectBodyUnusable();
+	request[bodyConsumedDirectlyKey] = true;
+};
+var toArrayBuffer = (buf) => {
+	return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+};
+var contentType = (request) => {
+	return (request[headersKey] ||= newHeadersFromIncoming(request[incomingKey])).get("content-type") || "";
+};
+var methodTokenRegExp = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+var normalizeIncomingMethod = (method) => {
+	if (typeof method !== "string" || method.length === 0) return "GET";
+	switch (method) {
+		case "DELETE":
+		case "GET":
+		case "HEAD":
+		case "OPTIONS":
+		case "PATCH":
+		case "POST":
+		case "PUT":
+		case "QUERY": return method;
+	}
+	const upper = method.toUpperCase();
+	switch (upper) {
+		case "DELETE":
+		case "GET":
+		case "HEAD":
+		case "OPTIONS":
+		case "POST":
+		case "PUT": return upper;
+		default: return method;
+	}
+};
+var validateDirectReadMethod = (method) => {
+	if (!methodTokenRegExp.test(method)) return /* @__PURE__ */ new TypeError(`'${method}' is not a valid HTTP method.`);
+	const normalized = method.toUpperCase();
+	if (normalized === "CONNECT" || normalized === "TRACK" || normalized === "TRACE" && method !== "TRACE") return /* @__PURE__ */ new TypeError(`'${method}' HTTP method is unsupported.`);
+};
+var readBodyWithFastPath = (request, method, fromBuffer) => {
+	if (request[bodyConsumedDirectlyKey]) return rejectBodyUnusable();
+	const methodName = request.method;
+	if (methodName === "GET" || methodName === "HEAD") return request[getRequestCache]()[method]();
+	const methodValidationError = validateDirectReadMethod(methodName);
+	if (methodValidationError) return Promise.reject(methodValidationError);
+	if (request[requestCache]) {
+		if (methodName !== "TRACE") return request[requestCache][method]();
+	}
+	const alreadyUsedError = consumeBodyDirectOnce(request);
+	if (alreadyUsedError) return alreadyUsedError;
+	const raw = readRawBodyIfAvailable(request);
+	if (raw) {
+		const result = Promise.resolve(fromBuffer(raw, request));
+		request[bodyBufferKey] = void 0;
+		return result;
+	}
+	return readBodyDirect(request).then((buf) => {
+		const result = fromBuffer(buf, request);
+		request[bodyBufferKey] = void 0;
+		return result;
+	});
+};
+var readRawBodyIfAvailable = (request) => {
+	const incoming = request[incomingKey];
+	if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) return incoming.rawBody;
+};
+var normalizeAbortError = (request, incoming) => {
+	if (incoming.errored) return incoming.errored;
+	const reason = request[abortReasonKey];
+	if (reason !== void 0) return reason instanceof Error ? reason : new Error(String(reason));
+	return /* @__PURE__ */ new Error("Client connection prematurely closed.");
+};
+var readBodyDirect = (request) => {
+	if (request[bodyBufferKey]) return Promise.resolve(request[bodyBufferKey]);
+	if (request[bodyReadPromiseKey]) return request[bodyReadPromiseKey];
+	const incoming = request[incomingKey];
+	if (incoming.readableDidRead) return rejectBodyUnusable();
+	const buffered = readBodyBufferedBeforeDisconnect(incoming);
+	if (buffered !== void 0) {
+		if (buffered instanceof Error) return Promise.reject(buffered);
+		request[bodyBufferKey] = buffered;
+		return Promise.resolve(buffered);
+	}
+	const promise = new Promise((resolve, reject) => {
+		const chunks = [];
+		let settled = false;
+		const finish = (callback) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			callback();
+		};
+		const recoverCompleteBodyAfterDisconnect = (error) => {
+			const streamError = incoming.errored ?? error;
+			if (!isRecoverableDisconnectedIncoming(incoming) || streamError && streamError.code !== "ECONNRESET") return false;
+			finish(() => {
+				const recovered = readBodyBufferedBeforeDisconnect(incoming, chunks);
+				if (recovered instanceof Error) reject(recovered);
+				else if (recovered === void 0) reject(error ?? normalizeAbortError(request, incoming));
+				else {
+					request[bodyBufferKey] = recovered;
+					resolve(recovered);
+				}
+			});
+			return true;
+		};
+		const onData = (chunk) => {
+			chunks.push(toBufferChunk(chunk, incoming.readableEncoding));
+		};
+		const onEnd = () => {
+			finish(() => {
+				const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks);
+				request[bodyBufferKey] = buffer;
+				resolve(buffer);
+			});
+		};
+		const onError = (error) => {
+			if (recoverCompleteBodyAfterDisconnect(error)) return;
+			finish(() => {
+				reject(error);
+			});
+		};
+		const onClose = () => {
+			if (incoming.readableEnded) {
+				onEnd();
+				return;
+			}
+			if (recoverCompleteBodyAfterDisconnect()) return;
+			finish(() => {
+				reject(normalizeAbortError(request, incoming));
+			});
+		};
+		const cleanup = () => {
+			incoming.off("data", onData);
+			incoming.off("end", onEnd);
+			incoming.off("error", onError);
+			incoming.off("close", onClose);
+			request[bodyReadPromiseKey] = void 0;
+		};
+		incoming.on("data", onData);
+		incoming.on("end", onEnd);
+		incoming.on("error", onError);
+		incoming.on("close", onClose);
+		queueMicrotask(() => {
+			if (settled) return;
+			if (incoming.readableEnded) onEnd();
+			else if (incoming.errored) onError(incoming.errored);
+			else if (incoming.destroyed) onClose();
+		});
+	});
+	request[bodyReadPromiseKey] = promise;
+	return promise;
+};
 var requestPrototype = {
 	get method() {
-		return this[incomingKey].method || "GET";
+		return this[methodKey];
 	},
 	get url() {
 		return this[urlKey];
@@ -7771,18 +8023,57 @@ var requestPrototype = {
 	get headers() {
 		return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
 	},
-	[Symbol("getAbortController")]() {
-		this[getRequestCache]();
+	[abortRequest](reason) {
+		if (this[abortReasonKey] === void 0) this[abortReasonKey] = reason;
+		const abortController = this[abortControllerKey];
+		if (abortController && !abortController.signal.aborted) abortController.abort(reason);
+	},
+	[getAbortController]() {
+		this[abortControllerKey] ||= new AbortController();
+		if (this[abortReasonKey] !== void 0 && !this[abortControllerKey].signal.aborted) this[abortControllerKey].abort(this[abortReasonKey]);
 		return this[abortControllerKey];
 	},
 	[getRequestCache]() {
-		this[abortControllerKey] ||= new AbortController();
-		return this[requestCache] ||= newRequestFromIncoming(this.method, this[urlKey], this.headers, this[incomingKey], this[abortControllerKey]);
+		const abortController = this[getAbortController]();
+		if (this[requestCache]) return this[requestCache];
+		const method = this.method;
+		if (this[bodyConsumedDirectlyKey] && !(method === "GET" || method === "HEAD")) {
+			this[bodyBufferKey] = void 0;
+			const init = {
+				method: method === "TRACE" ? "GET" : method,
+				headers: this.headers,
+				signal: abortController.signal
+			};
+			if (method !== "TRACE") {
+				init.body = new ReadableStream({ start(c) {
+					c.close();
+				} });
+				init.duplex = "half";
+			}
+			const req = new Request$1(this[urlKey], init);
+			if (method === "TRACE") Object.defineProperty(req, "method", { get() {
+				return "TRACE";
+			} });
+			return this[requestCache] = req;
+		}
+		return this[requestCache] = newRequestFromIncoming(this.method, this[urlKey], this.headers, this[incomingKey], abortController);
+	},
+	get body() {
+		if (!this[bodyConsumedDirectlyKey]) return this[getRequestCache]().body;
+		const request = this[getRequestCache]();
+		if (!this[bodyLockReaderKey] && request.body) this[bodyLockReaderKey] = request.body.getReader();
+		return request.body;
+	},
+	get bodyUsed() {
+		if (this[bodyConsumedDirectlyKey]) return true;
+		if (this[requestCache]) return this[requestCache].bodyUsed;
+		return false;
 	}
 };
+Object.defineProperty(requestPrototype, "signal", { get() {
+	return this[getAbortController]().signal;
+} });
 [
-	"body",
-	"bodyUsed",
 	"cache",
 	"credentials",
 	"destination",
@@ -7791,25 +8082,37 @@ var requestPrototype = {
 	"redirect",
 	"referrer",
 	"referrerPolicy",
-	"signal",
 	"keepalive"
 ].forEach((k) => {
 	Object.defineProperty(requestPrototype, k, { get() {
 		return this[getRequestCache]()[k];
 	} });
 });
-[
-	"arrayBuffer",
-	"blob",
-	"clone",
-	"formData",
-	"json",
-	"text"
-].forEach((k) => {
+["clone", "formData"].forEach((k) => {
 	Object.defineProperty(requestPrototype, k, { value: function() {
+		if (this[bodyConsumedDirectlyKey]) {
+			if (k === "clone") throw newBodyUnusableError();
+			return rejectBodyUnusable();
+		}
 		return this[getRequestCache]()[k]();
 	} });
 });
+Object.defineProperty(requestPrototype, "text", { value: function() {
+	return readBodyWithFastPath(this, "text", (buf) => textDecoder.decode(buf));
+} });
+Object.defineProperty(requestPrototype, "arrayBuffer", { value: function() {
+	return readBodyWithFastPath(this, "arrayBuffer", (buf) => toArrayBuffer(buf));
+} });
+Object.defineProperty(requestPrototype, "blob", { value: function() {
+	return readBodyWithFastPath(this, "blob", (buf, request) => {
+		const type = contentType(request);
+		return new Response(buf, type ? { headers: { "content-type": type } } : void 0).blob();
+	});
+} });
+Object.defineProperty(requestPrototype, "json", { value: function() {
+	if (this[bodyConsumedDirectlyKey]) return rejectBodyUnusable();
+	return this.text().then(JSON.parse);
+} });
 Object.defineProperty(requestPrototype, Symbol.for("nodejs.util.inspect.custom"), { value: function(depth, options, inspectFn) {
 	return `Request (lightweight) ${inspectFn({
 		method: this.method,
@@ -7825,9 +8128,10 @@ Object.setPrototypeOf(requestPrototype, Request$1.prototype);
 var newRequest = (incoming, defaultHostname) => {
 	const req = Object.create(requestPrototype);
 	req[incomingKey] = incoming;
+	req[methodKey] = normalizeIncomingMethod(incoming.method);
 	const incomingUrl = incoming.url || "";
 	if (incomingUrl[0] !== "/" && (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
-		if (incoming instanceof http2.Http2ServerRequest) throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
+		if (incoming instanceof node_http2.Http2ServerRequest) throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
 		try {
 			req[urlKey] = new URL(incomingUrl).href;
 		} catch (e) {
@@ -7835,33 +8139,43 @@ var newRequest = (incoming, defaultHostname) => {
 		}
 		return req;
 	}
-	const host = (incoming instanceof http2.Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
+	const host = (incoming instanceof node_http2.Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
 	if (!host) throw new RequestError("Missing host header");
 	let scheme;
-	if (incoming instanceof http2.Http2ServerRequest) {
+	if (incoming instanceof node_http2.Http2ServerRequest) {
 		scheme = incoming.scheme;
 		if (!(scheme === "http" || scheme === "https")) throw new RequestError("Unsupported scheme");
 	} else scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
-	const url = new URL(`${scheme}://${host}${incomingUrl}`);
-	if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) throw new RequestError("Invalid host header");
-	req[urlKey] = url.href;
+	try {
+		req[urlKey] = buildUrl(scheme, host, incomingUrl);
+	} catch (e) {
+		if (e instanceof RequestError) throw e;
+		else throw new RequestError("Invalid URL", { cause: e });
+	}
 	return req;
 };
+var defaultContentType = "text/plain; charset=UTF-8";
 var responseCache = Symbol("responseCache");
 var getResponseCache = Symbol("getResponseCache");
 var cacheKey = Symbol("cache");
 var GlobalResponse = global.Response;
-var Response2 = class _Response {
+var Response$1 = class Response$1 {
 	#body;
 	#init;
 	[getResponseCache]() {
+		const cache = this[cacheKey];
+		const liveHeaders = cache && cache[2] instanceof Headers ? cache[2] : void 0;
 		delete this[cacheKey];
-		return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+		return this[responseCache] ||= new GlobalResponse(this.#body, liveHeaders ? {
+			status: this.#init?.status,
+			statusText: this.#init?.statusText,
+			headers: liveHeaders
+		} : this.#init);
 	}
 	constructor(body, init) {
 		let headers;
 		this.#body = body;
-		if (init instanceof _Response) {
+		if (init instanceof Response$1) {
 			const cachedGlobalResponse = init[responseCache];
 			if (cachedGlobalResponse) {
 				this.#init = cachedGlobalResponse;
@@ -7869,19 +8183,19 @@ var Response2 = class _Response {
 				return;
 			} else {
 				this.#init = init.#init;
-				headers = new Headers(init.#init.headers);
+				headers = new Headers(init.headers);
 			}
 		} else this.#init = init;
-		if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) this[cacheKey] = [
+		if (body == null || typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) this[cacheKey] = [
 			init?.status || 200,
-			body,
+			body ?? null,
 			headers || init?.headers
 		];
 	}
 	get headers() {
 		const cache = this[cacheKey];
 		if (cache) {
-			if (!(cache[2] instanceof Headers)) cache[2] = new Headers(cache[2] || { "content-type": "text/plain; charset=UTF-8" });
+			if (!(cache[2] instanceof Headers)) cache[2] = new Headers(cache[2] || (cache[1] === null ? void 0 : { "content-type": defaultContentType }));
 			return cache[2];
 		}
 		return this[getResponseCache]().headers;
@@ -7903,7 +8217,7 @@ var Response2 = class _Response {
 	"type",
 	"url"
 ].forEach((k) => {
-	Object.defineProperty(Response2.prototype, k, { get() {
+	Object.defineProperty(Response$1.prototype, k, { get() {
 		return this[getResponseCache]()[k];
 	} });
 });
@@ -7915,11 +8229,11 @@ var Response2 = class _Response {
 	"json",
 	"text"
 ].forEach((k) => {
-	Object.defineProperty(Response2.prototype, k, { value: function() {
+	Object.defineProperty(Response$1.prototype, k, { value: function() {
 		return this[getResponseCache]()[k]();
 	} });
 });
-Object.defineProperty(Response2.prototype, Symbol.for("nodejs.util.inspect.custom"), { value: function(depth, options, inspectFn) {
+Object.defineProperty(Response$1.prototype, Symbol.for("nodejs.util.inspect.custom"), { value: function(depth, options, inspectFn) {
 	return `Response (lightweight) ${inspectFn({
 		status: this.status,
 		headers: this.headers,
@@ -7930,8 +8244,51 @@ Object.defineProperty(Response2.prototype, Symbol.for("nodejs.util.inspect.custo
 		depth: depth == null ? null : depth - 1
 	})}`;
 } });
-Object.setPrototypeOf(Response2, GlobalResponse);
-Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+Object.setPrototypeOf(Response$1, GlobalResponse);
+Object.setPrototypeOf(Response$1.prototype, GlobalResponse.prototype);
+var validRedirectUrl = /^https?:\/\/[!#-;=?-[\]_a-z~A-Z]+$/;
+var parseRedirectUrl = (url) => {
+	if (url instanceof URL) return url.href;
+	if (validRedirectUrl.test(url)) return url;
+	return new URL(url).href;
+};
+var validRedirectStatuses = /* @__PURE__ */ new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+Object.defineProperty(Response$1, "redirect", {
+	value: function redirect(url, status = 302) {
+		if (!validRedirectStatuses.has(status)) throw new RangeError("Invalid status code");
+		return new Response$1(null, {
+			status,
+			headers: { location: parseRedirectUrl(url) }
+		});
+	},
+	writable: true,
+	configurable: true
+});
+Object.defineProperty(Response$1, "json", {
+	value: function json(data, init) {
+		const body = JSON.stringify(data);
+		if (body === void 0) throw new TypeError("The data is not JSON serializable");
+		const initHeaders = init?.headers;
+		let headers;
+		if (initHeaders) {
+			headers = new Headers(initHeaders);
+			if (!headers.has("content-type")) headers.set("content-type", "application/json");
+		} else headers = { "content-type": "application/json" };
+		return new Response$1(body, {
+			status: init?.status ?? 200,
+			statusText: init?.statusText,
+			headers
+		});
+	},
+	writable: true,
+	configurable: true
+});
 async function readWithoutBlocking(readPromise) {
 	return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
 }
@@ -7962,23 +8319,23 @@ function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromi
 		}
 	}
 }
-function writeFromReadableStream(stream$1, writable) {
-	if (stream$1.locked) throw new TypeError("ReadableStream is locked.");
+function writeFromReadableStream(stream, writable) {
+	if (stream.locked) throw new TypeError("ReadableStream is locked.");
 	else if (writable.destroyed) return;
-	return writeFromReadableStreamDefaultReader(stream$1.getReader(), writable);
+	return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
 }
-var buildOutgoingHttpHeaders = (headers) => {
+var buildOutgoingHttpHeaders = (headers, defaultContentType) => {
 	const res = {};
 	if (!(headers instanceof Headers)) headers = new Headers(headers ?? void 0);
-	const cookies = [];
-	for (const [k, v] of headers) if (k === "set-cookie") cookies.push(v);
-	else res[k] = v;
-	if (cookies.length > 0) res["set-cookie"] = cookies;
-	res["content-type"] ??= "text/plain; charset=UTF-8";
+	if (headers.has("set-cookie")) {
+		const cookies = [];
+		for (const [k, v] of headers) if (k === "set-cookie") cookies.push(v);
+		else res[k] = v;
+		if (cookies.length > 0) res["set-cookie"] = cookies;
+	} else for (const [k, v] of headers) res[k] = v;
+	if (defaultContentType) res["content-type"] ??= defaultContentType;
 	return res;
 };
-var X_ALREADY_SENT = "x-hono-already-sent";
-if (typeof global.crypto === "undefined") global.crypto = crypto$1.default;
 var outgoingEnded = Symbol("outgoingEnded");
 var incomingDraining = Symbol("incomingDraining");
 var DRAIN_TIMEOUT_MS = 500;
@@ -7987,9 +8344,9 @@ var drainIncoming = (incoming) => {
 	const incomingWithDrainState = incoming;
 	if (incoming.destroyed || incomingWithDrainState[incomingDraining]) return;
 	incomingWithDrainState[incomingDraining] = true;
-	if (incoming instanceof http2.Http2ServerRequest) {
+	if (incoming instanceof node_http2.Http2ServerRequest) {
 		try {
-			incoming.stream?.close?.(http2.constants.NGHTTP2_NO_ERROR);
+			incoming.stream?.close?.(node_http2.constants.NGHTTP2_NO_ERROR);
 		} catch {}
 		return;
 	}
@@ -8016,6 +8373,25 @@ var drainIncoming = (incoming) => {
 	incoming.on("error", cleanup);
 	incoming.resume();
 };
+var makeCloseHandler = (req, incoming, outgoing, needsBodyCleanup) => () => {
+	if (incoming.errored) {
+		recordBodyBufferedBeforeDisconnect(incoming);
+		req[abortRequest](incoming.errored.toString());
+	} else if (!outgoing.writableFinished) {
+		recordBodyBufferedBeforeDisconnect(incoming);
+		req[abortRequest]("Client connection prematurely closed.");
+	}
+	if (needsBodyCleanup && !incoming.readableEnded) setTimeout(() => {
+		if (!incoming.readableEnded) setTimeout(() => {
+			drainIncoming(incoming);
+		});
+	});
+};
+var isImmediateCacheableResponse = (res) => {
+	if (!(cacheKey in res)) return false;
+	const body = res[cacheKey][1];
+	return body === null || typeof body === "string" || body instanceof Uint8Array;
+};
 var handleRequestError = () => new Response(null, { status: 400 });
 var handleFetchError = (e) => new Response(null, { status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500 });
 var handleResponseError = (e, outgoing) => {
@@ -8033,15 +8409,44 @@ var flushHeaders = (outgoing) => {
 };
 var responseViaCache = async (res, outgoing) => {
 	let [status, body, header] = res[cacheKey];
+	if (!header) {
+		if (body === null) {
+			outgoing.writeHead(status);
+			outgoing.end();
+		} else if (typeof body === "string") {
+			outgoing.writeHead(status, {
+				"Content-Type": defaultContentType,
+				"Content-Length": Buffer.byteLength(body)
+			});
+			outgoing.end(body);
+		} else if (body instanceof Uint8Array) {
+			outgoing.writeHead(status, {
+				"Content-Type": defaultContentType,
+				"Content-Length": body.byteLength
+			});
+			outgoing.end(body);
+		} else if (body instanceof Blob) {
+			outgoing.writeHead(status, {
+				"Content-Type": defaultContentType,
+				"Content-Length": body.size
+			});
+			outgoing.end(new Uint8Array(await body.arrayBuffer()));
+		} else {
+			outgoing.writeHead(status, { "Content-Type": defaultContentType });
+			flushHeaders(outgoing);
+			await writeFromReadableStream(body, outgoing)?.catch((e) => handleResponseError(e, outgoing));
+		}
+		outgoing[outgoingEnded]?.();
+		return;
+	}
 	let hasContentLength = false;
-	if (!header) header = { "content-type": "text/plain; charset=UTF-8" };
-	else if (header instanceof Headers) {
+	if (header instanceof Headers) {
 		hasContentLength = header.has("content-length");
-		header = buildOutgoingHttpHeaders(header);
+		header = buildOutgoingHttpHeaders(header, body === null ? void 0 : defaultContentType);
 	} else if (Array.isArray(header)) {
 		const headerObj = new Headers(header);
 		hasContentLength = headerObj.has("content-length");
-		header = buildOutgoingHttpHeaders(headerObj);
+		header = buildOutgoingHttpHeaders(headerObj, body === null ? void 0 : defaultContentType);
 	} else for (const key in header) if (key.length === 14 && key.toLowerCase() === "content-length") {
 		hasContentLength = true;
 		break;
@@ -8052,7 +8457,8 @@ var responseViaCache = async (res, outgoing) => {
 		else if (body instanceof Blob) header["Content-Length"] = body.size;
 	}
 	outgoing.writeHead(status, header);
-	if (typeof body === "string" || body instanceof Uint8Array) outgoing.end(body);
+	if (body == null) outgoing.end();
+	else if (typeof body === "string" || body instanceof Uint8Array) outgoing.end(body);
 	else if (body instanceof Blob) outgoing.end(new Uint8Array(await body.arrayBuffer()));
 	else {
 		flushHeaders(outgoing);
@@ -8071,7 +8477,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
 	}
 	else res = await res.catch(handleFetchError);
 	if (cacheKey in res) return responseViaCache(res, outgoing);
-	const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+	const resHeaderRecord = buildOutgoingHttpHeaders(res.headers, res.body === null ? void 0 : defaultContentType);
 	if (res.body) {
 		const reader = res.body.getReader();
 		const values = [];
@@ -8111,7 +8517,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
 			if (values.length === 0) flushHeaders(outgoing);
 			await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
 		}
-	} else if (resHeaderRecord[X_ALREADY_SENT]) {} else {
+	} else if (resHeaderRecord["x-hono-already-sent"]) {} else {
 		outgoing.writeHead(res.status, resHeaderRecord);
 		outgoing.end();
 	}
@@ -8121,47 +8527,45 @@ var getRequestListener = (fetchCallback, options = {}) => {
 	const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
 	if (options.overrideGlobalObjects !== false && global.Request !== Request$1) {
 		Object.defineProperty(global, "Request", { value: Request$1 });
-		Object.defineProperty(global, "Response", { value: Response2 });
+		Object.defineProperty(global, "Response", { value: Response$1 });
 	}
 	return async (incoming, outgoing) => {
 		let res, req;
+		let needsBodyCleanup = false;
+		let closeHandlerAttached = false;
+		const ensureCloseHandler = () => {
+			if (!req || closeHandlerAttached) return;
+			closeHandlerAttached = true;
+			outgoing.on("close", makeCloseHandler(req, incoming, outgoing, needsBodyCleanup));
+		};
 		try {
 			req = newRequest(incoming, options.hostname);
-			let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
-			if (!incomingEnded) {
+			needsBodyCleanup = autoCleanupIncoming && !(incoming.method === "GET" || incoming.method === "HEAD");
+			if (needsBodyCleanup) {
 				incoming[wrapBodyStream] = true;
-				incoming.on("end", () => {
-					incomingEnded = true;
-				});
-				if (incoming instanceof http2.Http2ServerRequest) outgoing[outgoingEnded] = () => {
-					if (!incomingEnded) setTimeout(() => {
-						if (!incomingEnded) setTimeout(() => {
-							drainIncoming(incoming);
+				if (incoming instanceof node_http2.Http2ServerRequest) outgoing[outgoingEnded] = () => {
+					if (!incoming.readableEnded) setTimeout(() => {
+						if (!incoming.readableEnded) setTimeout(() => {
+							incoming.destroy();
+							outgoing.destroy();
 						});
 					});
 				};
-				outgoing.on("finish", () => {
-					if (!incomingEnded) drainIncoming(incoming);
-				});
 			}
-			outgoing.on("close", () => {
-				if (req[abortControllerKey]) {
-					if (incoming.errored) req[abortControllerKey].abort(incoming.errored.toString());
-					else if (!outgoing.writableFinished) req[abortControllerKey].abort("Client connection prematurely closed.");
-				}
-				if (!incomingEnded) setTimeout(() => {
-					if (!incomingEnded) setTimeout(() => {
-						drainIncoming(incoming);
-					});
-				});
-			});
 			res = fetchCallback(req, {
 				incoming,
 				outgoing
 			});
-			if (cacheKey in res) return responseViaCache(res, outgoing);
+			if (!isPromise(res) && isImmediateCacheableResponse(res)) {
+				if (needsBodyCleanup && !incoming.readableEnded) outgoing.once("finish", () => {
+					if (!incoming.readableEnded) drainIncoming(incoming);
+				});
+				return responseViaCache(res, outgoing);
+			}
+			ensureCloseHandler();
 		} catch (e) {
 			if (!res) if (options.errorHandler) {
+				ensureCloseHandler();
 				res = await options.errorHandler(req ? e : toRequestError(e));
 				if (!res) return;
 			} else if (!req) res = handleRequestError();
@@ -8175,6 +8579,8 @@ var getRequestListener = (fetchCallback, options = {}) => {
 		}
 	};
 };
+globalThis.CloseEvent;
+globalThis.ErrorEvent;
 //#endregion
 //#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js
 /**
@@ -8879,16 +9285,18 @@ var StreamableHTTPServerTransport = class {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+ext-apps@1.7.4_@modelcontextprotocol+sdk@1.29.0_zod@4.4.3__react-_bc4d5adeaec14d46b9a46bfff8177b13/node_modules/@modelcontextprotocol/ext-apps/dist/src/server/index.js
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+ext-apps@1.7.4_@modelcontextprotocol+sdk@1.29.0_zod@4.4.3__react-_b5c68214f1621bc5f24903738e19c6a8/node_modules/@modelcontextprotocol/ext-apps/dist/src/server/index.js
 ((Z) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(Z, { get: ($, J) => (typeof require < "u" ? require : $)[J] }) : Z)(function(Z) {
 	if (typeof require < "u") return require.apply(this, arguments);
 	throw Error("Dynamic require of \"" + Z + "\" is not supported");
 });
-var v = require_protocol.union([require_protocol.literal("light"), require_protocol.literal("dark")]).describe("Color theme preference for the host environment."), K = require_protocol.union([
+var v = require_protocol.union([require_protocol.literal("light"), require_protocol.literal("dark")]).describe("Color theme preference for the host environment.");
+var K = require_protocol.union([
 	require_protocol.literal("inline"),
 	require_protocol.literal("fullscreen"),
 	require_protocol.literal("pip")
-]).describe("Display mode for UI presentation."), QQ = require_protocol.union([
+]).describe("Display mode for UI presentation.");
+var QQ = require_protocol.union([
 	require_protocol.literal("--color-background-primary"),
 	require_protocol.literal("--color-background-secondary"),
 	require_protocol.literal("--color-background-tertiary"),
@@ -8965,7 +9373,8 @@ var v = require_protocol.union([require_protocol.literal("light"), require_proto
 	require_protocol.literal("--shadow-sm"),
 	require_protocol.literal("--shadow-md"),
 	require_protocol.literal("--shadow-lg")
-]).describe("CSS variable keys available to MCP apps for theming."), ZQ = require_protocol.record(QQ.describe(`Style variables for theming MCP apps.
+]).describe("CSS variable keys available to MCP apps for theming.");
+var ZQ = require_protocol.record(QQ.describe(`Style variables for theming MCP apps.
 
 Individual style keys are optional - hosts may provide any subset of these values.
 Values are strings containing CSS values (colors, sizes, font stacks, etc.).
@@ -9003,7 +9412,8 @@ var Y = require_protocol.object({
 	resourceDomains: require_protocol.array(require_protocol.string()).optional().describe("Origins for static resources (images, scripts, stylesheets, fonts, media).\n\n- Maps to CSP `img-src`, `script-src`, `style-src`, `font-src`, `media-src` directives\n- Wildcard subdomains supported: `https://*.example.com`\n- Empty or omitted → no network resources (secure default)"),
 	frameDomains: require_protocol.array(require_protocol.string()).optional().describe("Origins for nested iframes.\n\n- Maps to CSP `frame-src` directive\n- Empty or omitted → no nested iframes allowed (`frame-src 'none'`)"),
 	baseUriDomains: require_protocol.array(require_protocol.string()).optional().describe("Allowed base URIs for the document.\n\n- Maps to CSP `base-uri` directive\n- Empty or omitted → only same origin allowed (`base-uri 'self'`)")
-}), j = require_protocol.object({
+});
+var j = require_protocol.object({
 	camera: require_protocol.object({}).optional().describe("Request camera access.\n\nMaps to Permission Policy `camera` feature."),
 	microphone: require_protocol.object({}).optional().describe("Request microphone access.\n\nMaps to Permission Policy `microphone` feature."),
 	geolocation: require_protocol.object({}).optional().describe("Request geolocation access.\n\nMaps to Permission Policy `geolocation` feature."),
@@ -9028,7 +9438,8 @@ require_protocol.object({
 	method: require_protocol.literal("ui/notifications/tool-cancelled"),
 	params: require_protocol.object({ reason: require_protocol.string().optional().describe("Optional reason for the cancellation (e.g., \"user action\", \"timeout\").") })
 });
-var f = require_protocol.object({ fonts: require_protocol.string().optional() }), u = require_protocol.object({
+var f = require_protocol.object({ fonts: require_protocol.string().optional() });
+var u = require_protocol.object({
 	variables: ZQ.optional().describe("CSS variables for theming the app."),
 	css: f.optional().describe("CSS blocks that apps can inject.")
 });
@@ -9063,7 +9474,8 @@ var d = require_protocol.object({
 	updateModelContext: O.optional().describe("Host accepts context updates (ui/update-model-context) to be included in the model's context for future turns."),
 	message: O.optional().describe("Host supports receiving content messages (ui/message) from the view."),
 	sampling: require_protocol.object({ tools: require_protocol.object({}).optional().describe("Host supports tool use via `tools` and `toolChoice` parameters.") }).optional().describe("Host supports LLM sampling (sampling/createMessage) from the view.\nMirrors the MCP `ClientCapabilities.sampling` shape so hosts can pass it through.")
-}), h = require_protocol.object({
+});
+var h = require_protocol.object({
 	experimental: require_protocol.object({}).optional().describe("Experimental features (structure TBD)."),
 	tools: require_protocol.object({ listChanged: require_protocol.boolean().optional().describe("App supports tools/list_changed notifications.") }).optional().describe("App exposes MCP-style tools that the host can call."),
 	availableDisplayModes: require_protocol.array(K).optional().describe("Display modes the app supports.")
@@ -9186,7 +9598,8 @@ require_protocol.object({
 	hostCapabilities: d.describe("Features and capabilities provided by the host."),
 	hostContext: T.describe("Rich context about the host environment.")
 }).passthrough();
-var C = "ui/resourceUri", p = "text/html;profile=mcp-app";
+var C = "ui/resourceUri";
+var p = "text/html;profile=mcp-app";
 function K3(Z, $, J, X) {
 	let V = J._meta, D = V.ui, L = V[C], W = V;
 	if (D?.resourceUri && !L) W = {