@mcp-b/webmcp-polyfill 5.1.0 → 6.0.0

package/dist/index.js

@@ -1,5 +1,458 @@
-import { coerceWebMcpToolDescriptor, createInvalidStateError, createToolInvocationFailedError, createUnknownError, isPlainObject, parseChromeToolInput, serializeChromeToolResult, serializeInputSchema, toWebMcpAnnotations, validateExecutableOrigin, validatePotentiallyTrustworthyOrigins, validateWebMcpAccess, validateWebMcpToolDescriptor, withAbortSignal } from "./schema.js";
+//#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");
+}
 
+//#endregion
 //#region src/declarative-forms.ts
 const agentInvokedEvents = /* @__PURE__ */ new WeakSet();
 const agentResponses = /* @__PURE__ */ new WeakMap();
@@ -37,25 +490,25 @@ function isControl(element) {
 	return element instanceof HTMLInputElement || element instanceof HTMLSelectElement || element instanceof HTMLTextAreaElement;
 }
 function getFormControls(form) {
-	return Reflect.get(HTMLFormElement.prototype, "elements", form);
+	return Object.getOwnPropertyDescriptor(HTMLFormElement.prototype, "elements")?.get?.call(form);
 }
 function getFormAttribute(form, name) {
-	return Reflect.apply(Element.prototype.getAttribute, form, [name]);
+	return Element.prototype.getAttribute.call(form, name);
 }
 function formHasAttribute(form, name) {
-	return Reflect.apply(Element.prototype.hasAttribute, form, [name]);
+	return Element.prototype.hasAttribute.call(form, name);
 }
-function isFormConnected(form) {
-	return Reflect.get(Node.prototype, "isConnected", form);
+function isConnected(node) {
+	return Object.getOwnPropertyDescriptor(Node.prototype, "isConnected")?.get?.call(node);
 }
 function getOpenShadowRoot(element) {
-	return Reflect.get(Element.prototype, "shadowRoot", element);
+	return Object.getOwnPropertyDescriptor(Element.prototype, "shadowRoot")?.get?.call(element);
 }
 function checkFormValidity(form) {
-	return Reflect.apply(HTMLFormElement.prototype.checkValidity, form, []);
+	return HTMLFormElement.prototype.checkValidity.call(form);
 }
 function requestFormSubmit(form, submitter) {
-	Reflect.apply(HTMLFormElement.prototype.requestSubmit, form, submitter ? [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))));
@@ -103,41 +556,42 @@ function validNumberAttribute(input, name) {
 	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 validPattern(input) {
+function withPattern(schema, input) {
 	const pattern = input.getAttribute("pattern");
-	if (pattern === null) return void 0;
+	if (pattern === null) return schema;
 	try {
 		new RegExp(pattern, "v");
-		return pattern;
 	} catch {
-		return;
+		return schema;
 	}
+	return {
+		...schema,
+		pattern
+	};
 }
-function numberSchema(input, includePattern = true) {
+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;
-	const rawStep = input.getAttribute("step");
-	if (rawStep !== "any") {
-		const parsedStep = rawStep === null || rawStep === "" ? 1 : Number(rawStep);
-		const step = Number.isFinite(parsedStep) && parsedStep > 0 ? parsedStep : 1;
+	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;
 	}
-	const pattern = includePattern ? validPattern(input) : void 0;
-	if (pattern !== void 0) schema.pattern = pattern;
 	return schema;
 }
 function temporalFormat(input, datePrefix) {
-	const rawStep = input.getAttribute("step");
-	const parsedStep = rawStep === null || rawStep === "" ? 60 : Number(rawStep);
-	const step = Number.isFinite(parsedStep) && parsedStep > 0 ? parsedStep : 60;
+	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}$`;
@@ -156,38 +610,79 @@ function groupChoiceSchemas(controls) {
 	return {
 		anyOf: controls.map((control) => {
 			const title = labelText(control);
-			return {
+			const schema = {
 				type: "string",
-				const: control.value,
-				...title ? { title } : {}
+				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[0];
+	const [first] = controls;
 	if (!first) return void 0;
-	if (controls.length > 1) {
-		if (!controls.every((control) => control instanceof HTMLInputElement)) return void 0;
-		if (controls.every((control) => control.type === "checkbox")) return withDescription({
+	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
-		}, form, controls);
-		if (controls.every((control) => control.type === "radio")) return withDescription({
-			type: "string",
-			...groupChoiceSchemas(controls)
-		}, form, controls);
-		return;
-	}
-	if (first instanceof HTMLTextAreaElement) return withDescription({ type: "string" }, form, controls);
-	if (first instanceof HTMLSelectElement) {
+		};
+	} else if (first instanceof HTMLTextAreaElement) schema = { type: "string" };
+	else if (first instanceof HTMLSelectElement) {
 		const choices = optionSchemas([...first.options]);
-		return withDescription(first.multiple ? {
+		schema = first.multiple ? {
 			type: "array",
 			items: {
 				type: "string",
@@ -197,51 +692,10 @@ function parameterSchema(form, controls) {
 		} : {
 			type: "string",
 			...choices
-		}, form, controls);
-	}
-	if (TEXT_INPUT_TYPES.has(first.type)) {
-		const schema = { type: "string" };
-		const pattern = validPattern(first);
-		if (pattern !== void 0) schema.pattern = pattern;
-		return withDescription(schema, form, controls);
-	}
-	if (first.type === "hidden") return first.getAttribute("toolparamdescription") ? withDescription({ type: "string" }, form, controls) : void 0;
-	if (first.type === "number") return withDescription(numberSchema(first), form, controls);
-	if (first.type === "range") {
-		const schema = numberSchema(first, false);
-		schema.minimum ??= 0;
-		schema.maximum ??= 100;
-		return withDescription(schema, form, controls);
-	}
-	if (first.type === "checkbox") return withDescription({ type: "boolean" }, form, controls);
-	if (first.type === "radio") return withDescription({
-		type: "string",
-		...groupChoiceSchemas([first])
-	}, form, controls);
-	if (first.type === "date") return withDescription({
-		type: "string",
-		format: "date"
-	}, form, controls, "Dates MUST be provided in 'YYYY-MM-DD' format.");
-	if (first.type === "month") return withDescription({
-		type: "string",
-		format: "^[0-9]{4}-(0[1-9]|1[0-2])$"
-	}, form, controls);
-	if (first.type === "week") return withDescription({
-		type: "string",
-		format: "^[0-9]{4}-W(0[1-9]|[1-4][0-9]|5[0-3])$"
-	}, form, controls);
-	if (first.type === "time") return withDescription({
-		type: "string",
-		format: temporalFormat(first, "^([01][0-9]|2[0-3]):[0-5][0-9]")
-	}, form, controls);
-	if (first.type === "datetime-local") return withDescription({
-		type: "string",
-		format: temporalFormat(first, "^[0-9]{4}-(0[1-9]|1[0-2])-[0-9]{2}T([01][0-9]|2[0-3]):[0-5][0-9]")
-	}, form, controls);
-	if (first.type === "color") return withDescription({
-		type: "string",
-		format: "^#[0-9a-zA-Z]{6}$"
-	}, form, controls);
+		};
+	} 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 = {};
@@ -300,31 +754,19 @@ function inputAcceptsValue(input, value) {
 	probe.value = value;
 	return probe.value !== "";
 }
-function validatesParameter(form, controls, value) {
-	const first = controls[0];
+function isFormParameterValue(form, controls, value) {
+	const [first] = controls;
 	if (!first || !parameterSchema(form, controls)) return false;
-	if (controls.length > 1) {
-		if (!controls.every((control) => control instanceof HTMLInputElement)) return false;
-		if (controls.every((control) => control.type === "checkbox")) return hasUniqueAllowedValues(value, new Set(controls.map((control) => control.value)));
-		if (controls.every((control) => control.type === "radio")) {
-			const string = toFormString(value);
-			return string !== void 0 && controls.some((control) => control.value === string);
-		}
-		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);
-		const string = toFormString(value);
 		return string !== void 0 && allowed.has(string);
 	}
-	if (first instanceof HTMLTextAreaElement) return toFormString(value) !== void 0;
+	if (first instanceof HTMLTextAreaElement) return string !== void 0;
 	if (first.type === "checkbox") return toFormBoolean(value) !== void 0;
-	if (first.type === "radio") {
-		const string = toFormString(value);
-		return string !== void 0 && first.value === string;
-	}
-	const string = toFormString(value);
 	return string !== void 0 && inputAcceptsValue(first, string);
 }
 function dispatchInputAndChange(control) {
@@ -334,111 +776,78 @@ function dispatchInputAndChange(control) {
 	}));
 	control.dispatchEvent(new Event("change", { bubbles: true }));
 }
-function setNativeValue(control, value) {
+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 setNativeChecked(control, checked) {
+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[0];
-	if (!first) return;
-	if (controls.length > 1 && controls.every((control) => control instanceof HTMLInputElement)) {
-		if (controls.every((control) => control.type === "checkbox") && Array.isArray(value)) {
-			const checked = new Set(value.map(toFormString));
-			for (const control of controls) {
-				const next = checked.has(control.value);
-				if (control.checked === next) continue;
-				setNativeChecked(control, next);
-				dispatchInputAndChange(control);
-			}
-			return;
-		}
-		const selected = toFormString(value);
-		const control = controls.find((candidate) => candidate.value === selected);
-		if (control && !control.checked) {
-			setNativeChecked(control, true);
-			dispatchInputAndChange(control);
-		}
-		return;
-	}
-	if (first instanceof HTMLSelectElement) {
-		if (first.multiple && Array.isArray(value)) {
-			const selected = new Set(value.map(toFormString));
+	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 = selected.has(option.value);
+				const next = values.has(option.value);
 				if (option.selected === next) continue;
 				option.selected = next;
 				changed = true;
 			}
 			if (changed) dispatchInputAndChange(first);
-			return;
-		}
-		const next = toFormString(value);
-		if (next !== void 0 && first.value !== next) {
-			first.value = next;
+		} else if (string !== void 0 && first.value !== string) {
+			first.value = string;
 			dispatchInputAndChange(first);
 		}
-		return;
-	}
-	if (first instanceof HTMLInputElement && first.type === "checkbox") {
-		const next = toFormBoolean(value);
-		if (next !== void 0 && first.checked !== next) {
-			setNativeChecked(first, next);
-			dispatchInputAndChange(first);
-		}
-		return;
-	}
-	if (first instanceof HTMLInputElement && first.type === "radio") {
-		if (toFormString(value) === first.value && !first.checked) {
-			setNativeChecked(first, true);
-			dispatchInputAndChange(first);
-		}
-		return;
-	}
-	const next = toFormString(value);
-	if (next !== void 0 && first.value !== next) {
-		setNativeValue(first, next);
-		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 new TypeError("Declarative tool input must be an object");
+	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 || !validatesParameter(form, controls, value)) throw new TypeError(`Invalid value for declarative form parameter "${name}"`);
+		if (!controls || !isFormParameterValue(form, controls, value)) throw executionError();
+		parameters.push({
+			controls,
+			value
+		});
 	}
-	for (const [name, value] of Object.entries(input)) fillParameter(groups.get(name) ?? [], 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 validationError(form) {
-	const failures = [...getFormControls(form)].filter((element) => isControl(element) && element.willValidate && !element.validity.valid).map((control) => `${control.name.trim() || "{unknown}"}: ${control.validationMessage}`).join(". ");
-	return new DOMException(`Form validation failed: ${failures}`, "UnknownError");
-}
-function toolActivatedEvent(toolName) {
-	const event = new Event("toolactivated");
+function lifecycleEvent(type, toolName) {
+	const event = new Event(type);
 	Object.defineProperty(event, "toolName", {
 		enumerable: true,
 		value: toolName
 	});
 	return event;
 }
-function waitForSubmission(registration, toolName, autosubmit, submitter) {
+function waitForSubmission(context, registration, definition, submitter, signal) {
 	const { form } = registration;
-	registration.cancelPending?.(new DOMException("Tool execution cancelled", "UnknownError"));
+	registration.cancelPending?.(executionError());
 	return new Promise((resolve, reject) => {
 		let settled = false;
 		const cleanup = () => {
-			Reflect.apply(EventTarget.prototype.removeEventListener, form, [
-				"invalid",
-				onInvalid,
-				true
-			]);
+			EventTarget.prototype.removeEventListener.call(form, "invalid", onInvalid, true);
+			signal.removeEventListener("abort", onAbort);
 			activeSubmissions.delete(form);
 			if (registration.cancelPending === cancel) delete registration.cancelPending;
 		};
@@ -450,25 +859,32 @@ function waitForSubmission(registration, toolName, autosubmit, submitter) {
 		};
 		const cancel = (reason) => finish(() => reject(reason));
 		const settleResponse = (response) => {
-			response.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+			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(validationError(form));
+				if (!checkFormValidity(form)) cancel(executionError());
+			});
+		};
+		const onAbort = () => {
+			finish(() => {
+				context.dispatchEvent(lifecycleEvent("toolcancel", definition.name));
+				reject(signal.reason);
 			});
 		};
 		activeSubmissions.set(form, {
 			complete(event) {
-				queueMicrotask(() => {
+				setTimeout(() => {
 					const response = agentResponses.get(event);
 					if (response) settleResponse(response);
-					else if (event.defaultPrevented) cancel(new DOMException("preventDefault() requires respondWith()", "UnknownError"));
-					else finish(() => resolve(void 0));
+					else if (event.defaultPrevented) cancel(executionError());
+					else finish(() => resolve(null));
 				});
 			},
 			direct() {
-				finish(() => resolve(void 0));
+				finish(() => resolve(null));
 			},
 			respond(event) {
 				queueMicrotask(() => {
@@ -478,27 +894,40 @@ function waitForSubmission(registration, toolName, autosubmit, submitter) {
 			}
 		});
 		registration.cancelPending = cancel;
-		Reflect.apply(EventTarget.prototype.addEventListener, form, [
-			"invalid",
-			onInvalid,
-			true
-		]);
-		if (!autosubmit) {
+		EventTarget.prototype.addEventListener.call(form, "invalid", onInvalid, true);
+		signal.addEventListener("abort", onAbort, { once: true });
+		if (!definition.autosubmit) {
 			submitter?.focus();
-			window.dispatchEvent(toolActivatedEvent(toolName));
+			context.dispatchEvent(lifecycleEvent("toolactivated", definition.name));
 			return;
 		}
 		try {
 			requestFormSubmit(form, submitter);
-			window.dispatchEvent(toolActivatedEvent(toolName));
+			context.dispatchEvent(lifecycleEvent("toolactivated", definition.name));
 		} catch (error) {
 			cancel(error);
 		}
 	});
 }
-/** Installs the DOM-backed half of the draft Declarative WebMCP API. */
-function installDeclarativeForms(document, context) {
-	let active = true;
+/** 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();
@@ -512,9 +941,9 @@ function installDeclarativeForms(document, context) {
 	const onReset = (event) => {
 		if (!event.isTrusted || !(event.target instanceof HTMLFormElement)) return;
 		const form = event.target;
-		queueMicrotask(() => {
+		setTimeout(() => {
 			if (event.defaultPrevented) return;
-			registrations.get(form)?.cancelPending?.(new DOMException("Tool execution cancelled by form reset", "UnknownError"));
+			registrations.get(form)?.cancelPending?.(executionError());
 		});
 	};
 	function stopObservingRoot(root) {
@@ -538,33 +967,30 @@ function installDeclarativeForms(document, context) {
 	}
 	function sync() {
 		observeRoot(document);
-		for (const root of observers.keys()) if (root instanceof ShadowRoot && !Reflect.get(Node.prototype, "isConnected", root.host)) stopObservingRoot(root);
+		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") || !isFormConnected(element)) continue;
+			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);
 			const blockedFingerprint = blockedDefinitions.get(form);
 			if (blockedFingerprint === fingerprint) continue;
-			const retryingChangedDefinition = blockedFingerprint !== void 0;
 			blockedDefinitions.delete(form);
 			const existingForm = selectedByName.get(definition.name);
-			if (existingForm && !retryingChangedDefinition) {
-				blockedDefinitions.set(form, fingerprint);
-				continue;
-			}
 			if (existingForm) {
-				const existingSelection = selected.get(existingForm);
-				if (existingSelection) {
-					blockedDefinitions.set(existingForm, existingSelection.fingerprint);
-					selected.delete(existingForm);
+				if (blockedFingerprint === void 0) {
+					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, {
@@ -574,7 +1000,7 @@ function installDeclarativeForms(document, context) {
 		}
 		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?.(new DOMException("Tool execution cancelled because its form changed", "UnknownError"));
+			registration.cancelPending?.(executionError());
 			registration.controller.abort();
 			registrations.delete(form);
 		}
@@ -592,427 +1018,455 @@ function installDeclarativeForms(document, context) {
 				title: definition.title,
 				description: definition.description,
 				inputSchema: definition.inputSchema,
-				execute(input) {
+				execute(input, options) {
 					const submitter = findSubmitter(form);
-					if (!definition.autosubmit && !submitter) throw new DOMException("A declarative form without toolautosubmit requires a submit button", "UnknownError");
+					if (!definition.autosubmit && !submitter) throw executionError();
 					fillForm(form, input);
-					return waitForSubmission(registration, definition.name, definition.autosubmit, submitter);
+					return waitForSubmission(context, registration, definition, submitter, options.signal);
 				}
-			}, { signal: controller.signal }).catch((error) => {
+			}, { signal: controller.signal }).catch((cause) => {
 				controller.abort();
-				if (error?.name === "AbortError") return;
-				console.error(`[webmcp] declarative form tool "${definition.name}" was not registered:`, error);
+				if (cause instanceof DOMException && cause.name === "AbortError") return;
+				console.error(`[webmcp] declarative form tool "${definition.name}" was not registered:`, cause);
 			});
 		}
 	}
-	let restoreAttachShadow = () => {};
-	const elementPrototype = document.defaultView?.Element.prototype;
-	const attachShadowDescriptor = elementPrototype ? Object.getOwnPropertyDescriptor(elementPrototype, "attachShadow") : void 0;
-	if (elementPrototype && attachShadowDescriptor?.configurable) {
-		const nativeAttachShadow = elementPrototype.attachShadow;
+	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 (active && root.mode === "open" && Reflect.get(Node.prototype, "ownerDocument", this) === document && Reflect.get(Node.prototype, "isConnected", this)) observeRoot(root);
+			if (root.mode === "open" && Object.getOwnPropertyDescriptor(Node.prototype, "ownerDocument")?.get?.call(this) === document && isConnected(this)) observeRoot(root);
 			return root;
 		};
-		Object.defineProperty(elementPrototype, "attachShadow", {
+		Object.defineProperty(Element.prototype, "attachShadow", {
 			...attachShadowDescriptor,
 			value: attachShadow
 		});
-		restoreAttachShadow = () => {
-			if (elementPrototype.attachShadow === attachShadow) Object.defineProperty(elementPrototype, "attachShadow", attachShadowDescriptor);
-		};
 	}
-	let restoreFormSubmit = () => {};
-	const formPrototype = document.defaultView?.HTMLFormElement.prototype;
-	const submitDescriptor = formPrototype ? Object.getOwnPropertyDescriptor(formPrototype, "submit") : void 0;
-	if (formPrototype && submitDescriptor?.configurable) {
-		const nativeSubmit = formPrototype.submit;
+	const submitDescriptor = Object.getOwnPropertyDescriptor(HTMLFormElement.prototype, "submit");
+	if (submitDescriptor?.configurable) {
+		const nativeSubmit = HTMLFormElement.prototype.submit;
 		const submit = function() {
 			nativeSubmit.call(this);
-			if (active) activeSubmissions.get(this)?.direct();
+			activeSubmissions.get(this)?.direct();
 		};
-		Object.defineProperty(formPrototype, "submit", {
+		Object.defineProperty(HTMLFormElement.prototype, "submit", {
 			...submitDescriptor,
 			value: submit
 		});
-		restoreFormSubmit = () => {
-			if (formPrototype.submit === submit) Object.defineProperty(formPrototype, "submit", submitDescriptor);
-		};
 	}
 	sync();
-	return () => {
-		active = false;
-		restoreFormSubmit();
-		restoreAttachShadow();
-		for (const root of observers.keys()) stopObservingRoot(root);
-		blockedDefinitions.clear();
-		for (const registration of registrations.values()) {
-			registration.cancelPending?.(new DOMException("Tool execution cancelled", "UnknownError"));
-			registration.controller.abort();
-		}
-		registrations.clear();
-	};
 }
 
 //#endregion
-//#region src/index.ts
-const POLYFILL_MARKER_PROPERTY = "__isWebMCPPolyfill";
-const REGISTERED_INPUT_SCHEMA_SYMBOL = Symbol("registeredInputSchema");
-const REGISTRATION_SIGNAL_SYMBOL = Symbol("registrationSignal");
-const REGISTRATION_ABORT_SYMBOL = Symbol("registrationAbort");
-const installedProperties = [];
-let installedContext = null;
-let cleanupDeclarativeForms = null;
-function currentOrigin() {
-	return typeof globalThis.origin === "string" ? globalThis.origin : globalThis.location?.origin ?? "";
-}
-function installProperty(target, key, descriptor) {
-	const previous = Object.getOwnPropertyDescriptor(target, key);
-	try {
-		Object.defineProperty(target, key, descriptor);
-	} catch (error) {
-		cleanupWebMCPPolyfill();
-		throw error;
-	}
-	installedProperties.push({
-		target,
-		key,
-		previous
+//#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 StrictWebMCPContext = class extends EventTarget {
+var ModelContextPolyfill = class extends EventTarget {
+	#document;
 	#tools = /* @__PURE__ */ new Map();
-	#testingShim = null;
-	#ontoolchangeHandler = null;
-	#ontoolchangeListener = (event) => {
-		this.#ontoolchangeHandler?.call(this, event);
+	#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);
 	};
-	#domException;
-	#ownerDocument;
-	constructor(ownerDocument) {
+	constructor(owner) {
 		super();
-		this.#ownerDocument = ownerDocument;
-		this.#domException = ownerDocument?.defaultView?.DOMException ?? DOMException;
-		Object.defineProperty(this, POLYFILL_MARKER_PROPERTY, {
-			value: true,
-			enumerable: false,
-			writable: false,
-			configurable: false
+		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.#ontoolchangeHandler;
+		return this.#toolchangeHandler;
 	}
 	set ontoolchange(handler) {
-		const listener = typeof handler === "function" ? handler : null;
-		if (listener === null) {
-			this.#ontoolchangeHandler = null;
-			super.removeEventListener("toolchange", this.#ontoolchangeListener);
-			return;
-		}
-		if (this.#ontoolchangeHandler === null) super.addEventListener("toolchange", this.#ontoolchangeListener);
-		this.#ontoolchangeHandler = listener;
+		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 = {}) {
-		validateWebMcpAccess(this.#ownerDocument);
-		const signal = options?.signal;
-		const normalized = normalizeToolDescriptor(tool, this.#tools);
-		signal?.throwIfAborted();
-		validatePotentiallyTrustworthyOrigins(options?.exposedTo);
-		signal?.throwIfAborted();
-		if (options?.exposedTo?.length) throw new this.#domException("Cross-document tool exposure requires native WebMCP", "NotSupportedError");
-		this.#tools.set(normalized.name, normalized);
-		if (signal) {
-			const abort = () => {
-				if (this.#removeTool(normalized.name, normalized)) this.#notifyToolsChanged();
-			};
-			normalized[REGISTRATION_SIGNAL_SYMBOL] = signal;
-			normalized[REGISTRATION_ABORT_SYMBOL] = abort;
-			signal.addEventListener("abort", abort, { once: true });
-		}
-		await this.#notifyToolsChanged();
-		if (signal?.aborted) throw signal.reason;
+		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 = {}) {
-		validateWebMcpAccess(this.#ownerDocument);
-		validatePotentiallyTrustworthyOrigins(options?.fromOrigins);
-		if (options?.fromOrigins?.length) throw new this.#domException("Cross-document tool discovery requires native WebMCP", "NotSupportedError");
-		const tools = [...this.#tools.values()].map((tool) => {
-			const serialized = tool[REGISTERED_INPUT_SCHEMA_SYMBOL];
-			const parsed = serialized === void 0 ? void 0 : JSON.parse(serialized);
-			return {
-				name: tool.name,
-				title: tool.title ?? "",
-				description: tool.description,
-				...isPlainObject(parsed) ? { inputSchema: parsed } : {},
-				origin: currentOrigin(),
-				window: globalThis.window,
-				...tool.annotations ? { annotations: toWebMcpAnnotations(tool.annotations) } : {}
+		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();
+				});
 			};
-		}).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
-		await new Promise((resolve) => setTimeout(resolve, 0));
-		return tools;
-	}
-	async executeTool(tool, inputArgsJson, options = {}) {
-		validateWebMcpAccess(this.#ownerDocument);
-		if (tool === null || typeof tool !== "object") throw new TypeError("RegisteredTool must be an object");
-		for (const required of [
-			"name",
-			"description",
-			"window",
-			"origin"
-		]) if (!(required in tool)) throw new TypeError(`RegisteredTool.${required} is required`);
-		validateExecutableOrigin(tool.origin);
-		if (tool.window !== globalThis.window || tool.origin !== currentOrigin()) throw createUnknownError(`Tool not found: ${tool.name}`);
-		return this.#invokeToolByName(tool.name, inputArgsJson, options);
-	}
-	/** @internal Used by initializeWebMCPPolyfill */
-	static getTestingShim(context) {
-		context.#testingShim ??= new PolyfillTestingShim(context);
-		return context.#testingShim;
-	}
-	/** @internal Used by PolyfillTestingShim */
-	static getToolInfos(context) {
-		return [...context.#tools.values()].map((tool) => ({
-			name: tool.name,
-			description: tool.description,
-			...tool[REGISTERED_INPUT_SCHEMA_SYMBOL] === void 0 ? {} : { inputSchema: tool[REGISTERED_INPUT_SCHEMA_SYMBOL] }
-		}));
-	}
-	/** @internal Used by PolyfillTestingShim */
-	static executeToolForTesting(context, toolName, inputArgsJson, options) {
-		validateWebMcpAccess(context.#ownerDocument);
-		return context.#invokeToolByName(toolName, inputArgsJson, options);
-	}
-	/** @internal Used by cleanupWebMCPPolyfill */
-	static dispose(context) {
-		for (const name of context.#tools.keys()) context.#removeTool(name);
-		context.ontoolchange = null;
-		context.#testingShim?.dispose();
-	}
-	#removeTool(name, expected) {
-		const registered = this.#tools.get(name);
-		if (!registered || expected && registered !== expected) return false;
-		const signal = registered[REGISTRATION_SIGNAL_SYMBOL];
-		const abort = registered[REGISTRATION_ABORT_SYMBOL];
-		if (signal && abort) signal.removeEventListener("abort", abort);
-		return this.#tools.delete(name);
-	}
-	async #invokeToolByName(toolName, inputArgsJson, options) {
-		options?.signal?.throwIfAborted();
-		const tool = this.#tools.get(toolName);
-		if (!tool) throw createUnknownError(`Tool not found: ${toolName}`);
-		const args = parseChromeToolInput(inputArgsJson);
-		options?.signal?.throwIfAborted();
-		if (tool[REGISTRATION_SIGNAL_SYMBOL]?.aborted) throw createUnknownError("Tool unregistered");
-		let rawResult;
-		try {
-			const registrationSignal = tool[REGISTRATION_SIGNAL_SYMBOL];
-			rawResult = await withAbortSignal(withAbortSignal(Promise.resolve(tool.execute(args)), registrationSignal, () => createUnknownError("Tool unregistered")), options?.signal);
-		} catch (error) {
-			if (options?.signal?.aborted && error === options.signal.reason) throw error;
-			if (tool[REGISTRATION_SIGNAL_SYMBOL]?.aborted) throw error;
-			throw createToolInvocationFailedError(error);
+			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 serializeChromeToolResult(rawResult);
+		return exposed;
 	}
-	async #notifyToolsChanged() {
-		await new Promise((resolve) => setTimeout(resolve, 0));
-		this.dispatchEvent(new Event("toolchange"));
-		this.#testingShim?.dispatchToolChange();
+	#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: StrictWebMCPContext.prototype,
+	value: ModelContextPolyfill.prototype,
 	writable: false
 });
 Object.setPrototypeOf(modelContextConstructor, EventTarget);
-Object.defineProperty(StrictWebMCPContext.prototype, "constructor", {
-	configurable: true,
-	writable: true,
-	value: modelContextConstructor
-});
-Object.defineProperty(StrictWebMCPContext.prototype, Symbol.toStringTag, {
-	configurable: true,
-	value: "ModelContext"
+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 }
 });
-for (const member of [
-	"registerTool",
-	"getTools",
-	"executeTool",
-	"ontoolchange"
-]) {
-	const descriptor = Object.getOwnPropertyDescriptor(StrictWebMCPContext.prototype, member);
-	if (descriptor) Object.defineProperty(StrictWebMCPContext.prototype, member, {
-		...descriptor,
-		enumerable: true
-	});
-}
-/**
-* EventTarget-based testing shim matching the native Chromium ModelContextTesting surface.
-*
-* Fires `toolchange` events and supports the `ontoolchange` handler property.
-*/
-var PolyfillTestingShim = class extends EventTarget {
-	_ontoolchange = null;
-	ontoolchangeListener = (event) => {
-		this._ontoolchange?.call(this, event);
+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
 	};
-	#context;
-	constructor(context) {
-		super();
-		this.#context = context;
-	}
-	listTools() {
-		return StrictWebMCPContext.getToolInfos(this.#context);
-	}
-	executeTool(toolName, inputArgsJson, options) {
-		return StrictWebMCPContext.executeToolForTesting(this.#context, toolName, inputArgsJson, options);
-	}
-	get ontoolchange() {
-		return this._ontoolchange;
-	}
-	set ontoolchange(handler) {
-		const listener = typeof handler === "function" ? handler : null;
-		if (listener === null) {
-			this._ontoolchange = null;
-			super.removeEventListener("toolchange", this.ontoolchangeListener);
-			return;
-		}
-		if (this._ontoolchange === null) super.addEventListener("toolchange", this.ontoolchangeListener);
-		this._ontoolchange = listener;
-	}
-	/** @internal Called by StrictWebMCPContext when tools change. */
-	dispatchToolChange() {
-		this.dispatchEvent(new Event("toolchange"));
-	}
-	dispose() {
-		this.ontoolchange = null;
-	}
-};
-function normalizeToolDescriptor(tool, existing) {
-	if (!tool || typeof tool !== "object") throw new TypeError("registerTool(tool) requires a tool object");
-	const coerced = coerceWebMcpToolDescriptor(tool);
-	validateWebMcpToolDescriptor(coerced);
-	if (existing.has(coerced.name)) throw createInvalidStateError(`Tool already registered: ${coerced.name}`);
-	const registeredInputSchema = coerced.inputSchema === void 0 ? void 0 : serializeInputSchema(coerced.inputSchema);
+}
+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: coerced.name,
-		...coerced.title === void 0 ? {} : { title: coerced.title },
-		description: coerced.description,
-		...coerced.inputSchema === void 0 ? {} : { inputSchema: coerced.inputSchema },
-		...coerced.annotations === void 0 ? {} : { annotations: coerced.annotations },
-		execute: (input) => Reflect.apply(coerced.execute, void 0, [input]),
-		...registeredInputSchema !== void 0 ? { [REGISTERED_INPUT_SCHEMA_SYMBOL]: registeredInputSchema } : {}
+		name,
+		origin,
+		window: targetWindow
 	};
 }
-let navigatorModelContextDeprecationWarned = false;
-/**
-* Backing store for the `Document.prototype.modelContext` getter.
-*
-* WebIDL puts `[SameObject] readonly attribute ModelContext modelContext` on
-* the Document *interface prototype object*, not on the document instance, and
-* Chrome matches that. One shared accessor therefore needs somewhere to keep
-* the per-document value, and keying it by document is what makes repeated
-* reads return the identical object, as `[SameObject]` requires.
-*/
-const documentModelContexts = /* @__PURE__ */ new WeakMap();
-const { modelContext: documentModelContextGetter } = { modelContext() {
-	if (!(this instanceof Document)) throw new TypeError("Illegal invocation");
-	return documentModelContexts.get(this);
-} };
-Object.defineProperty(documentModelContextGetter, "name", { value: "get modelContext" });
-function defineDocumentModelContext(target, value) {
-	documentModelContexts.set(target, value);
-	if (Object.hasOwn(Document.prototype, "modelContext")) return;
-	installProperty(Document.prototype, "modelContext", {
-		configurable: true,
-		enumerable: true,
-		get: documentModelContextGetter
-	});
+function readInputSchema(value) {
+	if (value !== void 0 && !isObject(value)) throw new TypeError("inputSchema must be an object");
+	return value;
 }
-function defineDeprecatedNavigatorModelContext(target, value) {
-	installProperty(target, "modelContext", {
-		configurable: true,
-		enumerable: true,
-		get() {
-			if (!navigatorModelContextDeprecationWarned) {
-				navigatorModelContextDeprecationWarned = true;
-				console.warn("[WebMCPPolyfill] navigator.modelContext is deprecated. The May 27, 2026 WebMCP draft moved the modelContext getter from Navigator to Document — use document.modelContext instead. See https://github.com/webmachinelearning/webmcp/pull/184.");
-			}
-			return value;
-		}
-	});
+function isObject(value) {
+	return typeof value === "object" && value !== null || typeof value === "function";
 }
-function installSubmitEventPolyfill() {
-	const prototype = SubmitEvent.prototype;
-	if (!("agentInvoked" in prototype)) installProperty(prototype, "agentInvoked", {
-		configurable: true,
-		enumerable: true,
-		get() {
-			return isAgentInvokedSubmitEvent(this);
-		}
-	});
-	if (!("respondWith" in prototype)) installProperty(prototype, "respondWith", {
-		configurable: true,
-		enumerable: true,
-		writable: true,
-		value(agentResponse) {
-			respondWithAgentSubmitEvent(this, agentResponse);
-		}
+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 initializeWebMCPPolyfill(options) {
-	if (globalThis.isSecureContext === false) return;
-	const nav = typeof navigator === "undefined" ? null : navigator;
-	const doc = typeof document === "undefined" ? null : document;
-	if (!nav || !doc || typeof window === "undefined") return;
-	if (doc.modelContext) return;
-	const navigatorModelContext = nav.modelContext;
-	if (installedProperties.length > 0) cleanupWebMCPPolyfill();
-	if (navigatorModelContext) {
-		defineDocumentModelContext(doc, navigatorModelContext);
-		return;
+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;
 	}
-	const previousDescriptor = Object.getOwnPropertyDescriptor(window, "ModelContext");
-	if (previousDescriptor && !previousDescriptor.configurable) {
-		if (!Object.is(Reflect.get(window, "ModelContext"), modelContextConstructor)) throw new TypeError("Cannot install ModelContext over a non-configurable global");
-	} else installProperty(window, "ModelContext", {
-		configurable: true,
-		enumerable: false,
-		writable: true,
-		value: modelContextConstructor
-	});
-	const context = new StrictWebMCPContext(doc);
-	installedContext = context;
-	defineDocumentModelContext(doc, context);
-	navigatorModelContextDeprecationWarned = false;
-	defineDeprecatedNavigatorModelContext(nav, context);
-	installSubmitEventPolyfill();
-	if (options?.installTestingShim && !nav.modelContextTesting) installProperty(nav, "modelContextTesting", {
-		configurable: true,
-		enumerable: true,
-		writable: false,
-		value: StrictWebMCPContext.getTestingShim(context)
-	});
-	cleanupDeclarativeForms = installDeclarativeForms(doc, context);
-}
-function cleanupWebMCPPolyfill() {
-	cleanupDeclarativeForms?.();
-	cleanupDeclarativeForms = null;
-	if (installedContext) StrictWebMCPContext.dispose(installedContext);
-	installedContext = null;
-	for (const { target, key, previous } of [...installedProperties].reverse()) if (previous) Object.defineProperty(target, key, previous);
-	else Reflect.deleteProperty(target, key);
-	installedProperties.length = 0;
-	navigatorModelContextDeprecationWarned = false;
+	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
+* 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
-export { cleanupWebMCPPolyfill, initializeWebMCPPolyfill };
+export { installWebMCP };
 //# sourceMappingURL=index.js.map