@mcp-b/webmcp-polyfill 6.0.2 → 6.1.0

package/dist/index.js

@@ -1,458 +1,5 @@
-//#region src/upstream/frames.ts
-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");
-}
+import { installWebMCP as installWebMCP$1 } from "@w3c/webmcp-polyfill";
 
-//#endregion
 //#region src/declarative-forms.ts
 const agentInvokedEvents = /* @__PURE__ */ new WeakSet();
 const agentResponses = /* @__PURE__ */ new WeakMap();
@@ -832,6 +379,9 @@ function fillForm(form, input) {
 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 executionError() {
+	return new DOMException("Tool execution failed", "UnknownError");
+}
 function lifecycleEvent(type, toolName) {
 	const event = new Event(type);
 	Object.defineProperty(event, "toolName", {
@@ -909,7 +459,7 @@ function waitForSubmission(context, registration, definition, submitter, signal)
 		}
 	});
 }
-/** Adds declarative tools until the vendored upstream implements them. */
+/** Adds declarative tools until upstream implements them. */
 function installWebMCPDeclarativeExtensions(context) {
 	const prototype = SubmitEvent.prototype;
 	if ("agentInvoked" in prototype && "respondWith" in prototype) return;
@@ -979,12 +529,12 @@ function installWebMCPDeclarativeExtensions(context) {
 			candidates.add(form);
 			const definition = toolDefinition(form);
 			const fingerprint = JSON.stringify(definition);
-			const blockedFingerprint = blockedDefinitions.get(form);
-			if (blockedFingerprint === fingerprint) continue;
+			if (blockedDefinitions.get(form) === fingerprint) continue;
 			blockedDefinitions.delete(form);
 			const existingForm = selectedByName.get(definition.name);
 			if (existingForm) {
-				if (blockedFingerprint === void 0) {
+				const holdsName = (candidate) => registrations.get(candidate)?.name === definition.name;
+				if (!holdsName(form) || holdsName(existingForm)) {
 					blockedDefinitions.set(form, fingerprint);
 					continue;
 				}
@@ -1010,7 +560,8 @@ function installWebMCPDeclarativeExtensions(context) {
 			const registration = {
 				controller,
 				fingerprint,
-				form
+				form,
+				name: definition.name
 			};
 			registrations.set(form, registration);
 			context.registerTool({
@@ -1059,405 +610,16 @@ function installWebMCPDeclarativeExtensions(context) {
 	sync();
 }
 
-//#endregion
-//#region src/upstream/index.ts
-/*!
-* 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);
-}
-
 //#endregion
 //#region src/index.ts
 /**
 * Installs upstream WebMCP and the temporary declarative tools layer.
-* Engines missing an API the vendored core calls are left untouched: upstream defines
+* Engines missing an API the upstream core calls are left untouched: upstream defines
 * the document getter before it constructs the context, so a failed construction would
 * leave `document.modelContext` throwing.
+*
+* @deprecated Use `installWebMCP` from `@w3c/webmcp-polyfill`. This wrapper only adds
+* declarative tools until upstream ships them.
 */
 function installWebMCP() {
 	if (typeof document === "undefined" || !globalThis.isSecureContext) return;