shadow-claw 1.32.0 → 1.33.0

package/dist/lib/webmcp-BVR2lBVo.js

@@ -0,0 +1,1544 @@
+import { n as __exportAll } from "./rolldown-runtime-DZ8SGSJo.js";
+import { o as DEFAULT_GROUP_ID } from "./config-BcFbkaQv.js";
+import { t as TOOL_DEFINITIONS } from "./tools-DKzPWc0q.js";
+import "./tools-C3Kft940.js";
+
+//#region node_modules/@mcp-b/webmcp-polyfill/dist/schema.js
+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 VALID_TOOL_NAME_RE = /^[A-Za-z0-9_.-]{1,128}$/u;
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toDomString(value) {
+	if (typeof value === "symbol") throw new TypeError("Symbol values cannot be converted to a DOMString");
+	return String(value);
+}
+function coerceWebMcpToolDescriptor(tool) {
+	const name = Reflect.get(tool, "name");
+	const description = Reflect.get(tool, "description");
+	const title = Reflect.get(tool, "title");
+	if (name === void 0) throw new TypeError("Tool \"name\" is required");
+	if (description === void 0) throw new TypeError("Tool \"description\" is required");
+	const annotations = Reflect.get(tool, "annotations");
+	const annotationMembers = isPlainObject(annotations) ? annotations : {};
+	const inputSchema = Reflect.get(tool, "inputSchema");
+	const outputSchema = Reflect.get(tool, "outputSchema");
+	const execute = Reflect.get(tool, "execute");
+	return {
+		name: toDomString(name),
+		...title === void 0 ? {} : { title: toDomString(title).toWellFormed() },
+		description: toDomString(description),
+		...inputSchema === void 0 ? {} : { inputSchema },
+		...outputSchema === void 0 ? {} : { outputSchema },
+		execute,
+		...annotations === void 0 ? {} : { annotations: {
+			...annotationMembers.title === void 0 ? {} : { title: toDomString(annotationMembers.title).toWellFormed() },
+			readOnlyHint: Boolean(annotationMembers.readOnlyHint),
+			...annotationMembers.destructiveHint === void 0 ? {} : { destructiveHint: Boolean(annotationMembers.destructiveHint) },
+			...annotationMembers.idempotentHint === void 0 ? {} : { idempotentHint: Boolean(annotationMembers.idempotentHint) },
+			...annotationMembers.openWorldHint === void 0 ? {} : { openWorldHint: Boolean(annotationMembers.openWorldHint) },
+			untrustedContentHint: Boolean(annotationMembers.untrustedContentHint)
+		} }
+	};
+}
+function createUnknownError(message) {
+	return new DOMException(message, "UnknownError");
+}
+function createToolInvocationFailedError(error) {
+	return createUnknownError(error instanceof Error ? `${TOOL_INVOCATION_FAILED_MESSAGE}: ${error.message}` : TOOL_INVOCATION_FAILED_MESSAGE);
+}
+function createInvalidStateError(message) {
+	return new DOMException(message, "InvalidStateError");
+}
+function validateWebMcpToolDescriptor(tool) {
+	if (tool.name === "") throw createInvalidStateError("Tool \"name\" must be a non-empty string");
+	if (typeof tool.name !== "string" || !VALID_TOOL_NAME_RE.test(tool.name)) 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");
+}
+function toWebMcpAnnotations(annotations) {
+	return {
+		readOnlyHint: annotations.readOnlyHint ?? false,
+		untrustedContentHint: annotations.untrustedContentHint ?? false
+	};
+}
+function parseChromeToolInput(input) {
+	try {
+		const value = JSON.parse(input);
+		if (Array.isArray(value) || isPlainObject(value)) return value;
+	} catch {}
+	throw createUnknownError(FAILED_TO_PARSE_INPUT_ARGUMENTS_MESSAGE);
+}
+function serializeChromeToolResult(value) {
+	if (typeof value === "object" && value !== null || typeof value === "function") try {
+		const serialized = JSON.stringify(value);
+		if (serialized) return serialized;
+	} catch {}
+	return String(value) || "Operation succeeded";
+}
+function withAbortSignal(operation, signal, getAbortReason = () => signal?.reason) {
+	if (!signal) return operation;
+	if (signal.aborted) return Promise.reject(getAbortReason());
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			cleanup();
+			reject(getAbortReason());
+		};
+		const cleanup = () => signal.removeEventListener("abort", onAbort);
+		signal.addEventListener("abort", onAbort, { once: true });
+		operation.then((value) => {
+			cleanup();
+			resolve(value);
+		}, (error) => {
+			cleanup();
+			reject(error);
+		});
+	});
+}
+function isPotentiallyTrustworthyOrigin(url) {
+	const originUrl = url.origin === "null" ? url : new URL(url.origin);
+	const protocol = originUrl.protocol;
+	if ([
+		"https:",
+		"wss:",
+		"file:",
+		"chrome-extension:",
+		"moz-extension:"
+	].includes(protocol)) return true;
+	const hostname = originUrl.hostname.toLowerCase();
+	const ipv4 = hostname.split(".");
+	const isLoopbackIpv4 = ipv4.length === 4 && ipv4.every((part) => /^\d{1,3}$/u.test(part) && Number(part) <= 255) && Number(ipv4[0]) === 127;
+	return hostname === "::1" || hostname === "[::1]" || hostname === "localhost" || hostname === "localhost." || hostname.endsWith(".localhost") || hostname.endsWith(".localhost.") || isLoopbackIpv4;
+}
+function validatePotentiallyTrustworthyOrigins(origins) {
+	for (const origin of origins ?? []) {
+		let parsed;
+		try {
+			parsed = new URL(origin);
+		} catch {
+			throw new DOMException(`Invalid or untrustworthy origin: ${String(origin)}`, "SecurityError");
+		}
+		if (!isPotentiallyTrustworthyOrigin(parsed)) throw new DOMException(`Invalid or untrustworthy origin: ${origin}`, "SecurityError");
+	}
+}
+function validateWebMcpAccess(ownerDocument) {
+	validateOriginAgentCluster();
+	if (!ownerDocument) return;
+	const DOMExceptionConstructor = ownerDocument.defaultView?.DOMException ?? DOMException;
+	let fullyActive = false;
+	try {
+		const ownerWindow = ownerDocument.defaultView;
+		fullyActive = Boolean(ownerWindow && ownerWindow.document === ownerDocument);
+	} catch {}
+	if (!fullyActive) throw new DOMExceptionConstructor("The associated document is not fully active", "InvalidStateError");
+	const policy = Reflect.get(ownerDocument, "permissionsPolicy") ?? Reflect.get(ownerDocument, "featurePolicy");
+	if (policy && typeof policy === "object") {
+		const features = Reflect.get(policy, "features");
+		const allowsFeature = Reflect.get(policy, "allowsFeature");
+		if (typeof features === "function" && typeof allowsFeature === "function") {
+			const supported = Reflect.apply(features, policy, []);
+			if (Array.isArray(supported) && supported.includes("tools")) {
+				if (Reflect.apply(allowsFeature, policy, ["tools"]) === true) return;
+				throw new DOMExceptionConstructor("WebMCP is disabled by Permissions Policy", "NotAllowedError");
+			}
+		}
+	}
+	const ownerWindow = ownerDocument.defaultView;
+	if (!ownerWindow || ownerWindow.parent === ownerWindow) return;
+	try {
+		ownerWindow.parent.document;
+		return;
+	} catch {}
+	throw new DOMExceptionConstructor("WebMCP in cross-origin frames requires native Permissions Policy support", "NotAllowedError");
+}
+function validateOriginAgentCluster() {
+	if (globalThis.originAgentCluster === false && globalThis.location?.protocol !== "file:") throw new DOMException("", "SecurityError");
+}
+function validateExecutableOrigin(origin) {
+	try {
+		if (new URL(String(origin)).origin !== "null") return;
+	} catch {}
+	throw new DOMException(`Unsupported tool origin: ${String(origin)}`, "NotSupportedError");
+}
+function serializeInputSchema(schema) {
+	if (schema === null || typeof schema !== "object" && typeof schema !== "function") throw new TypeError("inputSchema must be an object");
+	const serialized = JSON.stringify(schema);
+	if (serialized === void 0) throw new TypeError("inputSchema must be JSON-serializable");
+	return serialized;
+}
+
+//#endregion
+//#region node_modules/@mcp-b/webmcp-polyfill/dist/index.js
+const agentInvokedEvents = /* @__PURE__ */ new WeakSet();
+const agentResponses = /* @__PURE__ */ new WeakMap();
+const activeSubmissions = /* @__PURE__ */ new WeakMap();
+function isAgentInvokedSubmitEvent(event) {
+	return event.isTrusted && (agentInvokedEvents.has(event) || event.eventPhase !== Event.NONE && event.target instanceof HTMLFormElement && activeSubmissions.has(event.target));
+}
+function respondWithAgentSubmitEvent(event, agentResponse) {
+	if (!isAgentInvokedSubmitEvent(event)) throw new DOMException("respondWith() is only available during an agent-invoked submit event", "InvalidStateError");
+	if (!event.defaultPrevented) throw new DOMException("respondWith() requires preventDefault() during an agent-invoked submit event", "InvalidStateError");
+	if (event.eventPhase === Event.NONE) throw new DOMException("respondWith() is only available while the submit event is being dispatched", "InvalidStateError");
+	agentInvokedEvents.add(event);
+	const response = Promise.resolve(agentResponse);
+	agentResponses.set(event, response);
+	if (event.target instanceof HTMLFormElement) activeSubmissions.get(event.target)?.respond(event);
+}
+const TEXT_INPUT_TYPES = /* @__PURE__ */ new Set([
+	"email",
+	"password",
+	"search",
+	"tel",
+	"text",
+	"url"
+]);
+const READONLY_INPUT_TYPES = /* @__PURE__ */ new Set([
+	...TEXT_INPUT_TYPES,
+	"date",
+	"datetime-local",
+	"month",
+	"number",
+	"time",
+	"week"
+]);
+function isControl(element) {
+	return element instanceof HTMLInputElement || element instanceof HTMLSelectElement || element instanceof HTMLTextAreaElement;
+}
+function getFormControls(form) {
+	return 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();
+	};
+}
+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
+	});
+}
+var StrictWebMCPContext = class extends EventTarget {
+	#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.#ontoolchangeHandler;
+	}
+	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;
+	}
+	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;
+	}
+	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) } : {}
+			};
+		}).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);
+		}
+		return serializeChromeToolResult(rawResult);
+	}
+	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.
+*/
+var PolyfillTestingShim = class extends EventTarget {
+	_ontoolchange = null;
+	ontoolchangeListener = (event) => {
+		this._ontoolchange?.call(this, event);
+	};
+	#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);
+	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 } : {}
+	};
+}
+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 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 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) {
+	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;
+	}
+	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 globalThis");
+	} 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;
+}
+
+//#endregion
+//#region src/subsystems/mcp/webmcp.ts
+var webmcp_exports = /* @__PURE__ */ __exportAll({
+	CONSEQUENTIAL_TOOL_NAMES: () => CONSEQUENTIAL_TOOL_NAMES,
+	READ_ONLY_TOOL_NAMES: () => READ_ONLY_TOOL_NAMES,
+	executeWebMcpTool: () => executeWebMcpTool,
+	extractAbortSignal: () => extractAbortSignal,
+	getWebMcpMode: () => getWebMcpMode,
+	getWebMcpTools: () => getWebMcpTools,
+	parseWebMcpInputSchema: () => parseWebMcpInputSchema,
+	registerWebMcpTools: () => registerWebMcpTools,
+	resolveWebMcpToolAnnotations: () => resolveWebMcpToolAnnotations,
+	setWebMcpMode: () => setWebMcpMode,
+	unregisterWebMcpTools: () => unregisterWebMcpTools
+});
+const registeredToolControllers = /* @__PURE__ */ new Map();
+const registeredToolNames = /* @__PURE__ */ new Set();
+let currentMode = "polyfill";
+/**
+* Set the WebMCP mode (polyfill vs native).
+*
+* - `"polyfill"` (default): Uses `@mcp-b/webmcp-polyfill` for a pure-JS
+*   `document.modelContext` that works in all browsers.
+* - `"native"`: Uses Chrome's native `document.modelContext` from
+*   `chrome://flags/#enable-webmcp-testing`.  Requires the flag to be
+*   enabled.  May crash in early Canary builds.
+*
+* Detection follows Chrome's recommended compat pattern:
+*   `document.modelContext || navigator.modelContext`
+* `navigator.modelContext` was deprecated in Chrome 150 and removed in
+* Chrome 152.0.7943.0, but the fallback keeps older clients working.
+*/
+function setWebMcpMode(mode) {
+	currentMode = mode;
+}
+function getWebMcpMode() {
+	return currentMode;
+}
+/**
+* Install the `@mcp-b/webmcp-polyfill` onto `document.modelContext`.
+*
+* The polyfill itself bails out when Chrome's native `document.modelContext`
+* is already present — it does NOT override the native API. We call it
+* unconditionally; if the polyfill is already installed it will detect the
+* existing install via its own `installState` guard and return quickly.
+*/
+function ensurePolyfill() {
+	try {
+		initializeWebMCPPolyfill();
+	} catch (err) {
+		console.warn("WebMCP polyfill initialization failed:", err);
+	}
+}
+/**
+* Access the WebMCP ModelContext API.
+*
+* In polyfill mode: installs the `@mcp-b/webmcp-polyfill` which surfaces
+* `document.modelContext`.
+* In native mode: follows Chrome's recommended feature-detection pattern:
+*   `document.modelContext || navigator.modelContext`
+* `navigator.modelContext` was deprecated in Chrome 150 and removed in
+* Chrome 152.0.7943.0, but the fallback preserves compatibility with
+* earlier builds that may still be in the wild.
+*/
+function getModelContextApi() {
+	if (typeof document === "undefined" && typeof navigator === "undefined") return null;
+	if (currentMode === "polyfill") ensurePolyfill();
+	try {
+		const modelContext = typeof document !== "undefined" && typeof document.modelContext !== "undefined" ? Reflect.get(document, "modelContext") : typeof navigator !== "undefined" && typeof navigator.modelContext !== "undefined" ? Reflect.get(navigator, "modelContext") : void 0;
+		if (!modelContext || typeof modelContext !== "object") return null;
+		const api = modelContext;
+		if (typeof api.registerTool !== "function") return null;
+		return api;
+	} catch (err) {
+		console.warn("WebMCP modelContext access failed:", err);
+		return null;
+	}
+}
+/**
+* Safely parse or normalize WebMCP input schema.
+*
+* Starting in Chrome 154.0.8014.0 (PR #241), `RegisteredTool#inputSchema` returns
+* a JavaScript object (a deep copy of the schema provided at registration).
+* In Chrome < 154.0.8014.0, `RegisteredTool#inputSchema` returned a stringified JSON schema (DOMString).
+*
+* This function provides backwards-compatible schema parsing:
+* - If inputSchema is a string: attempts JSON.parse.
+* - If inputSchema is an object: returns the object.
+* - Fallbacks gracefully to an empty object schema if null, undefined, or invalid JSON.
+*/
+function parseWebMcpInputSchema(inputSchema) {
+	if (typeof inputSchema === "string") {
+		try {
+			const parsed = JSON.parse(inputSchema);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+		} catch {}
+		return {
+			type: "object",
+			properties: {}
+		};
+	}
+	if (inputSchema && typeof inputSchema === "object" && !Array.isArray(inputSchema)) return inputSchema;
+	return {
+		type: "object",
+		properties: {}
+	};
+}
+/**
+* Safely extract AbortSignal from execute options/context.
+* Supports Chrome 153+ options object `{ signal }` (PR #247), direct AbortSignal instances,
+* or undefined for backward compatibility with Chrome < 153 and legacy callers.
+*/
+function extractAbortSignal(context) {
+	if (!context) return;
+	if (typeof AbortSignal !== "undefined" && context instanceof AbortSignal) return context;
+	if (typeof context === "object" && "signal" in context && typeof AbortSignal !== "undefined" && context.signal instanceof AbortSignal) return context.signal;
+}
+/**
+* Retrieve tools registered on the WebMCP ModelContext API.
+*
+* Practicing graceful degradation:
+* - Feature-detects `getTools()` on `document.modelContext` / `navigator.modelContext`.
+* - If `getTools()` is absent (older browser builds or polyfills without getTools),
+*   returns an empty array `[]` without throwing.
+* - Normalizes `RegisteredTool#inputSchema` so caller receives a JavaScript object
+*   whether running on Chrome 154+ (native object) or Chrome < 154 (DOMString JSON).
+*/
+async function getWebMcpTools() {
+	const modelContext = getModelContextApi();
+	if (!modelContext || typeof modelContext.getTools !== "function") return [];
+	try {
+		const rawTools = await modelContext.getTools();
+		if (!Array.isArray(rawTools)) return [];
+		return rawTools.map((tool) => ({
+			name: tool.name,
+			...tool.description ? { description: tool.description } : {},
+			inputSchema: parseWebMcpInputSchema(tool.inputSchema),
+			...tool.annotations ? { annotations: tool.annotations } : {},
+			...tool.execute ? { execute: tool.execute } : {}
+		}));
+	} catch (err) {
+		console.warn("Failed to retrieve WebMCP tools via getTools():", err);
+		return [];
+	}
+}
+/**
+* Gracefully execute a WebMCP tool on a ModelContext instance with backwards compatibility.
+*
+* Starting in Chrome 155.0.8052.0 (PR #246, PR #251), `document.modelContext.executeTool()`
+* accepts an optional JavaScript object directly instead of a JSON DOMString.
+* In Chrome < 155 and earlier polyfills, `executeTool()` required a stringified JSON arguments string.
+*
+* This function practices graceful degradation:
+* 1. Prepares both an `inputObject` (for Chrome 155+) and an `inputStr` (for Chrome < 155 & polyfills).
+* 2. Attempts to execute `executeTool(tool, inputObject, options)` first.
+* 3. Catches errors starting with "Failed to parse input" (or TypeErrors from WebIDL DOMString checks)
+*    and retries transparently with `JSON.stringify(inputObject)`.
+* 4. Re-throws any unrelated execution errors.
+*/
+async function executeWebMcpTool(modelContext, tool, input, options) {
+	if (!modelContext || typeof modelContext.executeTool !== "function") throw new Error("ModelContext executeTool is not available");
+	let inputObject;
+	let inputStr;
+	if (typeof input === "string") {
+		inputStr = input;
+		try {
+			const parsed = JSON.parse(input);
+			inputObject = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+		} catch {
+			inputObject = {};
+		}
+	} else if (input && typeof input === "object" && !Array.isArray(input)) {
+		inputObject = input;
+		try {
+			inputStr = JSON.stringify(input);
+		} catch {
+			inputStr = "{}";
+		}
+	} else {
+		inputObject = {};
+		inputStr = "{}";
+	}
+	try {
+		return await modelContext.executeTool(tool, inputObject, options);
+	} catch (err) {
+		const isParseError = typeof err?.message === "string" && err.message.startsWith("Failed to parse input");
+		const isTypeError = err instanceof TypeError;
+		if (isParseError || isTypeError) return await modelContext.executeTool(tool, inputStr, options);
+		throw err;
+	}
+}
+/**
+* Consequential tools that perform high-stakes, irreversible, or external real-world actions
+* (such as deleting data, executing arbitrary system commands, or transmitting live communications).
+* Signals consuming agents to require explicit user confirmation prior to execution (Chrome 154.0.8017.0+).
+*/
+const CONSEQUENTIAL_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"bash",
+	"clear_chat",
+	"delete_file",
+	"delete_task",
+	"email_send_message",
+	"git_delete_branch",
+	"git_delete_repo",
+	"git_push",
+	"git_reset"
+]);
+/**
+* Read-only tools that query information without mutating state.
+*/
+const READ_ONLY_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"ask_user",
+	"detect_language",
+	"diff_files",
+	"email_read_messages",
+	"fetch_url",
+	"get_current_time",
+	"git_branches",
+	"git_diff",
+	"git_list_repos",
+	"git_log",
+	"git_read_file_at_ref",
+	"git_show",
+	"git_status",
+	"list_components",
+	"list_files",
+	"list_room_members",
+	"list_tasks",
+	"list_tool_profiles",
+	"proofread_text",
+	"read_file",
+	"remote_mcp_list_tools",
+	"rewrite_text",
+	"search_files",
+	"summarize_text",
+	"translate_text",
+	"web_search",
+	"write_text"
+]);
+/**
+* Resolve annotations for a WebMCP tool registration.
+* Allows custom annotations (from declarative or customized tool definitions)
+* to override defaults.
+*/
+function resolveWebMcpToolAnnotations(toolName, customAnnotations) {
+	const isConsequential = CONSEQUENTIAL_TOOL_NAMES.has(toolName);
+	return {
+		readOnlyHint: !isConsequential && READ_ONLY_TOOL_NAMES.has(toolName),
+		consequentialHint: isConsequential,
+		untrustedContentHint: true,
+		...customAnnotations || {}
+	};
+}
+/**
+* Register ShadowClaw tools with the WebMCP ModelContext API.
+*
+* Both the `@mcp-b/webmcp-polyfill` and Chrome's native API support
+* `registerTool(tool, { signal })`. We always use AbortController signals so
+* that unregistration works identically regardless of which implementation is
+* actually active.
+*
+* Key correctness detail: `initializeWebMCPPolyfill()` is a no-op when
+* Chrome's native `document.modelContext` already exists — it does NOT
+* override the native API. In that situation we are talking to the native
+* Chrome API even in "polyfill" mode. The native Chrome API only supports
+* signal-based unregistration, so using AbortController signals everywhere
+* prevents "Duplicate tool name" errors when tools are re-configured.
+*/
+async function registerWebMcpTools(agentWorker, _emit, groupId = DEFAULT_GROUP_ID, tools) {
+	const activeTools = Array.isArray(tools) ? tools : TOOL_DEFINITIONS;
+	if (activeTools.length === 0) return true;
+	const modelContext = getModelContextApi();
+	if (!modelContext) return false;
+	for (const def of activeTools) {
+		if (registeredToolNames.has(def.name)) continue;
+		const controller = new AbortController();
+		registeredToolControllers.set(def.name, controller);
+		registeredToolNames.add(def.name);
+		try {
+			const toolDef = {
+				name: def.name,
+				description: def.description,
+				inputSchema: parseWebMcpInputSchema(def.input_schema),
+				annotations: resolveWebMcpToolAnnotations(def.name, def.annotations),
+				execute: (input, context) => {
+					if (!agentWorker) throw new Error("Cannot execute tool: agent worker is not ready");
+					const signal = extractAbortSignal(context);
+					if (signal?.aborted) return Promise.reject(/* @__PURE__ */ new Error("Tool execution aborted"));
+					return new Promise((resolve, reject) => {
+						const callId = Date.now().toString(36) + Math.random().toString(36).slice(2);
+						let timeout = null;
+						const cleanup = () => {
+							if (timeout !== null) {
+								clearTimeout(timeout);
+								timeout = null;
+							}
+							agentWorker?.removeEventListener("message", handler);
+							if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+						};
+						const onAbort = () => {
+							cleanup();
+							reject(/* @__PURE__ */ new Error("Tool execution aborted"));
+						};
+						if (signal) signal.addEventListener("abort", onAbort, { once: true });
+						timeout = setTimeout(() => {
+							cleanup();
+							reject(/* @__PURE__ */ new Error("Timeout waiting for tool execution"));
+						}, 6e5);
+						const handler = (event) => {
+							const data = event.data;
+							if (data && data.type === "execute-tool-result" && data.callId === callId) {
+								cleanup();
+								if (data.error) reject(new Error(data.error));
+								else resolve(data.result);
+							}
+						};
+						agentWorker.addEventListener("message", handler);
+						agentWorker.postMessage({
+							type: "execute-tool",
+							callId,
+							payload: {
+								name: def.name,
+								input: input || {},
+								groupId
+							}
+						});
+					});
+				}
+			};
+			await modelContext.registerTool(toolDef, { signal: controller.signal });
+			await new Promise((resolve) => setTimeout(resolve, 0));
+		} catch (err) {
+			registeredToolControllers.delete(def.name);
+			registeredToolNames.delete(def.name);
+			if (!(err instanceof Error && (err.message.includes("already registered") || err.message.includes("Duplicate tool name")))) {
+				console.error(`Failed to register tool ${def.name}:`, err);
+				throw err;
+			}
+		}
+	}
+	return true;
+}
+/**
+* Unregister previously registered ShadowClaw WebMCP tools.
+*
+* Aborts every AbortController associated with a registered tool. This works
+* for both the polyfill (which listens for the `abort` event on the signal it
+* was given) and Chrome's native API (which also uses signal-based lifecycle).
+* The deprecated `unregisterTool(name)` is intentionally NOT called here
+* because it is absent from the native Chrome API and causes silent failures
+* that prevent proper cleanup.
+*/
+function unregisterWebMcpTools() {
+	for (const controller of registeredToolControllers.values()) try {
+		controller.abort();
+	} catch {}
+	registeredToolControllers.clear();
+	registeredToolNames.clear();
+}
+
+//#endregion
+export { webmcp_exports as a, unregisterWebMcpTools as i, registerWebMcpTools as n, setWebMcpMode as r, getWebMcpMode as t };
+//# sourceMappingURL=webmcp-BVR2lBVo.js.map