shadow-claw 1.54.0 → 1.55.0

package/dist/lib/webmcp-Bf9rT7uu.js

@@ -0,0 +1,2001 @@
+import { n as __exportAll } from "./rolldown-runtime-DwyhSnWe.js";
+import { o as DEFAULT_GROUP_ID } from "./config-Dalol4GN.js";
+import { t as TOOL_DEFINITIONS } from "./tools-tRG7Gu0x.js";
+import "./tools-Bj8UJ_6L.js";
+
+//#region node_modules/@mcp-b/webmcp-polyfill/dist/index.js
+const annotationNames = [
+	"consequentialHint",
+	"debugging",
+	"readOnlyHint",
+	"untrustedContentHint"
+];
+const protocol = "webmcp-polyfill";
+const deadline = 500;
+const NativeDOMException$1 = globalThis.DOMException;
+var FrameBridge = class {
+	#document;
+	#window;
+	#handlers;
+	#knownPeers = /* @__PURE__ */ new Set();
+	#unanswered = /* @__PURE__ */ new Set();
+	#started = Promise.withResolvers();
+	#handshakes = /* @__PURE__ */ new Map();
+	#sessions = /* @__PURE__ */ new Set();
+	#monitor;
+	#hidden = false;
+	constructor(view, handlers) {
+		this.#window = view;
+		this.#document = view.document;
+		this.#handlers = handlers;
+		this.#window.addEventListener("message", (event) => this.#receive(event), true);
+		this.#window.addEventListener("pagehide", () => {
+			this.#hidden = true;
+			for (const session of this.#sessions) session.end();
+		});
+		this.#window.addEventListener("pageshow", (event) => {
+			if (event.persisted) {
+				this.#hidden = false;
+				this.#announce();
+			}
+		});
+		for (const frame of this.#announce()) this.#unanswered.add(frame);
+		if (this.#unanswered.size === 0) this.#started.resolve();
+		else setTimeout(() => {
+			this.#unanswered.clear();
+			this.#started.resolve();
+		}, deadline);
+	}
+	async allowed() {
+		if (this.#hidden) return false;
+		return this.#documentAllowed(this.#document);
+	}
+	async getTools(fromOrigins) {
+		await this.#started.promise;
+		const ownOrigin = this.#window.origin;
+		const origins = [ownOrigin, ...fromOrigins];
+		return (await Promise.all(this.#participants().map(async (peer) => {
+			if (peer === this.#window) return this.#handlers.getTools(ownOrigin).map((metadata) => toRegisteredTool(metadata, this.#window, ownOrigin));
+			try {
+				const reply = await this.#request(peer, origins, { kind: "getTools" });
+				if (!Array.isArray(reply.value)) throw new TypeError("Expected a tool list from the frame");
+				return reply.value.map((value) => toRegisteredTool(readToolMetadata(value), peer, reply.origin));
+			} catch (error) {
+				if (!(error instanceof NativeDOMException$1 && error.name === "UnknownError")) console.warn("WebMCP: could not read tools from a frame.", error);
+				return [];
+			}
+		}))).flat();
+	}
+	async execute(target, expectedOrigin, name, serializedInput, signal) {
+		const reply = await this.#request(target, [expectedOrigin], {
+			kind: "execute",
+			name,
+			input: serializedInput
+		}, signal);
+		if (typeof reply.value !== "string") throw executionError();
+		return reply.value;
+	}
+	async notify(exposedTo) {
+		await this.#started.promise;
+		const origins = [this.#window.origin, ...exposedTo];
+		for (const peer of this.#participants()) {
+			if (peer === this.#window) {
+				await this.#handlers.changed();
+				continue;
+			}
+			try {
+				await this.#request(peer, origins, { kind: "changed" });
+			} catch {}
+		}
+	}
+	#request(target, origins, request, signal) {
+		return new Promise((resolve, reject) => {
+			signal?.throwIfAborted();
+			if (this.#hidden || !this.#related(target)) {
+				reject(executionError());
+				return;
+			}
+			const id = crypto.randomUUID();
+			const { port1, port2 } = new MessageChannel();
+			let peerOrigin;
+			const close = () => {
+				clearTimeout(timer);
+				stopWatching();
+				signal?.removeEventListener("abort", abort);
+				this.#handshakes.delete(id);
+				port1.close();
+			};
+			const fail = (error = executionError()) => {
+				port1.postMessage({ kind: "cancel" });
+				close();
+				reject(error);
+			};
+			const abort = () => fail(signal?.reason);
+			const expire = () => {
+				if (peerOrigin === void 0) this.#forget(target);
+				fail();
+			};
+			const connected = (event) => {
+				if (event.source !== target) return;
+				this.#handshakes.delete(id);
+				if (origins && !origins.includes(event.origin)) {
+					fail();
+					return;
+				}
+				peerOrigin = event.origin;
+				clearTimeout(timer);
+				if (request.kind !== "execute" && request.kind !== "changed") timer = setTimeout(expire, deadline);
+				port1.postMessage(request);
+			};
+			let timer = setTimeout(expire, deadline);
+			const stopWatching = this.#watch(target, fail);
+			port1.onmessage = (event) => {
+				const reply = record(event.data);
+				if (reply?.kind === "error") {
+					fail();
+					return;
+				}
+				if (reply?.kind !== "result" || peerOrigin === void 0) return;
+				close();
+				resolve({
+					value: reply.value,
+					origin: peerOrigin
+				});
+			};
+			port1.onmessageerror = () => fail();
+			signal?.addEventListener("abort", abort, { once: true });
+			this.#handshakes.set(id, connected);
+			try {
+				target.postMessage(`${protocol}:connect:${id}`, "*", [port2]);
+			} catch {
+				port2.close();
+				fail();
+			}
+		});
+	}
+	#receive(event) {
+		const message = readWindowMessage(event.data);
+		if (!message) return;
+		event.stopImmediatePropagation();
+		const source = event.source;
+		if (!event.isTrusted || !source || !isWindow(source) || !this.#related(source) || event.origin === "null" || this.#hidden) return;
+		if (message.kind === "announce") {
+			const isNew = !this.#knownPeers.has(source);
+			this.#learn(source);
+			source.postMessage(`${protocol}:present`, event.origin);
+			if (!isNew || this.#window !== this.#window.top) return;
+			for (const peer of this.#knownPeers) {
+				if (peer === source) continue;
+				peer.postMessage(`${protocol}:refresh`, "*");
+			}
+			return;
+		}
+		if (message.kind === "present") {
+			this.#learn(source);
+			return;
+		}
+		if (message.kind === "refresh") {
+			if (source === this.#window.top) this.#announce();
+			return;
+		}
+		if (message.kind === "ready") {
+			this.#handshakes.get(message.id)?.(event);
+			return;
+		}
+		const [port] = event.ports;
+		if (message.kind !== "connect" || !message.id || !port || event.ports.length !== 1) return;
+		this.#learn(source);
+		this.#accept(source, event.origin, message.id, port);
+	}
+	#accept(source, origin, id, port) {
+		const controller = new AbortController();
+		let requested = false;
+		const close = () => {
+			clearTimeout(timer);
+			stopWatching();
+			port.close();
+		};
+		const cancel = () => {
+			controller.abort();
+			close();
+		};
+		const fail = () => {
+			port.postMessage({ kind: "error" });
+			cancel();
+		};
+		const timer = setTimeout(fail, deadline);
+		const stopWatching = this.#watch(source, fail);
+		port.onmessageerror = fail;
+		port.onmessage = async (event) => {
+			const request = record(event.data);
+			if (request?.kind === "cancel") {
+				cancel();
+				return;
+			}
+			if (requested) return;
+			requested = true;
+			clearTimeout(timer);
+			try {
+				const value = await this.#respond(source, origin, request, controller.signal);
+				port.postMessage({
+					kind: "result",
+					value
+				});
+				close();
+			} catch {
+				fail();
+			}
+		};
+		source.postMessage(`${protocol}:ready:${id}`, origin);
+	}
+	async #respond(source, origin, request, signal) {
+		if (!request || !this.#related(source)) throw executionError();
+		if (request.kind === "permission") {
+			const { childIndex, childOrigin } = request;
+			if (typeof childIndex !== "number" || !Number.isInteger(childIndex) || childIndex < 0 || typeof childOrigin !== "string") throw executionError();
+			return this.#childPermission(childIndex, childOrigin);
+		}
+		if (!await this.allowed() || !await this.#sourceAllowed(source, origin)) throw executionError();
+		if (!this.#related(source)) throw executionError();
+		signal.throwIfAborted();
+		if (request.kind === "getTools") return this.#handlers.getTools(origin);
+		if (request.kind === "execute" && typeof request.name === "string" && typeof request.input === "string") return this.#handlers.execute(origin, request.name, request.input, signal);
+		if (request.kind === "changed") {
+			await this.#handlers.changed();
+			return;
+		}
+		throw executionError();
+	}
+	async #childPermission(childIndex, childOrigin) {
+		const child = this.#window[childIndex];
+		return child !== void 0 && await this.allowed() && childAllowed(this.#document, child, childOrigin);
+	}
+	async #documentAllowed(owner) {
+		const view = activeWindow(owner);
+		if (!view) return false;
+		const policy = readToolsPolicy(owner);
+		if (policy !== void 0) return policy;
+		if (view === view.parent) return true;
+		const parentOrigin = view.location.ancestorOrigins?.[0];
+		const parentDocument = readDocument(view.parent, parentOrigin === void 0 || parentOrigin === view.origin);
+		if (!parentDocument) return this.#parentPermission(view, view.origin);
+		return childAllowed(parentDocument, view, view.origin) && await this.#documentAllowed(parentDocument);
+	}
+	async #sourceAllowed(source, origin) {
+		const sourceDocument = readDocument(source, origin === this.#window.origin);
+		return sourceDocument ? this.#documentAllowed(sourceDocument) : this.#parentPermission(source, origin);
+	}
+	async #parentPermission(child, origin) {
+		const parent = child.parent;
+		if (parent === child) return true;
+		let childIndex = -1;
+		for (let index = 0; index < parent.length; index++) if (parent[index] === child) {
+			childIndex = index;
+			break;
+		}
+		if (childIndex < 0) return false;
+		if (parent === this.#window) return await this.allowed() && childAllowed(this.#document, child, origin);
+		await this.#started.promise;
+		if (!this.#knownPeers.has(parent)) return false;
+		try {
+			const reply = await this.#request(parent, void 0, {
+				kind: "permission",
+				childIndex,
+				childOrigin: origin
+			});
+			return reply.value === true && await this.#sourceAllowed(parent, reply.origin);
+		} catch {
+			return false;
+		}
+	}
+	#related(peer) {
+		try {
+			return !peer.closed && peer !== this.#window && peer.top === this.#window.top;
+		} catch {
+			return false;
+		}
+	}
+	#tree() {
+		if (this.#window.closed) return [];
+		for (const peer of this.#knownPeers) if (!this.#related(peer)) this.#knownPeers.delete(peer);
+		const candidates = [this.#window, ...this.#knownPeers];
+		for (let ancestor = this.#window.parent; ancestor !== ancestor.parent; ancestor = ancestor.parent) candidates.push(ancestor);
+		const tree = /* @__PURE__ */ new Set();
+		const pending = [this.#window.top];
+		while (pending.length) {
+			const frame = pending.pop();
+			if (tree.has(frame)) continue;
+			tree.add(frame);
+			const children = [];
+			for (let index = 0; index < frame.length; index++) {
+				const child = frame[index];
+				if (child) children.push(child);
+			}
+			for (const candidate of candidates) if (candidate !== frame && candidate.parent === frame && !children.includes(candidate)) children.push(candidate);
+			pending.push(...children.reverse());
+		}
+		return Array.from(tree).filter((frame) => frame === this.#window || this.#related(frame));
+	}
+	#participants() {
+		return this.#tree().filter((frame) => frame === this.#window || this.#knownPeers.has(frame));
+	}
+	#announce() {
+		const others = this.#tree().filter((frame) => frame !== this.#window);
+		for (const frame of others) frame.postMessage(`${protocol}:announce`, "*");
+		return others;
+	}
+	#learn(peer) {
+		this.#knownPeers.add(peer);
+		this.#unanswered.delete(peer);
+		if (this.#unanswered.size === 0) this.#started.resolve();
+	}
+	#forget(peer) {
+		this.#knownPeers.delete(peer);
+		if (this.#related(peer)) peer.postMessage(`${protocol}:announce`, "*");
+	}
+	#watch(peer, end) {
+		const session = {
+			peer,
+			end
+		};
+		this.#sessions.add(session);
+		if (this.#monitor === void 0) this.#monitor = this.#window.setInterval(() => {
+			for (const open of this.#sessions) if (!this.#related(open.peer)) open.end();
+		}, 100);
+		return () => {
+			this.#sessions.delete(session);
+			if (this.#sessions.size === 0) {
+				this.#window.clearInterval(this.#monitor);
+				this.#monitor = void 0;
+			}
+		};
+	}
+};
+function childAllowed(owner, child, origin) {
+	const ownerOrigin = owner.defaultView?.origin;
+	const frame = findFrame(owner, child, origin === ownerOrigin);
+	if (!frame) return false;
+	const directive = (frame.getAttribute("allow") ?? "").split(";").map((part) => part.trim().split(/\s+/u)).find(([name]) => name === "tools");
+	if (!directive) return origin === ownerOrigin;
+	const sources = directive.length === 1 ? ["'src'"] : directive.slice(1);
+	if (sources.includes("'none'")) return false;
+	const src = frame.hasAttribute("srcdoc") ? null : frame.getAttribute("src");
+	const srcURL = src ? URL.parse(src, owner.baseURI) : null;
+	const sourceOrigin = !src || srcURL?.protocol === "about:" ? ownerOrigin : srcURL?.origin;
+	return sources.some((source) => source === "*" || source === "'self'" && origin === ownerOrigin || source === "'src'" && origin === sourceOrigin || source === origin);
+}
+function readDocument(view, sameOrigin) {
+	if (!sameOrigin) return;
+	try {
+		return view.document;
+	} catch {
+		return;
+	}
+}
+function findFrame(owner, child, sameOrigin) {
+	if (sameOrigin) try {
+		const frame = child.frameElement;
+		if (frame?.ownerDocument === owner) return frame;
+	} catch {}
+	return searchFrames(owner, child);
+}
+function searchFrames(root, child) {
+	const frames = root.querySelectorAll("iframe, frame");
+	for (const frame of frames) if (frame.contentWindow === child) return frame;
+	for (const element of root.querySelectorAll("*")) {
+		if (!element.shadowRoot) continue;
+		const frame = searchFrames(element.shadowRoot, child);
+		if (frame) return frame;
+	}
+}
+function activeWindow(owner) {
+	const view = owner.defaultView;
+	return view && !view.closed && view.document === owner ? view : void 0;
+}
+function readToolsPolicy(owner) {
+	const source = owner;
+	const policy = record(source.permissionsPolicy ?? source.featurePolicy);
+	if (typeof policy?.features !== "function" || typeof policy.allowsFeature !== "function") return;
+	const features = policy.features();
+	return Array.isArray(features) && features.includes("tools") ? Boolean(policy.allowsFeature("tools")) : void 0;
+}
+function toRegisteredTool(metadata, owner, origin) {
+	const inputSchema = metadata.serializedSchema === void 0 ? void 0 : JSON.parse(metadata.serializedSchema);
+	return {
+		...metadata.annotations !== void 0 && { annotations: { ...metadata.annotations } },
+		description: metadata.description,
+		...inputSchema !== void 0 && { inputSchema },
+		name: metadata.name,
+		origin,
+		title: metadata.title,
+		window: owner
+	};
+}
+function readToolMetadata(value) {
+	const tool = record(value);
+	if (!tool || typeof tool.name !== "string" || typeof tool.title !== "string" || typeof tool.description !== "string" || tool.serializedSchema !== void 0 && typeof tool.serializedSchema !== "string") throw new TypeError("Invalid tool metadata from the frame");
+	const metadata = {
+		name: tool.name,
+		title: tool.title,
+		description: tool.description,
+		annotations: void 0,
+		serializedSchema: tool.serializedSchema
+	};
+	if (tool.annotations === void 0) return metadata;
+	const hints = record(tool.annotations);
+	if (!hints) throw new TypeError("Invalid tool annotations from the frame");
+	const annotations = {};
+	for (const name of annotationNames) {
+		const hint = hints[name];
+		if (hint === void 0) continue;
+		if (typeof hint !== "boolean") throw new TypeError(`Invalid ${name} annotation from the frame`);
+		annotations[name] = hint;
+	}
+	metadata.annotations = annotations;
+	return metadata;
+}
+function readWindowMessage(value) {
+	if (typeof value !== "string") return;
+	const [namespace, kind = "", id = "", extra] = value.split(":");
+	return namespace === protocol && extra === void 0 ? {
+		kind,
+		id
+	} : void 0;
+}
+function record(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return;
+	return value;
+}
+function isWindow(value) {
+	try {
+		return "postMessage" in value && "window" in value;
+	} catch {
+		return false;
+	}
+}
+function executionError() {
+	return new NativeDOMException$1("Tool execution failed", "UnknownError");
+}
+const agentInvokedEvents = /* @__PURE__ */ new WeakSet();
+const agentResponses = /* @__PURE__ */ new WeakMap();
+const activeSubmissions = /* @__PURE__ */ new WeakMap();
+function isAgentInvokedSubmitEvent(event) {
+	return event.isTrusted && (agentInvokedEvents.has(event) || event.eventPhase !== Event.NONE && event.target instanceof HTMLFormElement && activeSubmissions.has(event.target));
+}
+function respondWithAgentSubmitEvent(event, agentResponse) {
+	if (!isAgentInvokedSubmitEvent(event)) throw new DOMException("respondWith() is only available during an agent-invoked submit event", "InvalidStateError");
+	if (!event.defaultPrevented) throw new DOMException("respondWith() requires preventDefault() during an agent-invoked submit event", "InvalidStateError");
+	if (event.eventPhase === Event.NONE) throw new DOMException("respondWith() is only available while the submit event is being dispatched", "InvalidStateError");
+	agentInvokedEvents.add(event);
+	const response = Promise.resolve(agentResponse);
+	agentResponses.set(event, response);
+	if (event.target instanceof HTMLFormElement) activeSubmissions.get(event.target)?.respond(event);
+}
+const TEXT_INPUT_TYPES = /* @__PURE__ */ new Set([
+	"email",
+	"password",
+	"search",
+	"tel",
+	"text",
+	"url"
+]);
+const READONLY_INPUT_TYPES = /* @__PURE__ */ new Set([
+	...TEXT_INPUT_TYPES,
+	"date",
+	"datetime-local",
+	"month",
+	"number",
+	"time",
+	"week"
+]);
+function isControl(element) {
+	return element instanceof HTMLInputElement || element instanceof HTMLSelectElement || element instanceof HTMLTextAreaElement;
+}
+function getFormControls(form) {
+	return Object.getOwnPropertyDescriptor(HTMLFormElement.prototype, "elements")?.get?.call(form);
+}
+function getFormAttribute(form, name) {
+	return Element.prototype.getAttribute.call(form, name);
+}
+function formHasAttribute(form, name) {
+	return Element.prototype.hasAttribute.call(form, name);
+}
+function isConnected(node) {
+	return Object.getOwnPropertyDescriptor(Node.prototype, "isConnected")?.get?.call(node);
+}
+function getOpenShadowRoot(element) {
+	return Object.getOwnPropertyDescriptor(Element.prototype, "shadowRoot")?.get?.call(element);
+}
+function checkFormValidity(form) {
+	return HTMLFormElement.prototype.checkValidity.call(form);
+}
+function requestFormSubmit(form, submitter) {
+	HTMLFormElement.prototype.requestSubmit.call(form, submitter);
+}
+function getControls(form) {
+	return [...getFormControls(form)].filter((element) => isControl(element) && !element.matches(":disabled") && !("readOnly" in element && element.readOnly && (element instanceof HTMLTextAreaElement || READONLY_INPUT_TYPES.has(element.type))));
+}
+function controlGroups(form) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const control of getControls(form)) {
+		const name = control.name.trim();
+		const controls = groups.get(name);
+		if (controls) controls.push(control);
+		else groups.set(name, [control]);
+	}
+	return groups;
+}
+function labelText(control) {
+	return [...control.labels ?? []].map((label) => {
+		const copy = label.cloneNode(true);
+		if (!(copy instanceof HTMLElement)) return "";
+		copy.querySelectorAll("button, input, meter, output, progress, select, textarea").forEach((element) => element.remove());
+		return copy.textContent?.trim() ?? "";
+	}).filter(Boolean).join("; ");
+}
+function commonFieldset(form, controls) {
+	for (let element = controls[0]?.parentElement; element && element !== form; element = element.parentElement) if (element instanceof HTMLFieldSetElement && controls.every((control) => element.contains(control))) return element;
+}
+function parameterDescription(form, controls) {
+	if (controls.length === 1) {
+		const control = controls[0];
+		if (!control) return void 0;
+		return control.getAttribute("toolparamdescription") || labelText(control) || control.getAttribute("aria-description") || void 0;
+	}
+	return commonFieldset(form, controls)?.getAttribute("toolparamdescription") || void 0;
+}
+function withDescription(schema, form, controls, extra) {
+	const description = parameterDescription(form, controls);
+	const combined = description && extra ? `${description} (${extra})` : description || extra;
+	return combined ? {
+		...schema,
+		description: combined
+	} : schema;
+}
+function validNumberAttribute(input, name) {
+	const raw = input.getAttribute(name);
+	if (raw === null || raw.trim() === "") return void 0;
+	const value = Number(raw);
+	return Number.isFinite(value) ? value : void 0;
+}
+function validStep(input, fallback) {
+	const step = Number(input.getAttribute("step"));
+	return Number.isFinite(step) && step > 0 ? step : fallback;
+}
+function isStepBaseMultiple(stepBase, step) {
+	const quotient = stepBase / step;
+	return Math.abs(quotient - Math.round(quotient)) < Number.EPSILON * 16;
+}
+function withPattern(schema, input) {
+	const pattern = input.getAttribute("pattern");
+	if (pattern === null) return schema;
+	try {
+		new RegExp(pattern, "v");
+	} catch {
+		return schema;
+	}
+	return {
+		...schema,
+		pattern
+	};
+}
+function numberSchema(input) {
+	const schema = { type: "number" };
+	const minimum = validNumberAttribute(input, "min");
+	const maximum = validNumberAttribute(input, "max");
+	if (minimum !== void 0) schema.minimum = minimum;
+	if (maximum !== void 0) schema.maximum = maximum;
+	if (input.getAttribute("step") !== "any") {
+		const step = validStep(input, 1);
+		const rawValue = Number(input.getAttribute("value"));
+		if (isStepBaseMultiple(minimum ?? (Number.isFinite(rawValue) ? rawValue : 0), step)) schema.multipleOf = step;
+	}
+	return schema;
+}
+function temporalFormat(input, datePrefix) {
+	const step = validStep(input, 60);
+	if (step < 1) return `${datePrefix}(:[0-5][0-9](\\.[0-9]{1,3})?)?$`;
+	if (step < 60) return `${datePrefix}(:[0-5][0-9])?$`;
+	return `${datePrefix}$`;
+}
+function optionSchemas(options) {
+	return {
+		anyOf: options.map((option) => ({
+			type: "string",
+			const: option.value,
+			title: option.textContent ?? ""
+		})),
+		enum: options.map((option) => option.value)
+	};
+}
+function groupChoiceSchemas(controls) {
+	return {
+		anyOf: controls.map((control) => {
+			const title = labelText(control);
+			const schema = {
+				type: "string",
+				const: control.value
+			};
+			if (title) schema.title = title;
+			return schema;
+		}),
+		enum: controls.map((control) => control.value)
+	};
+}
+function isInput(control, type) {
+	return control instanceof HTMLInputElement && control.type === type;
+}
+function inputSchema(input) {
+	if (TEXT_INPUT_TYPES.has(input.type)) return withPattern({ type: "string" }, input);
+	switch (input.type) {
+		case "hidden": return input.getAttribute("toolparamdescription") ? { type: "string" } : void 0;
+		case "number": return withPattern(numberSchema(input), input);
+		case "range": {
+			const schema = numberSchema(input);
+			schema.minimum ??= 0;
+			schema.maximum ??= 100;
+			return schema;
+		}
+		case "checkbox": return { type: "boolean" };
+		case "date": return {
+			type: "string",
+			format: "date"
+		};
+		case "month": return {
+			type: "string",
+			format: "^[0-9]{4}-(0[1-9]|1[0-2])$"
+		};
+		case "week": return {
+			type: "string",
+			format: "^[0-9]{4}-W(0[1-9]|[1-4][0-9]|5[0-3])$"
+		};
+		case "time": return {
+			type: "string",
+			format: temporalFormat(input, "^([01][0-9]|2[0-3]):[0-5][0-9]")
+		};
+		case "datetime-local": return {
+			type: "string",
+			format: temporalFormat(input, "^[0-9]{4}-(0[1-9]|1[0-2])-[0-9]{2}T([01][0-9]|2[0-3]):[0-5][0-9]")
+		};
+		case "color": return {
+			type: "string",
+			format: "^#[0-9a-zA-Z]{6}$"
+		};
+		default: return;
+	}
+}
+function parameterSchema(form, controls) {
+	const [first] = controls;
+	if (!first) return void 0;
+	let schema;
+	if (controls.every((control) => isInput(control, "radio"))) schema = {
+		type: "string",
+		...groupChoiceSchemas(controls)
+	};
+	else if (controls.length > 1) {
+		if (controls.every((control) => isInput(control, "checkbox"))) schema = {
+			type: "array",
+			items: {
+				type: "string",
+				...groupChoiceSchemas(controls)
+			},
+			uniqueItems: true
+		};
+	} else if (first instanceof HTMLTextAreaElement) schema = { type: "string" };
+	else if (first instanceof HTMLSelectElement) {
+		const choices = optionSchemas([...first.options]);
+		schema = first.multiple ? {
+			type: "array",
+			items: {
+				type: "string",
+				...choices
+			},
+			uniqueItems: true
+		} : {
+			type: "string",
+			...choices
+		};
+	} else schema = inputSchema(first);
+	const dateHint = first.type === "date" ? "Dates MUST be provided in 'YYYY-MM-DD' format." : void 0;
+	return schema && withDescription(schema, form, controls, dateHint);
+}
+function synthesizeSchema(form) {
+	const properties = {};
+	const required = [];
+	for (const [name, controls] of controlGroups(form)) {
+		if (!name) continue;
+		const schema = parameterSchema(form, controls);
+		if (!schema) continue;
+		Object.defineProperty(properties, name, {
+			configurable: true,
+			enumerable: true,
+			value: schema,
+			writable: true
+		});
+		if (controls.some((control) => control.required)) required.push(name);
+	}
+	return {
+		type: "object",
+		properties,
+		required
+	};
+}
+function toolDefinition(form) {
+	return {
+		name: getFormAttribute(form, "toolname") ?? "",
+		title: getFormAttribute(form, "tooltitle") ?? "",
+		description: getFormAttribute(form, "tooldescription") ?? "",
+		inputSchema: synthesizeSchema(form),
+		autosubmit: formHasAttribute(form, "toolautosubmit")
+	};
+}
+function toFormString(value) {
+	if (typeof value === "string" || typeof value === "boolean") return String(value);
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+}
+function toFormBoolean(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "number" && Number.isInteger(value)) return value !== 0;
+	if (typeof value !== "string") return void 0;
+	if (value === "1" || value.toLowerCase() === "true") return true;
+	if (value === "0" || value.toLowerCase() === "false") return false;
+}
+function hasUniqueAllowedValues(value, allowed) {
+	if (!Array.isArray(value)) return false;
+	const remaining = new Set(allowed);
+	for (const item of value) {
+		const string = toFormString(item);
+		if (string === void 0 || !remaining.delete(string)) return false;
+	}
+	return true;
+}
+function inputAcceptsValue(input, value) {
+	if (value === "") return input.type !== "number" && input.type !== "range";
+	const probe = input.ownerDocument.createElement("input");
+	probe.type = input.type;
+	probe.value = value;
+	return probe.value !== "";
+}
+function isFormParameterValue(form, controls, value) {
+	const [first] = controls;
+	if (!first || !parameterSchema(form, controls)) return false;
+	const string = toFormString(value);
+	if (controls.every((control) => isInput(control, "radio"))) return controls.some((control) => control.value === string);
+	if (controls.length > 1) return hasUniqueAllowedValues(value, new Set(controls.map((control) => control.value)));
+	if (first instanceof HTMLSelectElement) {
+		const allowed = new Set([...first.options].map((option) => option.value));
+		if (first.multiple) return hasUniqueAllowedValues(value, allowed);
+		return string !== void 0 && allowed.has(string);
+	}
+	if (first instanceof HTMLTextAreaElement) return string !== void 0;
+	if (first.type === "checkbox") return toFormBoolean(value) !== void 0;
+	return string !== void 0 && inputAcceptsValue(first, string);
+}
+function dispatchInputAndChange(control) {
+	control.dispatchEvent(new Event("input", {
+		bubbles: true,
+		composed: true
+	}));
+	control.dispatchEvent(new Event("change", { bubbles: true }));
+}
+function setValue(control, value) {
+	if (control.value === value) return;
+	const prototype = control instanceof HTMLInputElement ? HTMLInputElement.prototype : HTMLTextAreaElement.prototype;
+	Object.getOwnPropertyDescriptor(prototype, "value")?.set?.call(control, value);
+	dispatchInputAndChange(control);
+}
+function setChecked(control, checked) {
+	if (control.checked === checked) return;
+	Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "checked")?.set?.call(control, checked);
+	dispatchInputAndChange(control);
+}
+function fillParameter(controls, value) {
+	const [first] = controls;
+	const string = toFormString(value);
+	const values = new Set(Array.isArray(value) ? value.map(toFormString) : []);
+	if (controls.every((control) => isInput(control, "radio"))) {
+		const control = controls.find((candidate) => candidate.value === string);
+		if (control) setChecked(control, true);
+	} else if (controls.length > 1) {
+		for (const control of controls) if (control instanceof HTMLInputElement) setChecked(control, values.has(control.value));
+	} else if (first instanceof HTMLSelectElement) {
+		if (first.multiple) {
+			let changed = false;
+			for (const option of first.options) {
+				const next = values.has(option.value);
+				if (option.selected === next) continue;
+				option.selected = next;
+				changed = true;
+			}
+			if (changed) dispatchInputAndChange(first);
+		} else if (string !== void 0 && first.value !== string) {
+			first.value = string;
+			dispatchInputAndChange(first);
+		}
+	} else if (first && isInput(first, "checkbox")) {
+		const checked = toFormBoolean(value);
+		if (checked !== void 0) setChecked(first, checked);
+	} else if (first && string !== void 0) setValue(first, string);
+}
+function fillForm(form, input) {
+	if (Array.isArray(input)) throw executionError();
+	const groups = controlGroups(form);
+	const parameters = [];
+	for (const [name, value] of Object.entries(input)) {
+		const controls = groups.get(name);
+		if (!controls || !isFormParameterValue(form, controls, value)) throw executionError();
+		parameters.push({
+			controls,
+			value
+		});
+	}
+	for (const { controls, value } of parameters) fillParameter(controls, value);
+}
+function findSubmitter(form) {
+	return [...getFormControls(form)].find((element) => !element.matches(":disabled") && (element instanceof HTMLButtonElement && element.type === "submit" || element instanceof HTMLInputElement && ["image", "submit"].includes(element.type)));
+}
+function lifecycleEvent(type, toolName) {
+	const event = new Event(type);
+	Object.defineProperty(event, "toolName", {
+		enumerable: true,
+		value: toolName
+	});
+	return event;
+}
+function waitForSubmission(context, registration, definition, submitter, signal) {
+	const { form } = registration;
+	registration.cancelPending?.(executionError());
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const cleanup = () => {
+			EventTarget.prototype.removeEventListener.call(form, "invalid", onInvalid, true);
+			signal.removeEventListener("abort", onAbort);
+			activeSubmissions.delete(form);
+			if (registration.cancelPending === cancel) delete registration.cancelPending;
+		};
+		const finish = (callback) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			callback();
+		};
+		const cancel = (reason) => finish(() => reject(reason));
+		const settleResponse = (response) => {
+			if (registration.cancelPending === cancel) delete registration.cancelPending;
+			response.then((value) => finish(() => resolve(value ?? null)), (cause) => finish(() => reject(cause)));
+		};
+		const onInvalid = (event) => {
+			if (!event.isTrusted) return;
+			queueMicrotask(() => {
+				if (!checkFormValidity(form)) cancel(executionError());
+			});
+		};
+		const onAbort = () => {
+			finish(() => {
+				context.dispatchEvent(lifecycleEvent("toolcancel", definition.name));
+				reject(signal.reason);
+			});
+		};
+		activeSubmissions.set(form, {
+			complete(event) {
+				setTimeout(() => {
+					const response = agentResponses.get(event);
+					if (response) settleResponse(response);
+					else if (event.defaultPrevented) cancel(executionError());
+					else finish(() => resolve(null));
+				});
+			},
+			direct() {
+				finish(() => resolve(null));
+			},
+			respond(event) {
+				queueMicrotask(() => {
+					const response = agentResponses.get(event);
+					if (response) settleResponse(response);
+				});
+			}
+		});
+		registration.cancelPending = cancel;
+		EventTarget.prototype.addEventListener.call(form, "invalid", onInvalid, true);
+		signal.addEventListener("abort", onAbort, { once: true });
+		if (!definition.autosubmit) {
+			submitter?.focus();
+			context.dispatchEvent(lifecycleEvent("toolactivated", definition.name));
+			return;
+		}
+		try {
+			requestFormSubmit(form, submitter);
+			context.dispatchEvent(lifecycleEvent("toolactivated", definition.name));
+		} catch (error) {
+			cancel(error);
+		}
+	});
+}
+/** Adds declarative tools until the vendored upstream implements them. */
+function installWebMCPDeclarativeExtensions(context) {
+	const prototype = SubmitEvent.prototype;
+	if ("agentInvoked" in prototype && "respondWith" in prototype) return;
+	if (!("agentInvoked" in prototype)) Object.defineProperty(prototype, "agentInvoked", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			return isAgentInvokedSubmitEvent(this);
+		}
+	});
+	if (!("respondWith" in prototype)) Object.defineProperty(prototype, "respondWith", {
+		configurable: true,
+		enumerable: true,
+		writable: true,
+		value(agentResponse) {
+			respondWithAgentSubmitEvent(this, agentResponse);
+		}
+	});
+	const registrations = /* @__PURE__ */ new Map();
+	const blockedDefinitions = /* @__PURE__ */ new Map();
+	const observers = /* @__PURE__ */ new Map();
+	const onSubmit = (event) => {
+		if (!(event instanceof SubmitEvent) || !event.isTrusted || !(event.target instanceof HTMLFormElement)) return;
+		const submission = activeSubmissions.get(event.target);
+		if (!submission) return;
+		agentInvokedEvents.add(event);
+		submission.complete(event);
+	};
+	const onReset = (event) => {
+		if (!event.isTrusted || !(event.target instanceof HTMLFormElement)) return;
+		const form = event.target;
+		setTimeout(() => {
+			if (event.defaultPrevented) return;
+			registrations.get(form)?.cancelPending?.(executionError());
+		});
+	};
+	function stopObservingRoot(root) {
+		observers.get(root)?.disconnect();
+		observers.delete(root);
+		root.removeEventListener("reset", onReset, true);
+		root.removeEventListener("submit", onSubmit, true);
+	}
+	function observeRoot(root) {
+		if (observers.has(root)) return;
+		const observer = new MutationObserver(sync);
+		observers.set(root, observer);
+		observer.observe(root, {
+			attributes: true,
+			characterData: true,
+			childList: true,
+			subtree: true
+		});
+		root.addEventListener("reset", onReset, true);
+		root.addEventListener("submit", onSubmit, true);
+	}
+	function sync() {
+		observeRoot(document);
+		for (const root of observers.keys()) if (root instanceof ShadowRoot && !root.host.isConnected) stopObservingRoot(root);
+		const candidates = /* @__PURE__ */ new Set();
+		const selected = /* @__PURE__ */ new Map();
+		const selectedByName = /* @__PURE__ */ new Map();
+		for (const root of observers.keys()) for (const element of root.querySelectorAll("*")) {
+			const shadowRoot = getOpenShadowRoot(element);
+			if (shadowRoot) observeRoot(shadowRoot);
+			if (!(element instanceof HTMLFormElement) || !formHasAttribute(element, "toolname") || !formHasAttribute(element, "tooldescription") || !isConnected(element)) continue;
+			const form = element;
+			candidates.add(form);
+			const definition = toolDefinition(form);
+			const fingerprint = JSON.stringify(definition);
+			if (blockedDefinitions.get(form) === fingerprint) continue;
+			blockedDefinitions.delete(form);
+			const existingForm = selectedByName.get(definition.name);
+			if (existingForm) {
+				const holdsName = (candidate) => registrations.get(candidate)?.name === definition.name;
+				if (!holdsName(form) || holdsName(existingForm)) {
+					blockedDefinitions.set(form, fingerprint);
+					continue;
+				}
+				const existingSelection = selected.get(existingForm);
+				if (existingSelection) blockedDefinitions.set(existingForm, existingSelection.fingerprint);
+				selected.delete(existingForm);
+			}
+			selectedByName.set(definition.name, form);
+			selected.set(form, {
+				definition,
+				fingerprint
+			});
+		}
+		for (const form of blockedDefinitions.keys()) if (!candidates.has(form)) blockedDefinitions.delete(form);
+		for (const [form, registration] of registrations) if (selected.get(form)?.fingerprint !== registration.fingerprint) {
+			registration.cancelPending?.(executionError());
+			registration.controller.abort();
+			registrations.delete(form);
+		}
+		for (const [form, { definition, fingerprint }] of selected) {
+			if (registrations.has(form)) continue;
+			const controller = new AbortController();
+			const registration = {
+				controller,
+				fingerprint,
+				form,
+				name: definition.name
+			};
+			registrations.set(form, registration);
+			context.registerTool({
+				name: definition.name,
+				title: definition.title,
+				description: definition.description,
+				inputSchema: definition.inputSchema,
+				execute(input, options) {
+					const submitter = findSubmitter(form);
+					if (!definition.autosubmit && !submitter) throw executionError();
+					fillForm(form, input);
+					return waitForSubmission(context, registration, definition, submitter, options.signal);
+				}
+			}, { signal: controller.signal }).catch((cause) => {
+				controller.abort();
+				if (cause instanceof DOMException && cause.name === "AbortError") return;
+				console.error(`[webmcp] declarative form tool "${definition.name}" was not registered:`, cause);
+			});
+		}
+	}
+	const attachShadowDescriptor = Object.getOwnPropertyDescriptor(Element.prototype, "attachShadow");
+	if (attachShadowDescriptor?.configurable) {
+		const nativeAttachShadow = Element.prototype.attachShadow;
+		const attachShadow = function(init) {
+			const root = nativeAttachShadow.call(this, init);
+			if (root.mode === "open" && Object.getOwnPropertyDescriptor(Node.prototype, "ownerDocument")?.get?.call(this) === document && isConnected(this)) observeRoot(root);
+			return root;
+		};
+		Object.defineProperty(Element.prototype, "attachShadow", {
+			...attachShadowDescriptor,
+			value: attachShadow
+		});
+	}
+	const submitDescriptor = Object.getOwnPropertyDescriptor(HTMLFormElement.prototype, "submit");
+	if (submitDescriptor?.configurable) {
+		const nativeSubmit = HTMLFormElement.prototype.submit;
+		const submit = function() {
+			nativeSubmit.call(this);
+			activeSubmissions.get(this)?.direct();
+		};
+		Object.defineProperty(HTMLFormElement.prototype, "submit", {
+			...submitDescriptor,
+			value: submit
+		});
+	}
+	sync();
+}
+/*!
+* Copyright (c) 2026 WebMCP polyfill contributors
+* SPDX-License-Identifier: MIT
+*/
+const NativeDOMException = globalThis.DOMException;
+const getWindow = Object.getOwnPropertyDescriptor(globalThis, "window")?.get;
+const contexts = /* @__PURE__ */ new WeakMap();
+/**
+* Install WebMCP in the current window.
+*
+* Does nothing outside a secure browser context or when `document.modelContext`
+* already exists, including partial native implementations. Call before registering
+* tools in each frame; repeated calls preserve existing contexts and registrations.
+*
+* Installing joins cross-frame discovery: the window listens for the polyfill's messages and
+* announces itself to the other frames of its tree.
+*
+* @throws {TypeError} If the window or Document prototype prevents installation.
+* @example
+* import { installWebMCP } from "webmcp-polyfill";
+* installWebMCP();
+*
+* @see https://webmachinelearning.github.io/webmcp/#document-extension
+* @see https://github.com/webmachinelearning/webmcp-polyfill/blob/main/TESTING.md
+*/
+function installWebMCP$1() {
+	if (typeof document === "undefined" || !globalThis.isSecureContext) return;
+	if ("modelContext" in document) return;
+	const documentPrototype = Document.prototype;
+	const getDefaultView = Object.getOwnPropertyDescriptor(documentPrototype, "defaultView").get;
+	const constructorDescriptor = Object.getOwnPropertyDescriptor(globalThis, "ModelContext");
+	if (!Object.isExtensible(documentPrototype) || constructorDescriptor && !constructorDescriptor.configurable || !constructorDescriptor && !Object.isExtensible(globalThis)) throw new TypeError("Cannot install WebMCP on this realm");
+	Object.defineProperty(globalThis, "ModelContext", {
+		value: modelContextConstructor,
+		configurable: true,
+		writable: true
+	});
+	const { getModelContext } = { getModelContext() {
+		getDefaultView.call(this);
+		let context = contexts.get(this);
+		if (!context) {
+			context = new ModelContextPolyfill(this);
+			contexts.set(this, context);
+		}
+		return context;
+	} };
+	Object.defineProperty(getModelContext, "name", { value: "get modelContext" });
+	Object.defineProperty(documentPrototype, "modelContext", {
+		configurable: true,
+		enumerable: true,
+		get: getModelContext
+	});
+	document.modelContext;
+}
+var ModelContextPolyfill = class extends EventTarget {
+	#document;
+	#tools = /* @__PURE__ */ new Map();
+	#frames;
+	#toolchangeHandler = null;
+	#toolchangeListener = (event) => {
+		const handler = this.#toolchangeHandler;
+		if (typeof handler !== "function") return;
+		if (Reflect.apply(handler, this, [event]) === false) Event.prototype.preventDefault.call(event);
+	};
+	constructor(owner) {
+		super();
+		this.#document = owner;
+		const view = activeWindow(owner);
+		if (!view) return;
+		this.#frames = new FrameBridge(view, {
+			getTools: (callerOrigin) => this.#exposedTools(callerOrigin),
+			execute: (callerOrigin, name, serializedInput, signal) => {
+				const ownerOrigin = requireActiveWindow(owner).origin;
+				return this.#executeLocal(name, serializedInput, ownerOrigin, callerOrigin, signal);
+			},
+			changed: () => this.#queueToolChange()
+		});
+	}
+	get ontoolchange() {
+		return this.#toolchangeHandler;
+	}
+	set ontoolchange(handler) {
+		const nextHandler = isObject(handler) ? handler : null;
+		if (!this.#toolchangeHandler && nextHandler) this.addEventListener("toolchange", this.#toolchangeListener);
+		if (this.#toolchangeHandler && !nextHandler) this.removeEventListener("toolchange", this.#toolchangeListener);
+		this.#toolchangeHandler = nextHandler;
+	}
+	async registerTool(tool, options = {}) {
+		const ownerDocument = this.#document;
+		const { name, title, description, annotations, inputSchema, execute } = readToolDefinition(tool);
+		const settings = readDictionary(options);
+		const exposedTo = readOriginSequence(settings.exposedTo);
+		const registrationSignal = readAbortSignal(settings.signal);
+		requireActiveWindow(ownerDocument);
+		const requireUnusedName = () => {
+			if (this.#tools.has(name)) throw new NativeDOMException(`A tool named ${name} is already registered`, "InvalidStateError");
+		};
+		requireUnusedName();
+		if (!/^[A-Za-z0-9_.-]{1,128}$/u.test(name)) throw new NativeDOMException(`Tool names are 1 to 128 characters of ASCII alphanumerics, "_", "-" or ".": ${name}`, "InvalidStateError");
+		if (!description) throw new NativeDOMException("A tool description cannot be empty", "InvalidStateError");
+		const serializedSchema = inputSchema === void 0 ? void 0 : serializeJSON(inputSchema);
+		registrationSignal?.throwIfAborted();
+		const exposedOrigins = parseOrigins(exposedTo);
+		const storedTool = {
+			metadata: {
+				name,
+				title,
+				description,
+				annotations,
+				serializedSchema
+			},
+			execute,
+			exposedTo: exposedOrigins
+		};
+		const frames = await this.#requireFrames();
+		registrationSignal?.throwIfAborted();
+		requireUnusedName();
+		return new Promise((resolve, reject) => {
+			registrationSignal?.addEventListener("abort", () => {
+				this.#tools.delete(name);
+				frames.notify(exposedOrigins);
+				reject(registrationSignal.reason);
+			}, { once: true });
+			this.#tools.set(name, storedTool);
+			frames.notify(exposedOrigins).then(resolve, reject);
+		});
+	}
+	async getTools(options = {}) {
+		const ownerDocument = this.#document;
+		const fromOrigins = readOriginSequence(readDictionary(options).fromOrigins);
+		requireActiveWindow(ownerDocument);
+		const frames = await this.#requireFrames();
+		const requestedOrigins = parseOrigins(fromOrigins);
+		const tools = await frames.getTools(requestedOrigins);
+		tools.sort((left, right) => {
+			if (left.name === right.name) return 0;
+			return left.name < right.name ? -1 : 1;
+		});
+		return new Promise((resolve) => {
+			queueTask(() => resolve(tools));
+		});
+	}
+	async executeTool(tool, inputObject = {}, options = {}) {
+		const ownerDocument = this.#document;
+		const target = readExecutionTarget(tool);
+		const callerSignal = readAbortSignal(readDictionary(options).signal);
+		requireActiveWindow(ownerDocument);
+		const expectedOrigin = URL.parse(target.origin)?.origin;
+		if (!expectedOrigin || expectedOrigin === "null") throw new NativeDOMException("Invalid or opaque origin", "NotSupportedError");
+		if (!isObject(inputObject)) throw new TypeError("inputObject must be an object");
+		const serializedInput = serializeJSON(inputObject);
+		callerSignal?.throwIfAborted();
+		const frames = await this.#requireFrames();
+		callerSignal?.throwIfAborted();
+		const callerWindow = requireActiveWindow(ownerDocument);
+		if (target.window !== callerWindow) return frames.execute(target.window, expectedOrigin, target.name, serializedInput, callerSignal);
+		return this.#executeLocal(target.name, serializedInput, expectedOrigin, callerWindow.origin, callerSignal);
+	}
+	#executeLocal(name, serializedInput, expectedOrigin, callerOrigin, callerSignal) {
+		return new Promise((resolve, reject) => {
+			callerSignal?.throwIfAborted();
+			const callbackController = new AbortController();
+			let callbackFinished = false;
+			const onCallerAbort = () => {
+				reject(callerSignal.reason);
+				queueTask(() => {
+					if (!callbackFinished) callbackController.abort();
+				});
+			};
+			const rejectExecution = () => {
+				callbackFinished = true;
+				queueTask(() => {
+					callerSignal?.removeEventListener("abort", onCallerAbort);
+					reject(executionError());
+				});
+			};
+			const completeExecution = (value) => {
+				callbackFinished = true;
+				if (callerSignal?.aborted) return;
+				try {
+					const serializedResult = serializeJSON(value);
+					queueTask(() => {
+						callerSignal?.removeEventListener("abort", onCallerAbort);
+						resolve(serializedResult);
+					});
+				} catch {
+					rejectExecution();
+				}
+			};
+			const dispatchTool = () => {
+				if (callerSignal?.aborted) return;
+				try {
+					const ownerWindow = requireActiveWindow(this.#document);
+					const storedTool = this.#tools.get(name);
+					if (!storedTool || expectedOrigin !== ownerWindow.origin || !isExposedTo(storedTool, ownerWindow.origin, callerOrigin)) {
+						rejectExecution();
+						return;
+					}
+					const input = JSON.parse(serializedInput);
+					if (!isObject(input)) {
+						rejectExecution();
+						return;
+					}
+					const execute = storedTool.execute;
+					const callbackResult = execute(input, { signal: callbackController.signal });
+					Promise.resolve(callbackResult).then(completeExecution, rejectExecution);
+				} catch {
+					rejectExecution();
+				}
+			};
+			callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
+			queueTask(dispatchTool);
+		});
+	}
+	async #requireFrames() {
+		const frames = this.#frames;
+		if (!frames || !await frames.allowed()) throw new NativeDOMException("WebMCP is disabled by Permissions Policy", "NotAllowedError");
+		requireActiveWindow(this.#document);
+		return frames;
+	}
+	#exposedTools(callerOrigin) {
+		const ownerOrigin = requireActiveWindow(this.#document).origin;
+		const exposed = [];
+		for (const storedTool of this.#tools.values()) {
+			if (!isExposedTo(storedTool, ownerOrigin, callerOrigin)) continue;
+			exposed.push(storedTool.metadata);
+		}
+		return exposed;
+	}
+	#queueToolChange() {
+		return new Promise((resolve) => {
+			queueTask(() => {
+				this.dispatchEvent(new Event("toolchange"));
+				resolve();
+			});
+		});
+	}
+};
+function isExposedTo(tool, ownerOrigin, callerOrigin) {
+	return ownerOrigin === callerOrigin || tool.exposedTo.includes(callerOrigin);
+}
+const modelContextConstructor = function ModelContext() {
+	throw new TypeError("Illegal constructor");
+};
+Object.defineProperty(modelContextConstructor, "name", { value: "ModelContext" });
+Object.defineProperty(modelContextConstructor, "prototype", {
+	value: ModelContextPolyfill.prototype,
+	writable: false
+});
+Object.setPrototypeOf(modelContextConstructor, EventTarget);
+Object.defineProperties(ModelContextPolyfill.prototype, {
+	constructor: {
+		value: modelContextConstructor,
+		configurable: true,
+		writable: true
+	},
+	[Symbol.toStringTag]: {
+		value: "ModelContext",
+		configurable: true
+	},
+	registerTool: { enumerable: true },
+	getTools: { enumerable: true },
+	executeTool: { enumerable: true },
+	ontoolchange: { enumerable: true }
+});
+function readToolDefinition(value) {
+	const descriptor = readDictionary(value);
+	const annotations = readAnnotations(descriptor.annotations);
+	const description = toDOMString(requireMember(descriptor.description, "description"));
+	const callback = requireMember(descriptor.execute, "execute");
+	if (typeof callback !== "function") throw new TypeError("execute must be a function");
+	const execute = callback;
+	const inputSchema = readInputSchema(descriptor.inputSchema);
+	const name = toDOMString(requireMember(descriptor.name, "name"));
+	const rawTitle = descriptor.title;
+	return {
+		name,
+		title: rawTitle === void 0 ? "" : toUSVString(rawTitle),
+		description,
+		annotations,
+		inputSchema,
+		execute
+	};
+}
+function readExecutionTarget(value) {
+	const descriptor = readDictionary(value);
+	readAnnotations(descriptor.annotations);
+	toDOMString(requireMember(descriptor.description, "description"));
+	readInputSchema(descriptor.inputSchema);
+	const name = toDOMString(requireMember(descriptor.name, "name"));
+	const origin = toUSVString(requireMember(descriptor.origin, "origin"));
+	const title = descriptor.title;
+	if (title !== void 0) toDOMString(title);
+	const targetWindow = requireMember(descriptor.window, "window");
+	if (!isObject(targetWindow)) throw new TypeError("window must be a Window");
+	getWindow.call(targetWindow);
+	return {
+		name,
+		origin,
+		window: targetWindow
+	};
+}
+function readInputSchema(value) {
+	if (value !== void 0 && !isObject(value)) throw new TypeError("inputSchema must be an object");
+	return value;
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null || typeof value === "function";
+}
+function readDictionary(value) {
+	if (value == null) return {};
+	if (!isObject(value)) throw new TypeError("Expected a dictionary");
+	return value;
+}
+function readAnnotations(value) {
+	if (value === void 0) return;
+	const dictionary = readDictionary(value);
+	const annotations = {};
+	for (const name of annotationNames) annotations[name] = Boolean(dictionary[name]);
+	return annotations;
+}
+function toDOMString(value) {
+	if (typeof value === "symbol") throw new TypeError("Cannot convert a Symbol to a string");
+	return String(value);
+}
+function toUSVString(value) {
+	return toDOMString(value).toWellFormed();
+}
+function requireMember(value, name) {
+	if (value === void 0) throw new TypeError(`${name} is required`);
+	return value;
+}
+function serializeJSON(value) {
+	const result = JSON.stringify(value);
+	if (result === void 0) throw new TypeError("Value is not JSON-serializable");
+	return result;
+}
+function readAbortSignal(value) {
+	if (value === void 0) return;
+	return AbortSignal.any([value]);
+}
+function readOriginSequence(value) {
+	if (value === void 0) return [];
+	if (!isObject(value)) throw new TypeError("Origins must be a sequence");
+	const getIterator = readDictionary(value)[Symbol.iterator];
+	if (typeof getIterator !== "function") throw new TypeError("Origins must be a sequence");
+	const iterable = { [Symbol.iterator]() {
+		const iterator = Reflect.apply(getIterator, value, []);
+		if (!isObject(iterator)) throw new TypeError("Iterator must be an object");
+		const next = readDictionary(iterator).next;
+		if (typeof next !== "function") throw new TypeError("Iterator next must be a function");
+		return { next() {
+			return Reflect.apply(next, iterator, []);
+		} };
+	} };
+	return Array.from(iterable, toUSVString);
+}
+function parseOrigins(origins) {
+	return origins.map((value) => {
+		const origin = URL.parse(value)?.origin;
+		if (origin === void 0) throw new NativeDOMException("Invalid origin", "SecurityError");
+		const url = URL.parse(origin);
+		if (!url || !isPotentiallyTrustworthy(url)) throw new NativeDOMException("Origin is not potentially trustworthy", "SecurityError");
+		return origin;
+	});
+}
+function isPotentiallyTrustworthy({ protocol, hostname }) {
+	if (["https:", "wss:"].includes(protocol)) return true;
+	const isLoopback = hostname === "[::1]" || /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(hostname);
+	const isLocalhost = hostname === "localhost" || hostname === "localhost." || hostname.endsWith(".localhost") || hostname.endsWith(".localhost.");
+	return ["http:", "ws:"].includes(protocol) && (isLoopback || isLocalhost);
+}
+function requireActiveWindow(owner) {
+	const view = activeWindow(owner);
+	if (!view) throw new NativeDOMException("The document is not fully active", "InvalidStateError");
+	if (readToolsPolicy(owner) === false) throw new NativeDOMException("WebMCP is disabled by Permissions Policy", "NotAllowedError");
+	return view;
+}
+let taskPort;
+const queuedTasks = [];
+function queueTask(callback) {
+	if (!taskPort) {
+		const channel = new MessageChannel();
+		channel.port1.onmessage = () => queuedTasks.shift()?.();
+		taskPort = channel.port2;
+	}
+	queuedTasks.push(callback);
+	taskPort.postMessage(void 0);
+}
+/**
+* Installs upstream WebMCP and the temporary declarative tools layer.
+* Engines missing an API the vendored core calls are left untouched: upstream defines
+* the document getter before it constructs the context, so a failed construction would
+* leave `document.modelContext` throwing.
+*/
+function installWebMCP() {
+	if (typeof document === "undefined" || !globalThis.isSecureContext) return;
+	if (typeof Promise.withResolvers !== "function" || typeof AbortSignal.any !== "function" || typeof String.prototype.toWellFormed !== "function" || typeof URL.parse !== "function") return;
+	installWebMCP$1();
+	const context = document.modelContext;
+	if (context) installWebMCPDeclarativeExtensions(context);
+}
+
+//#endregion
+//#region src/subsystems/mcp/webmcp.ts
+var webmcp_exports = /* @__PURE__ */ __exportAll({
+	CONSEQUENTIAL_TOOL_NAMES: () => CONSEQUENTIAL_TOOL_NAMES,
+	READ_ONLY_TOOL_NAMES: () => READ_ONLY_TOOL_NAMES,
+	addWebMcpEventListener: () => addWebMcpEventListener,
+	executeWebMcpTool: () => executeWebMcpTool,
+	extractAbortSignal: () => extractAbortSignal,
+	getWebMcpEventTarget: () => getWebMcpEventTarget,
+	getWebMcpMode: () => getWebMcpMode,
+	getWebMcpTools: () => getWebMcpTools,
+	onWebMcpToolActivated: () => onWebMcpToolActivated,
+	onWebMcpToolCancel: () => onWebMcpToolCancel,
+	onWebMcpToolChange: () => onWebMcpToolChange,
+	parseWebMcpInputSchema: () => parseWebMcpInputSchema,
+	registerWebMcpTools: () => registerWebMcpTools,
+	resolveWebMcpToolAnnotations: () => resolveWebMcpToolAnnotations,
+	setWebMcpMode: () => setWebMcpMode,
+	unregisterWebMcpTools: () => unregisterWebMcpTools
+});
+const registeredToolControllers = /* @__PURE__ */ new Map();
+const registeredToolNames = /* @__PURE__ */ new Set();
+let currentMode = "polyfill";
+/**
+* Set the WebMCP mode (polyfill vs native).
+*
+* - `"polyfill"` (default): Uses `@mcp-b/webmcp-polyfill` for a pure-JS
+*   `document.modelContext` that works in all browsers.
+* - `"native"`: Uses Chrome's native `document.modelContext` from
+*   `chrome://flags/#enable-webmcp-testing`.  Requires the flag to be
+*   enabled.  May crash in early Canary builds.
+*
+* Detection follows Chrome's recommended compat pattern:
+*   `document.modelContext || navigator.modelContext`
+* `navigator.modelContext` was deprecated in Chrome 150 and removed in
+* Chrome 152.0.7943.0, but the fallback keeps older clients working.
+*/
+function setWebMcpMode(mode) {
+	currentMode = mode;
+}
+function getWebMcpMode() {
+	return currentMode;
+}
+/**
+* Install the `@mcp-b/webmcp-polyfill` onto `document.modelContext`.
+*
+* In `@mcp-b/webmcp-polyfill` 6.0.0+, the entry point is `installWebMCP()`
+* (previously `initializeWebMCPPolyfill()` in v5).
+* The polyfill itself bails out when Chrome's native `document.modelContext`
+* is already present — it does NOT override the native API. We call it
+* unconditionally; if the polyfill is already installed it returns quickly.
+*/
+function ensurePolyfill() {
+	try {
+		if (typeof globalThis !== "undefined" && typeof globalThis.isSecureContext === "undefined" && typeof location !== "undefined" && (location.protocol === "https:" || location.hostname === "localhost" || location.hostname === "127.0.0.1")) try {
+			Object.defineProperty(globalThis, "isSecureContext", {
+				value: true,
+				configurable: true
+			});
+		} catch {}
+		if (typeof installWebMCP === "function") installWebMCP();
+	} catch (err) {
+		console.warn("WebMCP polyfill initialization failed:", err);
+	}
+}
+/**
+* Returns true when the `@mcp-b/webmcp-polyfill` v5.1.0+ security gate will
+* allow `registerTool()` to proceed.
+*
+* The polyfill's `validateOriginAgentCluster()` throws `DOMException("",
+* "SecurityError")` when `globalThis.originAgentCluster === false` (and the
+* protocol is not `file:`). Chrome automatically origin-isolates HTTPS pages so
+* this is never an issue there. Firefox ≥ 138 exposes `originAgentCluster` but
+* returns `false` unless the server sends `Origin-Agent-Cluster: ?1` — a
+* header that GitHub Pages does not set. This check lets us detect Firefox
+* (and any other browser with the same behaviour) early and skip registration
+* with a single descriptive warning instead of N per-tool `DOMException`s.
+*
+* Native mode bypasses the polyfill entirely and is unaffected.
+*/
+function isOriginAgentClusterCompatible() {
+	if (typeof globalThis.originAgentCluster === "undefined") return true;
+	if (globalThis.location?.protocol === "file:") return true;
+	return globalThis.originAgentCluster !== false;
+}
+/**
+* Access the WebMCP ModelContext API.
+*
+* In polyfill mode: installs the `@mcp-b/webmcp-polyfill` which surfaces
+* `document.modelContext`.
+* In native mode: follows Chrome's recommended feature-detection pattern:
+*   `document.modelContext || navigator.modelContext`
+* `navigator.modelContext` was deprecated in Chrome 150 and removed in
+* Chrome 152.0.7943.0, but the fallback preserves compatibility with
+* earlier builds that may still be in the wild.
+*/
+function getModelContextApi() {
+	if (typeof document === "undefined" && typeof navigator === "undefined") return null;
+	if (currentMode === "polyfill") ensurePolyfill();
+	try {
+		const modelContext = typeof document !== "undefined" && typeof document.modelContext !== "undefined" ? Reflect.get(document, "modelContext") : typeof navigator !== "undefined" && typeof navigator.modelContext !== "undefined" ? Reflect.get(navigator, "modelContext") : void 0;
+		if (!modelContext || typeof modelContext !== "object") return null;
+		const api = modelContext;
+		if (typeof api.registerTool !== "function") return null;
+		return api;
+	} catch (err) {
+		console.warn("WebMCP modelContext access failed:", err);
+		return null;
+	}
+}
+/**
+* Safely parse or normalize WebMCP input schema.
+*
+* Starting in Chrome 154.0.8014.0 (PR #241), `RegisteredTool#inputSchema` returns
+* a JavaScript object (a deep copy of the schema provided at registration).
+* In Chrome < 154.0.8014.0, `RegisteredTool#inputSchema` returned a stringified JSON schema (DOMString).
+*
+* This function provides backwards-compatible schema parsing:
+* - If inputSchema is a string: attempts JSON.parse.
+* - If inputSchema is an object: returns the object.
+* - Fallbacks gracefully to an empty object schema if null, undefined, or invalid JSON.
+*/
+function parseWebMcpInputSchema(inputSchema) {
+	if (typeof inputSchema === "string") {
+		try {
+			const parsed = JSON.parse(inputSchema);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+		} catch {}
+		return {
+			type: "object",
+			properties: {}
+		};
+	}
+	if (inputSchema && typeof inputSchema === "object" && !Array.isArray(inputSchema)) return inputSchema;
+	return {
+		type: "object",
+		properties: {}
+	};
+}
+/**
+* Safely extract AbortSignal from execute options/context.
+* Supports Chrome 153+ options object `{ signal }` (PR #247), direct AbortSignal instances,
+* or undefined for backward compatibility with Chrome < 153 and legacy callers.
+*/
+function extractAbortSignal(context) {
+	if (!context) return;
+	if (typeof AbortSignal !== "undefined" && context instanceof AbortSignal) return context;
+	if (typeof context === "object" && "signal" in context && typeof AbortSignal !== "undefined" && context.signal instanceof AbortSignal) return context.signal;
+}
+/**
+* Retrieve tools registered on the WebMCP ModelContext API.
+*
+* Practicing graceful degradation:
+* - Feature-detects `getTools()` on `document.modelContext` / `navigator.modelContext`.
+* - If `getTools()` is absent (older browser builds or polyfills without getTools),
+*   returns an empty array `[]` without throwing.
+* - Supports options dictionary with `fromOrigins` to discover cross-frame/cross-origin tools (Chrome 155+).
+* - Normalizes `RegisteredTool#inputSchema` so caller receives a JavaScript object
+*   whether running on Chrome 154+ (native object) or Chrome < 154 (DOMString JSON).
+*/
+async function getWebMcpTools(options) {
+	const modelContext = getModelContextApi();
+	if (!modelContext || typeof modelContext.getTools !== "function") return [];
+	try {
+		const rawTools = await modelContext.getTools(options);
+		if (!Array.isArray(rawTools)) return [];
+		return rawTools.map((tool) => ({
+			name: tool.name,
+			...tool.title ? { title: tool.title } : {},
+			...tool.description ? { description: tool.description } : {},
+			inputSchema: parseWebMcpInputSchema(tool.inputSchema),
+			...tool.annotations ? { annotations: tool.annotations } : {},
+			...tool.execute ? { execute: tool.execute } : {}
+		}));
+	} catch (err) {
+		console.warn("Failed to retrieve WebMCP tools via getTools():", err);
+		return [];
+	}
+}
+/**
+* Gracefully execute a WebMCP tool on a ModelContext instance with backwards compatibility.
+*
+* Starting in Chrome 155.0.8052.0 (PR #246, PR #251), `document.modelContext.executeTool()`
+* accepts an optional JavaScript object directly instead of a JSON DOMString.
+* In Chrome < 155 and earlier polyfills, `executeTool()` required a stringified JSON arguments string.
+*
+* This function practices graceful degradation:
+* 1. Prepares both an `inputObject` (for Chrome 155+) and an `inputStr` (for Chrome < 155 & polyfills).
+* 2. Attempts to execute `executeTool(tool, inputObject, options)` first.
+* 3. Catches errors starting with "Failed to parse input" (or TypeErrors from WebIDL DOMString checks)
+*    and retries transparently with `JSON.stringify(inputObject)`.
+* 4. Re-throws any unrelated execution errors.
+*/
+async function executeWebMcpTool(modelContext, tool, input, options) {
+	if (!modelContext || typeof modelContext.executeTool !== "function") throw new Error("ModelContext executeTool is not available");
+	let inputObject;
+	let inputStr;
+	if (typeof input === "string") {
+		inputStr = input;
+		try {
+			const parsed = JSON.parse(input);
+			inputObject = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+		} catch {
+			inputObject = {};
+		}
+	} else if (input && typeof input === "object" && !Array.isArray(input)) {
+		inputObject = input;
+		try {
+			inputStr = JSON.stringify(input);
+		} catch {
+			inputStr = "{}";
+		}
+	} else {
+		inputObject = {};
+		inputStr = "{}";
+	}
+	try {
+		return await modelContext.executeTool(tool, inputObject, options);
+	} catch (err) {
+		const isParseError = typeof err?.message === "string" && err.message.startsWith("Failed to parse input");
+		const isTypeError = err instanceof TypeError;
+		if (isParseError || isTypeError) return await modelContext.executeTool(tool, inputStr, options);
+		throw err;
+	}
+}
+/**
+* Resolves the appropriate EventTarget for WebMCP lifecycle events
+* (`toolactivated` and `toolcancel`) with backwards compatibility.
+*
+* Starting in Chrome 156.0.8076.0 (PR #245), `ontoolactivated` and `ontoolcancel`
+* event handler properties and lifecycle events moved from `window` to `document.modelContext`.
+* In Chrome < 156, these events were fired on `window`.
+*
+* This function practices robust feature detection and graceful degradation:
+* 1. Safely checks for existence of `document` and `window` to avoid ReferenceErrors
+*    in non-DOM / headless / Node.js environments.
+* 2. Checks if `on${type}` is present in `document.modelContext` (or `navigator.modelContext`).
+*    If present and it supports `addEventListener`, `modelContext` is returned.
+* 3. Checks if `on${type}` is present in `window`. If present and `window` supports
+*    `addEventListener`, `window` is returned (legacy Chrome < 156 path).
+* 4. Fallback: If neither has `on${type}` (e.g. polyfill, synthetic mock, or uninitialized prototype),
+*    prefers `modelContext` if it supports `addEventListener`, otherwise falls back to `window`.
+* 5. Returns `null` if no valid EventTarget is found.
+*/
+function getWebMcpEventTarget(type) {
+	const doc = typeof document !== "undefined" ? document : void 0;
+	const win = typeof window !== "undefined" ? window : void 0;
+	const nav = typeof navigator !== "undefined" ? navigator : void 0;
+	const modelContext = doc?.modelContext ?? nav?.modelContext;
+	const hasModelContextListener = modelContext && typeof modelContext.addEventListener === "function";
+	const hasWindowListener = win && typeof win.addEventListener === "function";
+	if (type) {
+		const handlerKey = `on${type}`;
+		if (modelContext && handlerKey in modelContext && hasModelContextListener) return modelContext;
+		if (win && handlerKey in win && hasWindowListener) return win;
+	}
+	if (hasModelContextListener) return modelContext;
+	if (hasWindowListener) return win;
+	return null;
+}
+/**
+* Safely registers a listener for WebMCP lifecycle events (`toolactivated`, `toolcancel`)
+* with graceful degradation, event payload normalization, and automatic unsubscription.
+*
+* Returns an idempotent unsubscribe cleanup function.
+*/
+function addWebMcpEventListener(type, listener, options) {
+	const target = getWebMcpEventTarget(type);
+	const opts = typeof options === "object" ? options : void 0;
+	const listenBoth = opts?.listenBoth ?? false;
+	const win = typeof window !== "undefined" && typeof window.addEventListener === "function" ? window : null;
+	const doc = typeof document !== "undefined" ? document : null;
+	const nav = typeof navigator !== "undefined" ? navigator : null;
+	const modelContext = doc?.modelContext ?? nav?.modelContext;
+	const hasMc = modelContext && typeof modelContext.addEventListener === "function";
+	const secondaryTarget = listenBoth ? target === modelContext ? win !== target ? win : null : hasMc ? modelContext : null : null;
+	if (!target && !secondaryTarget) return () => {};
+	let recentToolNames = null;
+	let clearTimer = null;
+	const wrapHandler = (evt) => {
+		let toolName = evt.toolName;
+		if (typeof toolName !== "string" && "detail" in evt && typeof evt.detail === "object") toolName = evt.detail?.toolName;
+		if (typeof toolName !== "string") toolName = "";
+		if (!("toolName" in evt) || evt.toolName !== toolName) try {
+			Object.defineProperty(evt, "toolName", {
+				value: toolName,
+				configurable: true,
+				enumerable: true
+			});
+		} catch {}
+		if (listenBoth && toolName) {
+			if (!recentToolNames) recentToolNames = /* @__PURE__ */ new Set();
+			if (recentToolNames.has(toolName)) return;
+			recentToolNames.add(toolName);
+			if (!clearTimer) clearTimer = setTimeout(() => {
+				recentToolNames?.clear();
+				clearTimer = null;
+			}, 100);
+		}
+		listener(evt);
+	};
+	if (target) target.addEventListener(type, wrapHandler, options);
+	if (secondaryTarget) secondaryTarget.addEventListener(type, wrapHandler, options);
+	let unsubscribed = false;
+	const unsubscribe = () => {
+		if (unsubscribed) return;
+		unsubscribed = true;
+		if (clearTimer) {
+			clearTimeout(clearTimer);
+			clearTimer = null;
+		}
+		if (target) target.removeEventListener(type, wrapHandler, options);
+		if (secondaryTarget) secondaryTarget.removeEventListener(type, wrapHandler, options);
+	};
+	if (opts?.signal) {
+		if (opts.signal.aborted) {
+			unsubscribe();
+			return () => {};
+		}
+		opts.signal.addEventListener("abort", () => unsubscribe(), { once: true });
+	}
+	return unsubscribe;
+}
+/**
+* Convenience helper to subscribe to tool execution start events (`toolactivated`).
+* Returns an unsubscribe cleanup function.
+*/
+function onWebMcpToolActivated(listener, options) {
+	return addWebMcpEventListener("toolactivated", listener, options);
+}
+/**
+* Convenience helper to subscribe to tool execution cancel events (`toolcancel`).
+* Returns an unsubscribe cleanup function.
+*/
+function onWebMcpToolCancel(listener, options) {
+	return addWebMcpEventListener("toolcancel", listener, options);
+}
+/**
+* Convenience helper to subscribe to tool registration change events (`toolchange`).
+* Dispatched on `document.modelContext` when tools are registered or unregistered.
+* Returns an unsubscribe cleanup function.
+*/
+function onWebMcpToolChange(listener, options) {
+	const doc = typeof document !== "undefined" ? document : void 0;
+	const nav = typeof navigator !== "undefined" ? navigator : void 0;
+	const modelContext = doc?.modelContext ?? nav?.modelContext;
+	if (!modelContext || typeof modelContext.addEventListener !== "function") return () => {};
+	modelContext.addEventListener("toolchange", listener, options);
+	return () => {
+		try {
+			modelContext.removeEventListener("toolchange", listener, options);
+		} catch {}
+	};
+}
+/**
+* Consequential tools that perform high-stakes, irreversible, or external real-world actions
+* (such as deleting data, executing arbitrary system commands, or transmitting live communications).
+* Signals consuming agents to require explicit user confirmation prior to execution (Chrome 154.0.8017.0+).
+*/
+const CONSEQUENTIAL_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"bash",
+	"clear_chat",
+	"delete_file",
+	"delete_task",
+	"email_send_message",
+	"git_delete_branch",
+	"git_delete_repo",
+	"git_push",
+	"git_reset"
+]);
+/**
+* Read-only tools that query information without mutating state.
+*/
+const READ_ONLY_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"ask_user",
+	"detect_language",
+	"diff_files",
+	"email_read_messages",
+	"fetch_url",
+	"get_current_time",
+	"git_branches",
+	"git_diff",
+	"git_list_repos",
+	"git_log",
+	"git_read_file_at_ref",
+	"git_show",
+	"git_status",
+	"list_components",
+	"list_files",
+	"list_room_members",
+	"list_tasks",
+	"list_tool_profiles",
+	"proofread_text",
+	"read_file",
+	"remote_mcp_list_tools",
+	"rewrite_text",
+	"search_files",
+	"summarize_text",
+	"translate_text",
+	"web_search",
+	"write_text"
+]);
+/**
+* Resolve annotations for a WebMCP tool registration.
+* Allows custom annotations (from declarative or customized tool definitions)
+* to override defaults.
+*/
+function resolveWebMcpToolAnnotations(toolName, customAnnotations) {
+	const isConsequential = CONSEQUENTIAL_TOOL_NAMES.has(toolName);
+	return {
+		readOnlyHint: !isConsequential && READ_ONLY_TOOL_NAMES.has(toolName),
+		consequentialHint: isConsequential,
+		untrustedContentHint: true,
+		...typeof customAnnotations?.debugging === "boolean" ? { debugging: customAnnotations.debugging } : {},
+		...customAnnotations || {}
+	};
+}
+/**
+* Register ShadowClaw tools with the WebMCP ModelContext API.
+*
+* Both the `@mcp-b/webmcp-polyfill` and Chrome's native API support
+* `registerTool(tool, { signal })`. We always use AbortController signals so
+* that unregistration works identically regardless of which implementation is
+* actually active.
+*
+* Key correctness detail: `ensurePolyfill()` is a no-op when
+* Chrome's native `document.modelContext` already exists — it does NOT
+* override the native API. In that situation we are talking to the native
+* Chrome API even in "polyfill" mode. The native Chrome API only supports
+* signal-based unregistration, so using AbortController signals everywhere
+* prevents "Duplicate tool name" errors when tools are re-configured.
+*/
+async function registerWebMcpTools(agentWorker, _emit, groupId = DEFAULT_GROUP_ID, tools) {
+	const activeTools = Array.isArray(tools) ? tools : TOOL_DEFINITIONS;
+	if (activeTools.length === 0) return true;
+	if (currentMode === "polyfill" && !isOriginAgentClusterCompatible()) {
+		console.warn("WebMCP polyfill registration skipped: this browser reports originAgentCluster = false. The @mcp-b/webmcp-polyfill v5.1.0+ requires an origin-keyed agent cluster (Chrome enforces this automatically for HTTPS; Firefox requires the server to send Origin-Agent-Cluster: ?1). WebMCP tools are unavailable in this browser session.");
+		return false;
+	}
+	const modelContext = getModelContextApi();
+	if (!modelContext) return false;
+	for (const def of activeTools) {
+		if (registeredToolNames.has(def.name)) continue;
+		const controller = new AbortController();
+		registeredToolControllers.set(def.name, controller);
+		registeredToolNames.add(def.name);
+		try {
+			const toolDef = {
+				name: def.name,
+				title: def.title || def.name,
+				description: def.description,
+				inputSchema: parseWebMcpInputSchema(def.input_schema),
+				annotations: resolveWebMcpToolAnnotations(def.name, def.annotations),
+				execute: (input, context) => {
+					if (!agentWorker) throw new Error("Cannot execute tool: agent worker is not ready");
+					const signal = extractAbortSignal(context);
+					if (signal?.aborted) return Promise.reject(/* @__PURE__ */ new Error("Tool execution aborted"));
+					return new Promise((resolve, reject) => {
+						const callId = Date.now().toString(36) + Math.random().toString(36).slice(2);
+						let timeout = null;
+						const cleanup = () => {
+							if (timeout !== null) {
+								clearTimeout(timeout);
+								timeout = null;
+							}
+							agentWorker?.removeEventListener("message", handler);
+							if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+						};
+						const onAbort = () => {
+							cleanup();
+							reject(/* @__PURE__ */ new Error("Tool execution aborted"));
+						};
+						if (signal) signal.addEventListener("abort", onAbort, { once: true });
+						timeout = setTimeout(() => {
+							cleanup();
+							reject(/* @__PURE__ */ new Error("Timeout waiting for tool execution"));
+						}, 6e5);
+						const handler = (event) => {
+							const data = event.data;
+							if (data && data.type === "execute-tool-result" && data.callId === callId) {
+								cleanup();
+								if (data.error) reject(new Error(data.error));
+								else resolve(data.result);
+							}
+						};
+						agentWorker.addEventListener("message", handler);
+						agentWorker.postMessage({
+							type: "execute-tool",
+							callId,
+							payload: {
+								name: def.name,
+								input: input || {},
+								groupId
+							}
+						});
+					});
+				}
+			};
+			await modelContext.registerTool(toolDef, { signal: controller.signal });
+			await new Promise((resolve) => setTimeout(resolve, 0));
+		} catch (err) {
+			registeredToolControllers.delete(def.name);
+			registeredToolNames.delete(def.name);
+			if (err instanceof Error && (err.message.includes("already registered") || err.message.includes("Duplicate tool name"))) continue;
+			if (err instanceof DOMException && err.name === "SecurityError") {
+				console.warn("WebMCP tool registration aborted: browser security policy (SecurityError) prevented registration. Remaining tools will not be registered for this session.", err);
+				return false;
+			}
+			console.error(`Failed to register tool ${def.name}:`, err);
+			throw err;
+		}
+	}
+	return true;
+}
+/**
+* Unregister previously registered ShadowClaw WebMCP tools.
+*
+* Aborts every AbortController associated with a registered tool. This works
+* for both the polyfill (which listens for the `abort` event on the signal it
+* was given) and Chrome's native API (which also uses signal-based lifecycle).
+* The deprecated `unregisterTool(name)` is intentionally NOT called here
+* because it is absent from the native Chrome API and causes silent failures
+* that prevent proper cleanup.
+*/
+function unregisterWebMcpTools() {
+	for (const controller of registeredToolControllers.values()) try {
+		controller.abort();
+	} catch {}
+	registeredToolControllers.clear();
+	registeredToolNames.clear();
+}
+
+//#endregion
+export { registerWebMcpTools as a, webmcp_exports as c, onWebMcpToolChange as i, onWebMcpToolActivated as n, setWebMcpMode as o, onWebMcpToolCancel as r, unregisterWebMcpTools as s, getWebMcpMode as t };
+//# sourceMappingURL=webmcp-Bf9rT7uu.js.map