@mcp-b/webmcp-polyfill 4.0.0 → 5.0.0

package/dist/index.js

@@ -1,368 +1,943 @@
-import { isPlainObject, normalizeInputSchema, toJsonValue, validateValueWithSchema } from "./schema.js";
+import { coerceWebMcpToolDescriptor, createInvalidStateError, createToolInvocationFailedError, createUnknownError, isPlainObject, parseChromeToolInput, serializeChromeToolResult, serializeInputSchema, toWebMcpAnnotations, validateExecutableOrigin, validatePotentiallyTrustworthyOrigins, validateWebMcpAccess, validateWebMcpToolDescriptor, withAbortSignal } from "./schema.js";
 
+//#region src/declarative-forms.ts
+const agentInvokedEvents = /* @__PURE__ */ new WeakSet();
+const agentResponses = /* @__PURE__ */ new WeakMap();
+const activeSubmissions = /* @__PURE__ */ new WeakMap();
+function isAgentInvokedSubmitEvent(event) {
+	return event.isTrusted && (agentInvokedEvents.has(event) || event.eventPhase !== Event.NONE && event.target instanceof HTMLFormElement && activeSubmissions.has(event.target));
+}
+function respondWithAgentSubmitEvent(event, agentResponse) {
+	if (!isAgentInvokedSubmitEvent(event)) throw new DOMException("respondWith() is only available during an agent-invoked submit event", "InvalidStateError");
+	if (!event.defaultPrevented) throw new DOMException("respondWith() requires preventDefault() during an agent-invoked submit event", "InvalidStateError");
+	if (event.eventPhase === Event.NONE) throw new DOMException("respondWith() is only available while the submit event is being dispatched", "InvalidStateError");
+	agentInvokedEvents.add(event);
+	const response = Promise.resolve(agentResponse);
+	agentResponses.set(event, response);
+	if (event.target instanceof HTMLFormElement) activeSubmissions.get(event.target)?.respond(event);
+}
+const TEXT_INPUT_TYPES = new Set([
+	"email",
+	"password",
+	"search",
+	"tel",
+	"text",
+	"url"
+]);
+const READONLY_INPUT_TYPES = new Set([
+	...TEXT_INPUT_TYPES,
+	"date",
+	"datetime-local",
+	"month",
+	"number",
+	"time",
+	"week"
+]);
+function isControl(element) {
+	return element instanceof HTMLInputElement || element instanceof HTMLSelectElement || element instanceof HTMLTextAreaElement;
+}
+function getFormControls(form) {
+	return Reflect.get(HTMLFormElement.prototype, "elements", form);
+}
+function getFormAttribute(form, name) {
+	return Reflect.apply(Element.prototype.getAttribute, form, [name]);
+}
+function formHasAttribute(form, name) {
+	return Reflect.apply(Element.prototype.hasAttribute, form, [name]);
+}
+function isFormConnected(form) {
+	return Reflect.get(Node.prototype, "isConnected", form);
+}
+function getOpenShadowRoot(element) {
+	return Reflect.get(Element.prototype, "shadowRoot", element);
+}
+function checkFormValidity(form) {
+	return Reflect.apply(HTMLFormElement.prototype.checkValidity, form, []);
+}
+function requestFormSubmit(form, submitter) {
+	Reflect.apply(HTMLFormElement.prototype.requestSubmit, form, submitter ? [submitter] : []);
+}
+function getControls(form) {
+	return [...getFormControls(form)].filter((element) => isControl(element) && !element.matches(":disabled") && !("readOnly" in element && element.readOnly && (element instanceof HTMLTextAreaElement || READONLY_INPUT_TYPES.has(element.type))));
+}
+function controlGroups(form) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const control of getControls(form)) {
+		const name = control.name.trim();
+		const controls = groups.get(name);
+		if (controls) controls.push(control);
+		else groups.set(name, [control]);
+	}
+	return groups;
+}
+function labelText(control) {
+	return [...control.labels ?? []].map((label) => {
+		const copy = label.cloneNode(true);
+		if (!(copy instanceof HTMLElement)) return "";
+		copy.querySelectorAll("button, input, meter, output, progress, select, textarea").forEach((element) => element.remove());
+		return copy.textContent?.trim() ?? "";
+	}).filter(Boolean).join("; ");
+}
+function commonFieldset(form, controls) {
+	for (let element = controls[0]?.parentElement; element && element !== form; element = element.parentElement) if (element instanceof HTMLFieldSetElement && controls.every((control) => element.contains(control))) return element;
+}
+function parameterDescription(form, controls) {
+	if (controls.length === 1) {
+		const control = controls[0];
+		if (!control) return void 0;
+		return control.getAttribute("toolparamdescription") || labelText(control) || control.getAttribute("aria-description") || void 0;
+	}
+	return commonFieldset(form, controls)?.getAttribute("toolparamdescription") || void 0;
+}
+function withDescription(schema, form, controls, extra) {
+	const description = parameterDescription(form, controls);
+	const combined = description && extra ? `${description} (${extra})` : description || extra;
+	return combined ? {
+		...schema,
+		description: combined
+	} : schema;
+}
+function validNumberAttribute(input, name) {
+	const raw = input.getAttribute(name);
+	if (raw === null || raw.trim() === "") return void 0;
+	const value = Number(raw);
+	return Number.isFinite(value) ? value : void 0;
+}
+function isStepBaseMultiple(stepBase, step) {
+	const quotient = stepBase / step;
+	return Math.abs(quotient - Math.round(quotient)) < Number.EPSILON * 16;
+}
+function validPattern(input) {
+	const pattern = input.getAttribute("pattern");
+	if (pattern === null) return void 0;
+	try {
+		new RegExp(pattern, "v");
+		return pattern;
+	} catch {
+		return;
+	}
+}
+function numberSchema(input, includePattern = true) {
+	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;
+		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;
+	if (step < 1) return `${datePrefix}(:[0-5][0-9](\\.[0-9]{1,3})?)?$`;
+	if (step < 60) return `${datePrefix}(:[0-5][0-9])?$`;
+	return `${datePrefix}$`;
+}
+function optionSchemas(options) {
+	return {
+		anyOf: options.map((option) => ({
+			type: "string",
+			const: option.value,
+			title: option.textContent ?? ""
+		})),
+		enum: options.map((option) => option.value)
+	};
+}
+function groupChoiceSchemas(controls) {
+	return {
+		anyOf: controls.map((control) => {
+			const title = labelText(control);
+			return {
+				type: "string",
+				const: control.value,
+				...title ? { title } : {}
+			};
+		}),
+		enum: controls.map((control) => control.value)
+	};
+}
+function parameterSchema(form, controls) {
+	const first = controls[0];
+	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({
+			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) {
+		const choices = optionSchemas([...first.options]);
+		return withDescription(first.multiple ? {
+			type: "array",
+			items: {
+				type: "string",
+				...choices
+			},
+			uniqueItems: true
+		} : {
+			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);
+}
+function synthesizeSchema(form) {
+	const properties = {};
+	const required = [];
+	for (const [name, controls] of controlGroups(form)) {
+		if (!name) continue;
+		const schema = parameterSchema(form, controls);
+		if (!schema) continue;
+		Object.defineProperty(properties, name, {
+			configurable: true,
+			enumerable: true,
+			value: schema,
+			writable: true
+		});
+		if (controls.some((control) => control.required)) required.push(name);
+	}
+	return {
+		type: "object",
+		properties,
+		required
+	};
+}
+function toolDefinition(form) {
+	return {
+		name: getFormAttribute(form, "toolname") ?? "",
+		title: getFormAttribute(form, "tooltitle") ?? "",
+		description: getFormAttribute(form, "tooldescription") ?? "",
+		inputSchema: synthesizeSchema(form),
+		autosubmit: formHasAttribute(form, "toolautosubmit")
+	};
+}
+function toFormString(value) {
+	if (typeof value === "string" || typeof value === "boolean") return String(value);
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+}
+function toFormBoolean(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "number" && Number.isInteger(value)) return value !== 0;
+	if (typeof value !== "string") return void 0;
+	if (value === "1" || value.toLowerCase() === "true") return true;
+	if (value === "0" || value.toLowerCase() === "false") return false;
+}
+function hasUniqueAllowedValues(value, allowed) {
+	if (!Array.isArray(value)) return false;
+	const remaining = new Set(allowed);
+	for (const item of value) {
+		const string = toFormString(item);
+		if (string === void 0 || !remaining.delete(string)) return false;
+	}
+	return true;
+}
+function inputAcceptsValue(input, value) {
+	if (value === "") return input.type !== "number" && input.type !== "range";
+	const probe = input.ownerDocument.createElement("input");
+	probe.type = input.type;
+	probe.value = value;
+	return probe.value !== "";
+}
+function validatesParameter(form, controls, value) {
+	const first = controls[0];
+	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;
+	}
+	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.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) {
+	control.dispatchEvent(new Event("input", {
+		bubbles: true,
+		composed: true
+	}));
+	control.dispatchEvent(new Event("change", { bubbles: true }));
+}
+function setNativeValue(control, value) {
+	const prototype = control instanceof HTMLInputElement ? HTMLInputElement.prototype : HTMLTextAreaElement.prototype;
+	Object.getOwnPropertyDescriptor(prototype, "value")?.set?.call(control, value);
+}
+function setNativeChecked(control, checked) {
+	Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "checked")?.set?.call(control, checked);
+}
+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));
+			let changed = false;
+			for (const option of first.options) {
+				const next = selected.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;
+			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);
+	}
+}
+function fillForm(form, input) {
+	if (Array.isArray(input)) throw new TypeError("Declarative tool input must be an object");
+	const groups = controlGroups(form);
+	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}"`);
+	}
+	for (const [name, value] of Object.entries(input)) fillParameter(groups.get(name) ?? [], 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");
+	Object.defineProperty(event, "toolName", {
+		enumerable: true,
+		value: toolName
+	});
+	return event;
+}
+function waitForSubmission(registration, toolName, autosubmit, submitter) {
+	const { form } = registration;
+	registration.cancelPending?.(new DOMException("Tool execution cancelled", "UnknownError"));
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const cleanup = () => {
+			Reflect.apply(EventTarget.prototype.removeEventListener, form, [
+				"invalid",
+				onInvalid,
+				true
+			]);
+			activeSubmissions.delete(form);
+			if (registration.cancelPending === cancel) delete registration.cancelPending;
+		};
+		const finish = (callback) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			callback();
+		};
+		const cancel = (reason) => finish(() => reject(reason));
+		const settleResponse = (response) => {
+			response.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+		};
+		const onInvalid = (event) => {
+			if (!event.isTrusted) return;
+			queueMicrotask(() => {
+				if (!checkFormValidity(form)) cancel(validationError(form));
+			});
+		};
+		activeSubmissions.set(form, {
+			complete(event) {
+				queueMicrotask(() => {
+					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));
+				});
+			},
+			direct() {
+				finish(() => resolve(void 0));
+			},
+			respond(event) {
+				queueMicrotask(() => {
+					const response = agentResponses.get(event);
+					if (response) settleResponse(response);
+				});
+			}
+		});
+		registration.cancelPending = cancel;
+		Reflect.apply(EventTarget.prototype.addEventListener, form, [
+			"invalid",
+			onInvalid,
+			true
+		]);
+		if (!autosubmit) {
+			submitter?.focus();
+			window.dispatchEvent(toolActivatedEvent(toolName));
+			return;
+		}
+		try {
+			requestFormSubmit(form, submitter);
+			window.dispatchEvent(toolActivatedEvent(toolName));
+		} catch (error) {
+			cancel(error);
+		}
+	});
+}
+/** Installs the DOM-backed half of the draft Declarative WebMCP API. */
+function installDeclarativeForms(document, context) {
+	let active = true;
+	const registrations = /* @__PURE__ */ new Map();
+	const blockedDefinitions = /* @__PURE__ */ new Map();
+	const observers = /* @__PURE__ */ new Map();
+	const onSubmit = (event) => {
+		if (!(event instanceof SubmitEvent) || !event.isTrusted || !(event.target instanceof HTMLFormElement)) return;
+		const submission = activeSubmissions.get(event.target);
+		if (!submission) return;
+		agentInvokedEvents.add(event);
+		submission.complete(event);
+	};
+	const onReset = (event) => {
+		if (!event.isTrusted || !(event.target instanceof HTMLFormElement)) return;
+		const form = event.target;
+		queueMicrotask(() => {
+			if (event.defaultPrevented) return;
+			registrations.get(form)?.cancelPending?.(new DOMException("Tool execution cancelled by form reset", "UnknownError"));
+		});
+	};
+	function stopObservingRoot(root) {
+		observers.get(root)?.disconnect();
+		observers.delete(root);
+		root.removeEventListener("reset", onReset, true);
+		root.removeEventListener("submit", onSubmit, true);
+	}
+	function observeRoot(root) {
+		if (observers.has(root)) return;
+		const observer = new MutationObserver(sync);
+		observers.set(root, observer);
+		observer.observe(root, {
+			attributes: true,
+			characterData: true,
+			childList: true,
+			subtree: true
+		});
+		root.addEventListener("reset", onReset, true);
+		root.addEventListener("submit", onSubmit, true);
+	}
+	function sync() {
+		observeRoot(document);
+		for (const root of observers.keys()) if (root instanceof ShadowRoot && !Reflect.get(Node.prototype, "isConnected", root.host)) 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;
+			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);
+				}
+			}
+			selectedByName.set(definition.name, form);
+			selected.set(form, {
+				definition,
+				fingerprint
+			});
+		}
+		for (const form of blockedDefinitions.keys()) if (!candidates.has(form)) blockedDefinitions.delete(form);
+		for (const [form, registration] of registrations) if (selected.get(form)?.fingerprint !== registration.fingerprint) {
+			registration.cancelPending?.(new DOMException("Tool execution cancelled because its form changed", "UnknownError"));
+			registration.controller.abort();
+			registrations.delete(form);
+		}
+		for (const [form, { definition, fingerprint }] of selected) {
+			if (registrations.has(form)) continue;
+			const controller = new AbortController();
+			const registration = {
+				controller,
+				fingerprint,
+				form
+			};
+			registrations.set(form, registration);
+			context.registerTool({
+				name: definition.name,
+				title: definition.title,
+				description: definition.description,
+				inputSchema: definition.inputSchema,
+				execute(input) {
+					const submitter = findSubmitter(form);
+					if (!definition.autosubmit && !submitter) throw new DOMException("A declarative form without toolautosubmit requires a submit button", "UnknownError");
+					fillForm(form, input);
+					return waitForSubmission(registration, definition.name, definition.autosubmit, submitter);
+				}
+			}, { signal: controller.signal }).catch((error) => {
+				controller.abort();
+				if (error?.name === "AbortError") return;
+				console.error(`[webmcp] declarative form tool "${definition.name}" was not registered:`, error);
+			});
+		}
+	}
+	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 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);
+			return root;
+		};
+		Object.defineProperty(elementPrototype, "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 submit = function() {
+			nativeSubmit.call(this);
+			if (active) activeSubmissions.get(this)?.direct();
+		};
+		Object.defineProperty(formPrototype, "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 FAILED_TO_PARSE_INPUT_ARGUMENTS_MESSAGE = "Failed to parse input arguments";
-const TOOL_INVOCATION_FAILED_MESSAGE = "Tool was executed but the invocation failed. For example, the script function threw an error";
-const TOOL_CANCELLED_MESSAGE = "Tool was cancelled";
-/** WebMCP §4.2 tool name: ASCII alnum, underscore, hyphen, period; 1–128 code points. */
-const VALID_TOOL_NAME_RE = /^[A-Za-z0-9_\-.]{1,128}$/u;
 const POLYFILL_MARKER_PROPERTY = "__isWebMCPPolyfill";
-const STANDARD_VALIDATOR_SYMBOL = Symbol("standardValidator");
-function createAbortError() {
-	return new DOMException("signal is aborted without reason", "AbortError");
-}
-const installState = {
-	installed: false,
-	previousNavigatorModelContextDescriptor: void 0,
-	previousNavigatorModelContextTestingDescriptor: void 0,
-	previousDocumentModelContextDescriptor: void 0,
-	installedNavigatorModelContext: false,
-	installedNavigatorModelContextTesting: false,
-	installedDocumentModelContext: false
-};
+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
+	});
+}
 var StrictWebMCPContext = class extends EventTarget {
-	tools = /* @__PURE__ */ new Map();
-	testingShim = null;
-	_ontoolchange = null;
-	unregisterToolDeprecationWarned = false;
-	toolsChangedQueued = false;
+	#tools = /* @__PURE__ */ new Map();
+	#testingShim = null;
+	#ontoolchangeHandler = null;
+	#ontoolchangeListener = (event) => {
+		this.#ontoolchangeHandler?.call(this, event);
+	};
+	#domException;
+	#ownerDocument;
+	constructor(ownerDocument) {
+		super();
+		this.#ownerDocument = ownerDocument;
+		this.#domException = ownerDocument?.defaultView?.DOMException ?? DOMException;
+		Object.defineProperty(this, POLYFILL_MARKER_PROPERTY, {
+			value: true,
+			enumerable: false,
+			writable: false,
+			configurable: false
+		});
+	}
 	get ontoolchange() {
-		return this._ontoolchange;
+		return this.#ontoolchangeHandler;
 	}
 	set ontoolchange(handler) {
-		this._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;
 	}
-	registerTool(tool, options) {
+	async registerTool(tool, options = {}) {
+		validateWebMcpAccess(this.#ownerDocument);
 		const signal = options?.signal;
-		if (signal?.aborted) return Promise.reject(createAbortError());
-		const normalized = normalizeToolDescriptor(tool, this.tools);
-		this.tools.set(normalized.name, normalized);
-		this.notifyToolsChanged();
-		if (signal) signal.addEventListener("abort", () => {
-			if (this.tools.delete(normalized.name)) this.notifyToolsChanged();
-		}, { once: true });
-		return Promise.resolve();
-	}
-	unregisterTool(nameOrTool) {
-		this.warnUnregisterToolDeprecationOnce();
-		const name = getToolNameForUnregister(nameOrTool);
-		if (this.tools.delete(name)) this.notifyToolsChanged();
-	}
-	getTools() {
-		return Promise.resolve(this.getRegisteredToolInfos());
-	}
-	executeTool(tool, inputArgsJson, options) {
-		return this.executeToolByName(tool.name, inputArgsJson, options, false);
-	}
-	getTestingShim() {
-		if (!this.testingShim) this.testingShim = new PolyfillTestingShim(this);
-		return this.testingShim;
+		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;
 	}
-	/** @internal Used by PolyfillTestingShim */
-	getToolInfos() {
-		return [...this.tools.values()].map((tool) => {
-			let inputSchema;
-			try {
-				inputSchema = JSON.stringify(tool.inputSchema ?? { type: "object" });
-			} catch {
-				inputSchema = "{\"type\":\"object\"}";
-			}
+	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,
-				inputSchema
+				...isPlainObject(parsed) ? { inputSchema: parsed } : {},
+				origin: currentOrigin(),
+				window: globalThis.window,
+				...tool.annotations ? { annotations: toWebMcpAnnotations(tool.annotations) } : {}
 			};
-		});
+		}).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		return tools;
 	}
-	/** @internal Used by getTools() */
-	getRegisteredToolInfos() {
-		return this.getToolInfos().map((toolInfo) => {
-			const tool = this.tools.get(toolInfo.name);
-			return {
-				...toolInfo,
-				title: tool?.title ?? "",
-				origin: globalThis.location?.origin ?? "",
-				window: globalThis.window
-			};
-		});
+	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 */
-	async executeToolForTesting(toolName, inputArgsJson, options) {
-		return this.executeToolByName(toolName, inputArgsJson, options, true);
+	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] }
+		}));
 	}
-	async executeToolByName(toolName, inputArgsJson, options, normalizeResult) {
-		if (options?.signal?.aborted) throw createUnknownError(TOOL_CANCELLED_MESSAGE);
-		const tool = this.tools.get(toolName);
+	/** @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 = parseInputArgsJson(inputArgsJson);
-		const validationError = await validateArgsForTool(args, tool);
-		if (validationError) throw createUnknownError(validationError);
-		let contextActive = true;
-		const client = { requestUserInteraction: async (callback) => {
-			if (!contextActive) throw new Error(`ModelContextClient for tool "${toolName}" is no longer active after execute() resolved`);
-			if (typeof callback !== "function") throw new TypeError("requestUserInteraction(callback) requires a function callback");
-			return callback();
-		} };
+		const args = parseChromeToolInput(inputArgsJson);
+		options?.signal?.throwIfAborted();
+		if (tool[REGISTRATION_SIGNAL_SYMBOL]?.aborted) throw createUnknownError("Tool unregistered");
+		let rawResult;
 		try {
-			const execution = tool.execute(args, client);
-			const rawResult = await withAbortSignal(Promise.resolve(execution), options?.signal);
-			const normalizedResult = normalizeToolResponse(rawResult);
-			const outputValidationError = validateOutputForTool(normalizedResult, tool);
-			if (outputValidationError) throw new Error(outputValidationError);
-			if (normalizeResult) return toSerializedTestingResult(normalizedResult);
-			const serialized = JSON.stringify(rawResult);
-			return serialized === void 0 ? null : serialized;
+			const registrationSignal = tool[REGISTRATION_SIGNAL_SYMBOL];
+			rawResult = await withAbortSignal(withAbortSignal(Promise.resolve(tool.execute(args)), registrationSignal, () => createUnknownError("Tool unregistered")), options?.signal);
 		} catch (error) {
-			throw createUnknownError(error instanceof Error ? `${TOOL_INVOCATION_FAILED_MESSAGE}: ${error.message}` : TOOL_INVOCATION_FAILED_MESSAGE);
-		} finally {
-			contextActive = false;
+			if (options?.signal?.aborted && error === options.signal.reason) throw error;
+			if (tool[REGISTRATION_SIGNAL_SYMBOL]?.aborted) throw error;
+			throw createToolInvocationFailedError(error);
 		}
+		return serializeChromeToolResult(rawResult);
 	}
-	notifyToolsChanged() {
-		if (this.toolsChangedQueued) return;
-		this.toolsChangedQueued = true;
-		queueMicrotask(() => {
-			this.toolsChangedQueued = false;
-			const event = new Event("toolchange");
-			try {
-				this._ontoolchange?.call(this, event);
-			} catch (error) {
-				console.warn("[WebMCPPolyfill] navigator.modelContext.ontoolchange handler threw:", error);
-			}
-			this.dispatchEvent(event);
-			this.testingShim?.dispatchToolChange();
-		});
-	}
-	warnUnregisterToolDeprecationOnce() {
-		if (this.unregisterToolDeprecationWarned) return;
-		this.unregisterToolDeprecationWarned = true;
-		console.warn("[WebMCPPolyfill] navigator.modelContext.unregisterTool() is deprecated. The April 23, 2026 WebMCP draft removed it in favor of registerTool(tool, { signal }) — pass an AbortSignal and abort it to unregister.");
+	async #notifyToolsChanged() {
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		this.dispatchEvent(new Event("toolchange"));
+		this.#testingShim?.dispatchToolChange();
 	}
 };
+const modelContextConstructor = function ModelContext() {
+	throw new TypeError("Illegal constructor");
+};
+Object.defineProperty(modelContextConstructor, "name", { value: "ModelContext" });
+Object.defineProperty(modelContextConstructor, "prototype", {
+	value: StrictWebMCPContext.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"
+});
+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,
-* matching the native Chromium 148 API. The deprecated `registerToolsChangedCallback`
-* is kept as a compat layer that wraps `addEventListener`.
+* Fires `toolchange` events and supports the `ontoolchange` handler property.
 */
 var PolyfillTestingShim = class extends EventTarget {
-	context;
 	_ontoolchange = null;
+	ontoolchangeListener = (event) => {
+		this._ontoolchange?.call(this, event);
+	};
+	#context;
 	constructor(context) {
 		super();
-		this.context = context;
+		this.#context = context;
 	}
 	listTools() {
-		return this.context.getToolInfos();
+		return StrictWebMCPContext.getToolInfos(this.#context);
 	}
 	executeTool(toolName, inputArgsJson, options) {
-		return this.context.executeToolForTesting(toolName, inputArgsJson, options);
-	}
-	getCrossDocumentScriptToolResult() {
-		return Promise.resolve("[]");
+		return StrictWebMCPContext.executeToolForTesting(this.#context, toolName, inputArgsJson, options);
 	}
 	get ontoolchange() {
 		return this._ontoolchange;
 	}
 	set ontoolchange(handler) {
-		this._ontoolchange = handler;
-	}
-	/**
-	* @deprecated Use `addEventListener('toolchange', callback)` instead.
-	* Kept for backward compatibility with older polyfill consumers.
-	*/
-	registerToolsChangedCallback(callback) {
-		if (typeof callback !== "function") throw new TypeError("Failed to execute 'registerToolsChangedCallback' on 'ModelContextTesting': parameter 1 is not of type 'Function'.");
-		this.addEventListener("toolchange", callback);
+		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() {
-		const event = new Event("toolchange");
-		try {
-			this._ontoolchange?.call(this, event);
-		} catch (error) {
-			console.warn("[WebMCPPolyfill] ontoolchange handler threw:", error);
-		}
-		this.dispatchEvent(event);
-		this.dispatchEvent(new Event("toolschanged"));
+		this.dispatchEvent(new Event("toolchange"));
 	}
-};
-function createUnknownError(message) {
-	try {
-		return new DOMException(message, "UnknownError");
-	} catch {
-		const error = new Error(message);
-		error.name = "UnknownError";
-		return error;
+	dispose() {
+		this.ontoolchange = null;
 	}
-}
-function createInvalidStateError(message) {
-	try {
-		return new DOMException(message, "InvalidStateError");
-	} catch {
-		const error = new Error(message);
-		error.name = "InvalidStateError";
-		return error;
-	}
-}
-function parseInputArgsJson(inputArgsJson) {
-	let parsed;
-	try {
-		parsed = JSON.parse(inputArgsJson);
-	} catch {
-		throw createUnknownError(FAILED_TO_PARSE_INPUT_ARGUMENTS_MESSAGE);
-	}
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw createUnknownError(FAILED_TO_PARSE_INPUT_ARGUMENTS_MESSAGE);
-	return parsed;
-}
-function getToolNameForUnregister(nameOrTool) {
-	if (typeof nameOrTool === "string") return nameOrTool;
-	if (isPlainObject(nameOrTool) && typeof nameOrTool.name === "string") return nameOrTool.name;
-	throw new TypeError("Failed to execute 'unregisterTool' on 'ModelContext': parameter 1 must be a string or an object with a string name.");
-}
+};
 function normalizeToolDescriptor(tool, existing) {
 	if (!tool || typeof tool !== "object") throw new TypeError("registerTool(tool) requires a tool object");
-	if (typeof tool.name !== "string" || tool.name.length === 0) throw createInvalidStateError("Tool \"name\" must be a non-empty string");
-	if (!VALID_TOOL_NAME_RE.test(tool.name) || Array.from(tool.name).length > 128) throw createInvalidStateError("Tool \"name\" must be 1–128 characters and contain only ASCII alphanumeric, underscore, hyphen, or period");
-	if (typeof tool.description !== "string" || tool.description.length === 0) throw createInvalidStateError("Tool \"description\" must be a non-empty string");
-	if (typeof tool.execute !== "function") throw new TypeError("Tool \"execute\" must be a function");
-	if (existing.has(tool.name)) throw new Error(`Tool already registered: ${tool.name}`);
-	const normalizedInputSchema = normalizeInputSchema(tool.inputSchema);
-	const annotations = tool.annotations;
-	const normalizedAnnotations = annotations ? {
-		...annotations,
-		...annotations.readOnlyHint === "true" ? { readOnlyHint: true } : annotations.readOnlyHint === "false" ? { readOnlyHint: false } : {},
-		...annotations.destructiveHint === "true" ? { destructiveHint: true } : annotations.destructiveHint === "false" ? { destructiveHint: false } : {},
-		...annotations.idempotentHint === "true" ? { idempotentHint: true } : annotations.idempotentHint === "false" ? { idempotentHint: false } : {},
-		...annotations.openWorldHint === "true" ? { openWorldHint: true } : annotations.openWorldHint === "false" ? { openWorldHint: false } : {}
-	} : void 0;
-	return {
-		...tool,
-		...normalizedAnnotations ? { annotations: normalizedAnnotations } : {},
-		inputSchema: normalizedInputSchema.inputSchema,
-		[STANDARD_VALIDATOR_SYMBOL]: normalizedInputSchema.standardValidator
-	};
-}
-function formatStandardIssuePath(path) {
-	if (!path || path.length === 0) return null;
-	const segments = path.map((segment) => {
-		if (isPlainObject(segment) && "key" in segment) return segment.key;
-		return segment;
-	}).map((segment) => String(segment)).filter((segment) => segment.length > 0);
-	if (segments.length === 0) return null;
-	return segments.join(".");
-}
-async function validateArgsWithStandardSchema(args, schema) {
-	let result;
-	try {
-		result = await Promise.resolve(schema["~standard"].validate(args));
-	} catch (error) {
-		const detail = error instanceof Error ? `: ${error.message}` : "";
-		console.error("[WebMCPPolyfill] Standard Schema validation threw unexpectedly:", error);
-		return `Input validation error: schema validation failed${detail}`;
-	}
-	if (!result.issues || result.issues.length === 0) return null;
-	const firstIssue = result.issues[0];
-	if (!firstIssue) return "Input validation error";
-	const path = formatStandardIssuePath(firstIssue?.path);
-	if (path) return `Input validation error: ${firstIssue.message} at ${path}`;
-	return `Input validation error: ${firstIssue.message}`;
-}
-async function validateArgsForTool(args, tool) {
-	return validateArgsWithStandardSchema(args, tool[STANDARD_VALIDATOR_SYMBOL]);
-}
-function validateOutputForTool(result, tool) {
-	if (!tool.outputSchema || result.isError) return null;
-	if (result.structuredContent === void 0) return `Output validation error: Tool ${tool.name} has an output schema but no structured content was provided`;
-	const issue = validateValueWithSchema(result.structuredContent, tool.outputSchema);
-	return issue ? `Output validation error: ${issue.message}` : null;
-}
-function isCallToolResult(value) {
-	return isPlainObject(value) && Array.isArray(value.content);
-}
-function serializeTextContent(value) {
-	if (typeof value === "string") return value;
-	try {
-		return JSON.stringify(value) ?? String(value);
-	} catch {
-		return String(value);
-	}
-}
-function normalizeToolResponse(value) {
-	if (isCallToolResult(value)) return value;
-	const structuredContent = toJsonValue(value);
+	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);
 	return {
-		content: [{
-			type: "text",
-			text: serializeTextContent(value)
-		}],
-		...structuredContent !== void 0 ? { structuredContent } : {},
-		isError: false
+		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 } : {}
 	};
 }
-function getFirstTextBlock(result) {
-	for (const block of result.content ?? []) if (block.type === "text" && "text" in block && typeof block.text === "string") return block.text;
-	return null;
-}
-function toSerializedTestingResult(result) {
-	if (result.isError) throw createUnknownError(getFirstTextBlock(result)?.replace(/^Error:\s*/i, "").trim() || TOOL_INVOCATION_FAILED_MESSAGE);
-	const metadata = result.metadata;
-	if (metadata && typeof metadata === "object" && metadata.willNavigate) return null;
-	try {
-		return JSON.stringify(result);
-	} catch {
-		throw createUnknownError(TOOL_INVOCATION_FAILED_MESSAGE);
-	}
-}
-function withAbortSignal(operation, signal) {
-	if (!signal) return operation;
-	if (signal.aborted) return Promise.reject(createUnknownError(TOOL_CANCELLED_MESSAGE));
-	return new Promise((resolve, reject) => {
-		const onAbort = () => {
-			cleanup();
-			reject(createUnknownError(TOOL_CANCELLED_MESSAGE));
-		};
-		const cleanup = () => {
-			signal.removeEventListener("abort", onAbort);
-		};
-		signal.addEventListener("abort", onAbort, { once: true });
-		operation.then((value) => {
-			cleanup();
-			resolve(value);
-		}, (error) => {
-			cleanup();
-			reject(error);
-		});
-	});
-}
-function getNavigator() {
-	if (typeof navigator !== "undefined") return navigator;
-	return null;
-}
-function getDocument() {
-	if (typeof document !== "undefined") return document;
-	return null;
-}
-function defineNavigatorProperty(target, key, value) {
-	Object.defineProperty(target, key, {
-		configurable: true,
-		enumerable: true,
-		writable: false,
-		value
-	});
-}
-function defineDocumentModelContextProperty(target, value) {
-	Object.defineProperty(target, "modelContext", {
+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,
-		writable: false,
-		value
+		get: documentModelContextGetter
 	});
 }
-let navigatorModelContextDeprecationWarned = false;
 function defineDeprecatedNavigatorModelContext(target, value) {
-	Object.defineProperty(target, "modelContext", {
+	installProperty(target, "modelContext", {
 		configurable: true,
 		enumerable: true,
 		get() {
@@ -374,78 +949,70 @@ function defineDeprecatedNavigatorModelContext(target, value) {
 		}
 	});
 }
+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 initializeWebMCPPolyfill(options) {
-	const nav = getNavigator();
-	const doc = getDocument();
-	if (!nav && !doc) return;
-	const documentModelContext = doc?.modelContext;
-	if (Boolean(documentModelContext)) return;
-	const navigatorModelContext = nav?.modelContext;
-	const hasNavigatorModelContext = Boolean(navigatorModelContext);
-	if (installState.installed) cleanupWebMCPPolyfill();
-	if (doc && navigatorModelContext) {
-		installState.previousDocumentModelContextDescriptor = Object.getOwnPropertyDescriptor(doc, "modelContext");
-		defineDocumentModelContextProperty(doc, navigatorModelContext);
-		installState.installedDocumentModelContext = true;
-		installState.installed = true;
+	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;
 	}
-	if (hasNavigatorModelContext) return;
-	const context = new StrictWebMCPContext();
-	const modelContext = context;
-	modelContext[POLYFILL_MARKER_PROPERTY] = true;
-	if (doc) {
-		installState.previousDocumentModelContextDescriptor = Object.getOwnPropertyDescriptor(doc, "modelContext");
-		defineDocumentModelContextProperty(doc, modelContext);
-		installState.installedDocumentModelContext = true;
-	}
-	if (nav) {
-		installState.previousNavigatorModelContextDescriptor = Object.getOwnPropertyDescriptor(nav, "modelContext");
-		installState.previousNavigatorModelContextTestingDescriptor = Object.getOwnPropertyDescriptor(nav, "modelContextTesting");
-		navigatorModelContextDeprecationWarned = false;
-		defineDeprecatedNavigatorModelContext(nav, modelContext);
-		installState.installedNavigatorModelContext = true;
-		const installTestingShim = options?.installTestingShim ?? "if-missing";
-		const hasModelContextTesting = Boolean(nav.modelContextTesting);
-		if (installTestingShim === "always" || (installTestingShim === true || installTestingShim === "if-missing") && !hasModelContextTesting) {
-			defineNavigatorProperty(nav, "modelContextTesting", context.getTestingShim());
-			installState.installedNavigatorModelContextTesting = true;
-		}
-	}
-	installState.installed = true;
+	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() {
-	if (!installState.installed) return;
-	const restore = (target, key, previousDescriptor) => {
-		if (previousDescriptor) {
-			Object.defineProperty(target, key, previousDescriptor);
-			return;
-		}
-		delete target[key];
-	};
-	const nav = getNavigator();
-	const doc = getDocument();
-	if (doc && installState.installedDocumentModelContext) restore(doc, "modelContext", installState.previousDocumentModelContextDescriptor);
-	if (nav && installState.installedNavigatorModelContext) restore(nav, "modelContext", installState.previousNavigatorModelContextDescriptor);
-	if (nav && installState.installedNavigatorModelContextTesting) restore(nav, "modelContextTesting", installState.previousNavigatorModelContextTestingDescriptor);
-	installState.installed = false;
-	installState.previousDocumentModelContextDescriptor = void 0;
-	installState.previousNavigatorModelContextDescriptor = void 0;
-	installState.previousNavigatorModelContextTestingDescriptor = void 0;
-	installState.installedDocumentModelContext = false;
-	installState.installedNavigatorModelContext = false;
-	installState.installedNavigatorModelContextTesting = false;
+	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;
 }
-if (typeof window !== "undefined" && typeof document !== "undefined") {
-	const options = window.__webMCPPolyfillOptions;
-	if (options?.autoInitialize !== false) try {
-		initializeWebMCPPolyfill(options);
-	} catch (error) {
-		console.error("[WebMCPPolyfill] Auto-initialization failed:", error);
-	}
-}
 
 //#endregion
-export { cleanupWebMCPPolyfill, initializeWebMCPPolyfill, initializeWebMCPPolyfill as initializeWebModelContextPolyfill, isPlainObject, normalizeInputSchema, toJsonValue, validateValueWithSchema };
+export { cleanupWebMCPPolyfill, initializeWebMCPPolyfill };
 //# sourceMappingURL=index.js.map