eslint-plugin-webmcp 0.0.0

package/dist/index.mjs

@@ -0,0 +1,1251 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { Ajv2020 } from "ajv/dist/2020.js";
+//#region package.json
+var name = "eslint-plugin-webmcp";
+var version = "0.0.0";
+//#endregion
+//#region src/profiles.ts
+const DEFAULT_TARGET = "draft-2026-09-04";
+const TOOL_PROPERTIES = [
+	"name",
+	"title",
+	"description",
+	"inputSchema",
+	"execute",
+	"annotations"
+];
+const ANNOTATIONS = [
+	"readOnlyHint",
+	"untrustedContentHint",
+	"consequentialHint"
+];
+const API_OPTIONS = {
+	registerTool: ["exposedTo", "signal"],
+	getTools: ["fromOrigins"],
+	executeTool: ["signal"]
+};
+const API_METHODS = [
+	"registerTool",
+	"getTools",
+	"executeTool"
+];
+const LEGACY_METHODS = [
+	"provideContext",
+	"clearContext",
+	"unregisterTool"
+];
+function resolveTarget(target) {
+	if (target === void 0) return DEFAULT_TARGET;
+	if (target === "draft-2026-09-04" || target === "chrome-2026-09-01") return target;
+	throw new Error("webmcp: target must be \"draft-2026-09-04\" or \"chrome-2026-09-01\".");
+}
+function isWrapper(wrapper) {
+	return typeof wrapper === "object" && wrapper !== null && "module" in wrapper && typeof wrapper.module === "string" && wrapper.module.length > 0 && "imported" in wrapper && typeof wrapper.imported === "string" && wrapper.imported.length > 0 && "toolArgument" in wrapper && typeof wrapper.toolArgument === "number" && Number.isSafeInteger(wrapper.toolArgument) && wrapper.toolArgument >= 0 && "kind" in wrapper && wrapper.kind === "definition";
+}
+function resolveSettings(settings) {
+	if (settings === void 0) return {
+		target: DEFAULT_TARGET,
+		wrappers: []
+	};
+	if (typeof settings !== "object" || settings === null || Array.isArray(settings)) throw new Error("webmcp: settings.webmcp must be an object.");
+	const target = resolveTarget("target" in settings ? settings.target : void 0);
+	const wrappers = "wrappers" in settings ? settings.wrappers : [];
+	if (!Array.isArray(wrappers) || !wrappers.every((wrapper) => isWrapper(wrapper))) throw new Error("webmcp: wrappers must contain module, imported, toolArgument and kind: \"definition\".");
+	return {
+		target,
+		wrappers
+	};
+}
+//#endregion
+//#region src/analysis/bindings.ts
+const MAX_DEPTH$1 = 20;
+function unwrap(node) {
+	switch (node.type) {
+		case "TSAsExpression":
+		case "TSTypeAssertion":
+		case "TSSatisfiesExpression":
+		case "TSNonNullExpression":
+		case "TSInstantiationExpression":
+		case "ChainExpression": return unwrap(node.expression);
+		default: return node;
+	}
+}
+function getKey(node) {
+	const key = node.type === "MemberExpression" ? node.property : node.key;
+	if (!node.computed && key.type === "Identifier") return key.name;
+	const unwrapped = unwrap(key);
+	if (unwrapped.type === "Literal" && (typeof unwrapped.value === "string" || typeof unwrapped.value === "number")) return String(unwrapped.value);
+	if (unwrapped.type === "TemplateLiteral" && unwrapped.expressions.length === 0) return unwrapped.quasis[0]?.value.cooked ?? void 0;
+}
+function getVariable(source, node) {
+	let scope = source.getScope(node);
+	while (scope) {
+		const variable = scope.set.get(node.name);
+		if (variable) return variable;
+		scope = scope.upper;
+	}
+}
+function isGlobal(source, node, name) {
+	const expression = unwrap(node);
+	if (expression.type !== "Identifier" || expression.name !== name) return false;
+	const variable = getVariable(source, expression);
+	return !variable || variable.defs.length === 0;
+}
+function getExecutionOwner(node) {
+	let current = node;
+	while (current.parent) {
+		current = current.parent;
+		if (current.type === "Program" || current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") return current;
+	}
+	return current;
+}
+function hasSafeReceiverReferences(source, variable, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(variable) || seen.size > MAX_DEPTH$1 || variable.references.some((reference) => reference.isWrite() && !reference.init)) return false;
+	seen.add(variable);
+	return variable.references.filter((reference) => reference.isRead()).every((reference) => {
+		const { parent } = reference.identifier;
+		if (parent.type === "MemberExpression" && parent.object === reference.identifier) {
+			const use = parent.parent;
+			return use.type !== "AssignmentExpression" && use.type !== "UpdateExpression" && !(use.type === "UnaryExpression" && use.operator === "delete");
+		}
+		if (parent.type === "VariableDeclarator" && parent.parent.type === "VariableDeclaration" && parent.parent.kind === "const") {
+			if (parent.id.type === "ObjectPattern") return true;
+			if (parent.id.type === "Identifier") {
+				const alias = getVariable(source, parent.id);
+				return alias !== void 0 && hasSafeReceiverReferences(source, alias, seen);
+			}
+		}
+		return false;
+	});
+}
+/**
+* Only immutable bindings are followed. Objects additionally need a single read,
+* preventing writes, aliases, exports and escapes from masquerading as constants.
+*
+* @param source The parser-provided source and scope manager
+* @param node The identifier at its use site
+* @param mode Whether to enforce value ownership or native method/receiver constraints
+* @returns The initializer only when its binding is safe to follow
+*/
+function getConstInitializer(source, node, mode = "value") {
+	const variable = getVariable(source, node);
+	if (!variable || variable.defs.length !== 1 || variable.references.some((reference) => reference.isWrite() && !reference.init)) return;
+	const [definition] = variable.defs;
+	if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.id.type !== "Identifier" || !definition.node.init) return;
+	if (definition.parent.parent.type === "ExportNamedDeclaration" || definition.node.range[1] > node.range[0] || getExecutionOwner(definition.node) !== getExecutionOwner(node)) return;
+	const initializer = unwrap(definition.node.init);
+	const reads = variable.references.filter((reference) => reference.isRead());
+	if (mode === "receiver") {
+		if (!hasSafeReceiverReferences(source, variable)) return;
+	} else if (mode === "value" && initializer.type !== "Literal" && initializer.type !== "TemplateLiteral" && initializer.type !== "UnaryExpression" && (reads.length !== 1 || reads[0]?.identifier !== node)) return;
+	return initializer;
+}
+//#endregion
+//#region src/analysis/static.ts
+const UNKNOWN = { kind: "unknown" };
+const MAX_DEPTH = 20;
+const MAX_NODES = 1e3;
+function resolveExpression(source, node, depth = 0) {
+	const expression = unwrap(node);
+	if (depth < MAX_DEPTH && expression.type === "Identifier") {
+		const initializer = getConstInitializer(source, expression);
+		if (initializer) return resolveExpression(source, initializer, depth + 1);
+	}
+	return expression;
+}
+function readObject(source, node, depth = 0) {
+	if (!node || depth > MAX_DEPTH) return;
+	const expression = resolveExpression(source, node);
+	if (expression.type !== "ObjectExpression" || expression.properties.length > MAX_NODES) return;
+	const properties = /* @__PURE__ */ new Map();
+	let complete = true;
+	for (const property of expression.properties) if (property.type === "SpreadElement") {
+		const spread = readObject(source, property.argument, depth + 1);
+		if (!spread?.complete) {
+			properties.clear();
+			complete = false;
+		}
+		for (const [name, field] of spread?.properties ?? []) properties.set(name, field);
+	} else {
+		const key = getKey(property);
+		if (property.kind !== "init" || key === "__proto__") return;
+		if (key === void 0) {
+			properties.clear();
+			complete = false;
+		} else properties.set(key, property);
+	}
+	return {
+		node: expression,
+		properties,
+		complete
+	};
+}
+function getField(object, name) {
+	const property = object?.properties.get(name);
+	if (property) return {
+		kind: "known",
+		node: property.value
+	};
+	return { kind: object?.complete ? "missing" : "unknown" };
+}
+function readValue(source, node, depth = 0, budget) {
+	const remaining = budget ?? { remaining: MAX_NODES };
+	if (!node || depth > MAX_DEPTH || remaining.remaining-- <= 0) return UNKNOWN;
+	const expression = resolveExpression(source, node);
+	if (expression.type === "Literal") {
+		if ("regex" in expression) return UNKNOWN;
+		return {
+			kind: "known",
+			value: expression.value
+		};
+	}
+	if (expression.type === "Identifier" && isGlobal(source, expression, "undefined")) return {
+		kind: "known",
+		value: void 0
+	};
+	if (expression.type === "TemplateLiteral" && expression.expressions.length === 0) {
+		const value = expression.quasis[0]?.value.cooked;
+		return value === null || value === void 0 ? UNKNOWN : {
+			kind: "known",
+			value
+		};
+	}
+	if (expression.type === "UnaryExpression") {
+		const argument = readValue(source, expression.argument, depth + 1, remaining);
+		if (argument.kind === "known" && expression.operator === "void") return {
+			kind: "known",
+			value: void 0
+		};
+		if (argument.kind === "known" && typeof argument.value === "number" && (expression.operator === "-" || expression.operator === "+")) return {
+			kind: "known",
+			value: expression.operator === "-" ? -argument.value : argument.value
+		};
+	}
+	if (expression.type === "ArrayExpression") {
+		const values = [];
+		for (const element of expression.elements) {
+			const fact = element ? readValue(source, element, depth + 1, remaining) : {
+				kind: "known",
+				value: void 0
+			};
+			if (fact.kind === "unknown") return UNKNOWN;
+			values.push(fact.value);
+		}
+		return {
+			kind: "known",
+			value: values
+		};
+	}
+	const object = readObject(source, expression);
+	if (object?.complete && !object.properties.has("toJSON")) {
+		const entries = [];
+		for (const [name, property] of object.properties) {
+			const fact = readValue(source, property.value, depth + 1, remaining);
+			if (fact.kind === "unknown") return UNKNOWN;
+			entries.push([name, fact.value]);
+		}
+		return {
+			kind: "known",
+			value: Object.fromEntries(entries)
+		};
+	}
+	return UNKNOWN;
+}
+function readString(source, node) {
+	const fact = readValue(source, node);
+	return fact.kind === "known" && typeof fact.value === "string" ? fact.value : void 0;
+}
+function isDefinitelyNonCallable(source, node) {
+	const expression = resolveExpression(source, node);
+	return readValue(source, expression).kind === "known" || expression.type === "ObjectExpression" || expression.type === "ArrayExpression" || expression.type === "ClassExpression" || expression.type === "Literal";
+}
+//#endregion
+//#region src/analysis/api.ts
+var ApiAnalyzer = class {
+	settings;
+	source;
+	calls = /* @__PURE__ */ new WeakMap();
+	constructor(source, settings) {
+		this.source = source;
+		this.settings = resolveSettings(settings);
+	}
+	getReceiver(node, depth = 0) {
+		if (depth > 20) return;
+		const expression = unwrap(node);
+		if (expression.type === "Identifier") {
+			const initializer = getConstInitializer(this.source, expression, "receiver");
+			return initializer ? this.getReceiver(initializer, depth + 1) : void 0;
+		}
+		if (expression.type !== "MemberExpression" || getKey(expression) !== "modelContext") return;
+		const owner = unwrap(expression.object);
+		for (const name of ["document", "navigator"]) {
+			if (isGlobal(this.source, owner, name)) return name;
+			if (owner.type === "MemberExpression" && getKey(owner) === name && (isGlobal(this.source, owner.object, "window") || isGlobal(this.source, owner.object, "globalThis"))) return name;
+		}
+	}
+	getMethod(node, depth = 0) {
+		if (depth > 20) return;
+		const expression = unwrap(node);
+		if (expression.type === "MemberExpression") {
+			const receiver = this.getReceiver(expression.object);
+			const method = getKey(expression);
+			return receiver && method ? {
+				receiver,
+				method,
+				bound: true
+			} : void 0;
+		}
+		if (expression.type === "SequenceExpression") {
+			const last = expression.expressions.at(-1);
+			const method = last ? this.getMethod(last, depth + 1) : void 0;
+			return method ? {
+				...method,
+				bound: false
+			} : void 0;
+		}
+		if (expression.type !== "Identifier") return;
+		const initializer = getConstInitializer(this.source, expression, "method");
+		if (initializer) {
+			const method = this.getMethod(initializer, depth + 1);
+			return method ? {
+				...method,
+				bound: false
+			} : void 0;
+		}
+		const variable = getVariable(this.source, expression);
+		if (variable?.defs.length !== 1 || variable.references.some((reference) => reference.isWrite() && !reference.init)) return;
+		const [definition] = variable.defs;
+		if (definition?.type !== "Variable" || definition.parent.kind !== "const" || !definition.node.init || definition.node.id.type !== "ObjectPattern" || definition.node.range[1] > node.range[0]) return;
+		const receiver = this.getReceiver(definition.node.init);
+		if (!receiver) return;
+		for (const property of definition.node.id.properties) if (property.type === "Property" && property.value.type === "Identifier" && property.value.name === expression.name) {
+			const method = getKey(property);
+			return method ? {
+				receiver,
+				method,
+				bound: false
+			} : void 0;
+		}
+	}
+	getWrapper(node) {
+		const callee = unwrap(node.callee);
+		if (callee.type !== "Identifier") return;
+		const definition = getVariable(this.source, callee)?.defs[0];
+		if (definition?.type !== "ImportBinding" || definition.node.type !== "ImportSpecifier" || definition.parent.type !== "ImportDeclaration" || definition.parent.importKind === "type" || definition.node.importKind === "type") return;
+		const imported = definition.node.imported.type === "Identifier" ? definition.node.imported.name : definition.node.imported.value;
+		const moduleName = definition.parent.source.value;
+		return this.settings.wrappers.find((wrapper) => wrapper.module === moduleName && wrapper.imported === imported)?.toolArgument;
+	}
+	identify(node) {
+		const cached = this.calls.get(node);
+		if (cached !== void 0) return cached ?? void 0;
+		const method = this.getMethod(node.callee);
+		const wrapperIndex = method ? void 0 : this.getWrapper(node);
+		if (!method && wrapperIndex === void 0) {
+			this.calls.set(node, null);
+			return;
+		}
+		const descriptor = method ?? {
+			method: "definition",
+			receiver: "wrapper",
+			bound: true
+		};
+		const argument = (index) => node.arguments.slice(0, index + 1).some((entry) => entry.type === "SpreadElement") ? void 0 : node.arguments[index];
+		const toolIndex = wrapperIndex ?? (descriptor.method === "registerTool" || descriptor.method === "executeTool" ? 0 : -1);
+		const toolNode = toolIndex >= 0 ? argument(toolIndex) : void 0;
+		const optionIndex = {
+			registerTool: 1,
+			getTools: 0,
+			executeTool: 2
+		}[descriptor.method] ?? -1;
+		const result = {
+			...descriptor,
+			node,
+			toolNode,
+			tool: readObject(this.source, toolNode),
+			options: optionIndex >= 0 ? readObject(this.source, argument(optionIndex)) : void 0
+		};
+		this.calls.set(node, result);
+		return result;
+	}
+};
+const ANALYZERS = /* @__PURE__ */ new WeakMap();
+function getAnalyzer(source, settings) {
+	const resolved = resolveSettings(settings);
+	const key = JSON.stringify(resolved);
+	let analyzers = ANALYZERS.get(source);
+	if (!analyzers) {
+		analyzers = /* @__PURE__ */ new Map();
+		ANALYZERS.set(source, analyzers);
+	}
+	let analyzer = analyzers.get(key);
+	if (!analyzer) {
+		analyzer = new ApiAnalyzer(source, resolved);
+		analyzers.set(key, analyzer);
+	}
+	return analyzer;
+}
+function isDefinition(call) {
+	return call.bound && (call.receiver === "document" && call.method === "registerTool" || call.receiver === "wrapper");
+}
+function isNativeMethod(call) {
+	return call.receiver !== "wrapper" && (API_METHODS.includes(call.method) || LEGACY_METHODS.includes(call.method));
+}
+//#endregion
+//#region src/createRule.ts
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/ntnyq/eslint-plugin-webmcp/blob/main/docs/rules/${name}.md`);
+function createApiRule(definition) {
+	return createRule({
+		name: definition.name,
+		meta: {
+			type: definition.type ?? "problem",
+			docs: {
+				description: definition.description,
+				...definition.recommended ? { recommended: definition.recommended } : {},
+				...definition.strict ? { strict: definition.strict } : {}
+			},
+			schema: definition.schema ?? [],
+			messages: definition.messages
+		},
+		defaultOptions: definition.defaultOptions,
+		create(context, options) {
+			const analyzer = getAnalyzer(context.sourceCode, context.settings["webmcp"]);
+			return { CallExpression(node) {
+				const call = analyzer.identify(node);
+				if (call) definition.check(call, analyzer, context, options);
+			} };
+		}
+	});
+}
+function stringListOption(name) {
+	return [{
+		type: "object",
+		properties: { [name]: {
+			type: "array",
+			items: { type: "string" },
+			uniqueItems: true
+		} },
+		additionalProperties: false
+	}];
+}
+//#endregion
+//#region src/rules/apiOptions.ts
+function isCurrentCall(call) {
+	return call.receiver === "document" && call.bound && API_METHODS.includes(call.method);
+}
+function getOrigins(call) {
+	if (!isCurrentCall(call)) return;
+	const originOption = {
+		registerTool: "exposedTo",
+		getTools: "fromOrigins"
+	};
+	if (call.method !== "registerTool" && call.method !== "getTools") return;
+	return call.options?.properties.get(originOption[call.method])?.value;
+}
+function getOriginEntries(analyzer, node) {
+	const expression = resolveExpression(analyzer.source, node);
+	return expression.type === "ArrayExpression" ? expression.elements.filter((element) => element !== null && element.type !== "SpreadElement") : [];
+}
+function parseOrigin(value) {
+	try {
+		return new URL(value);
+	} catch {
+		return;
+	}
+}
+const requireApiArguments = createApiRule({
+	name: "require-api-arguments",
+	description: "Require mandatory WebMCP call arguments.",
+	recommended: "error",
+	defaultOptions: [],
+	messages: {
+		missing: "{{method}} requires a tool argument.",
+		input: "chrome-2026-09-01 requires a JSON text input argument for executeTool."
+	},
+	check(call, analyzer, context) {
+		if (isCurrentCall(call) && call.method !== "getTools" && call.node.arguments.length === 0) context.report({
+			node: call.node,
+			messageId: "missing",
+			data: { method: call.method }
+		});
+		else if (isCurrentCall(call) && call.method === "executeTool" && analyzer.settings.target === "chrome-2026-09-01" && call.node.arguments.length === 1 && call.node.arguments[0]?.type !== "SpreadElement") context.report({
+			node: call.node,
+			messageId: "input"
+		});
+	}
+});
+const noUnknownApiOptions = createApiRule({
+	name: "no-unknown-api-options",
+	description: "Catch unrecognized or misplaced API options.",
+	type: "suggestion",
+	strict: "warn",
+	defaultOptions: [{ allowOptions: [] }],
+	schema: stringListOption("allowOptions"),
+	messages: { unknown: "Option \"{{name}}\" is not declared for {{method}} in {{target}} and may be ignored." },
+	check(call, analyzer, context, [options]) {
+		if (!isCurrentCall(call)) return;
+		for (const [name, property] of call.options?.properties ?? []) if (!API_OPTIONS[call.method]?.includes(name) && !options.allowOptions.includes(name)) context.report({
+			node: property.key,
+			messageId: "unknown",
+			data: {
+				name,
+				method: call.method,
+				target: analyzer.settings.target
+			}
+		});
+	}
+});
+const validAbortSignal = createApiRule({
+	name: "valid-abort-signal",
+	description: "Reject values that are definitely not AbortSignals.",
+	recommended: "error",
+	defaultOptions: [],
+	messages: { invalid: "Pass an AbortSignal, such as controller.signal, as the signal option." },
+	check(call, analyzer, context) {
+		const node = isCurrentCall(call) && call.method !== "getTools" ? call.options?.properties.get("signal")?.value : void 0;
+		if (!node) return;
+		const expression = resolveExpression(analyzer.source, node);
+		const fact = readValue(analyzer.source, expression);
+		if (fact.kind === "known" && fact.value !== void 0 || expression.type === "ObjectExpression" || expression.type === "ArrayExpression" || expression.type === "ArrowFunctionExpression" || expression.type === "FunctionExpression" || expression.type === "NewExpression" && isGlobal(analyzer.source, expression.callee, "AbortController")) context.report({
+			node,
+			messageId: "invalid"
+		});
+	}
+});
+const validOriginList = createApiRule({
+	name: "valid-origin-list",
+	description: "Validate known origin lists and absolute URL strings.",
+	recommended: "error",
+	defaultOptions: [],
+	messages: {
+		list: "The origin list must be an iterable object of absolute URL strings.",
+		url: "\"{{origin}}\" cannot be parsed as an absolute origin URL."
+	},
+	check(call, analyzer, context) {
+		const node = getOrigins(call);
+		if (!node) return;
+		const fact = readValue(analyzer.source, node);
+		if (fact.kind === "known" && fact.value !== void 0 && (fact.value === null || typeof fact.value !== "object")) {
+			context.report({
+				node,
+				messageId: "list"
+			});
+			return;
+		}
+		for (const entry of getOriginEntries(analyzer, node)) {
+			const origin = readString(analyzer.source, entry);
+			if (origin !== void 0 && !parseOrigin(origin)) context.report({
+				node: entry,
+				messageId: "url",
+				data: { origin }
+			});
+		}
+	}
+});
+const preferCanonicalOrigin = createApiRule({
+	name: "prefer-canonical-origin",
+	description: "Make origin-wide exposure explicit in URL options.",
+	type: "suggestion",
+	strict: "warn",
+	defaultOptions: [],
+	messages: { canonical: "This option matches the entire origin; credentials, paths, queries and fragments do not narrow its scope." },
+	check(call, analyzer, context) {
+		const node = getOrigins(call);
+		if (!node) return;
+		for (const entry of getOriginEntries(analyzer, node)) {
+			const origin = readString(analyzer.source, entry);
+			const url = origin === void 0 ? void 0 : parseOrigin(origin);
+			if (url && url.origin !== "null" && (url.username || url.password || url.pathname !== "/" && url.pathname !== "" || url.search || url.hash)) context.report({
+				node: entry,
+				messageId: "canonical"
+			});
+		}
+	}
+});
+const noPreabortedRegistrationSignal = createApiRule({
+	name: "no-preaborted-registration-signal",
+	description: "Avoid registering with an already-aborted signal.",
+	type: "suggestion",
+	strict: "warn",
+	defaultOptions: [],
+	messages: { aborted: "AbortSignal.abort() produces an already-aborted signal; this tool will not be registered." },
+	check(call, analyzer, context) {
+		const node = isCurrentCall(call) && call.method === "registerTool" ? call.options?.properties.get("signal")?.value : void 0;
+		if (!node) return;
+		const expression = resolveExpression(analyzer.source, node);
+		if (expression.type !== "CallExpression") return;
+		const callee = unwrap(expression.callee);
+		if (callee.type === "MemberExpression" && getKey(callee) === "abort" && isGlobal(analyzer.source, callee.object, "AbortSignal")) context.report({
+			node,
+			messageId: "aborted"
+		});
+	}
+});
+//#endregion
+//#region src/rules/consumer.ts
+const validRegisteredTool = createApiRule({
+	name: "valid-registered-tool",
+	description: "Validate statically known RegisteredTool dictionaries.",
+	recommended: "error",
+	defaultOptions: [],
+	messages: {
+		invalid: "executeTool expects a RegisteredTool dictionary, not a tool name or primitive.",
+		missing: "RegisteredTool is missing required property \"{{property}}\"."
+	},
+	check(call, analyzer, context) {
+		if (!isCurrentCall(call) || call.method !== "executeTool" || !call.toolNode) return;
+		const fact = readValue(analyzer.source, call.toolNode);
+		if (fact.kind === "known" && (fact.value === null || typeof fact.value !== "object")) {
+			context.report({
+				node: call.toolNode,
+				messageId: "invalid"
+			});
+			return;
+		}
+		for (const property of [
+			"name",
+			"description",
+			"window",
+			"origin"
+		]) {
+			const field = getField(call.tool, property);
+			const value = field.kind === "known" ? readValue(analyzer.source, field.node) : void 0;
+			if (field.kind === "missing" || value?.kind === "known" && value.value === void 0) context.report({
+				node: field.kind === "known" ? field.node : call.toolNode,
+				messageId: "missing",
+				data: { property }
+			});
+		}
+	}
+});
+const noUnknownModelContextEvents = createApiRule({
+	name: "no-unknown-model-context-events",
+	description: "Catch unrecognized native ModelContext event names.",
+	type: "suggestion",
+	strict: "warn",
+	defaultOptions: [{ allowEvents: [] }],
+	schema: stringListOption("allowEvents"),
+	messages: { unknown: "{{target}} declares the native event \"toolchange\", not \"{{event}}\". Allow intentional custom events explicitly." },
+	check(call, analyzer, context, [options]) {
+		if (call.receiver !== "document" || !call.bound || !["addEventListener", "removeEventListener"].includes(call.method)) return;
+		const [node] = call.node.arguments;
+		const event = readString(analyzer.source, node);
+		if (node && event !== void 0 && event !== "toolchange" && !options.allowEvents.includes(event)) context.report({
+			node,
+			messageId: "unknown",
+			data: {
+				event,
+				target: analyzer.settings.target
+			}
+		});
+	}
+});
+//#endregion
+//#region src/rules/core.ts
+function isValidToolName(name) {
+	return name.length > 0 && name.length <= 128 && !/[^A-Za-z0-9_.-]/u.test(name);
+}
+const requireToolProperties = createApiRule({
+	name: "require-tool-properties",
+	description: "Require the mandatory tool definition fields.",
+	recommended: "error",
+	defaultOptions: [],
+	messages: {
+		missing: "Tool definition is missing required property \"{{property}}\".",
+		invalid: "A tool definition must be a dictionary with name, description and execute."
+	},
+	check(call, analyzer, context) {
+		if (!isDefinition(call) || !call.toolNode) return;
+		const fact = readValue(analyzer.source, call.toolNode);
+		if (fact.kind === "known" && (fact.value === null || typeof fact.value !== "object")) {
+			context.report({
+				node: call.toolNode,
+				messageId: "invalid"
+			});
+			return;
+		}
+		for (const property of [
+			"name",
+			"description",
+			"execute"
+		]) {
+			const field = getField(call.tool, property);
+			const value = field.kind === "known" ? readValue(analyzer.source, field.node) : void 0;
+			if (field.kind === "missing" || value?.kind === "known" && value.value === void 0) context.report({
+				node: field.kind === "known" ? field.node : call.toolNode,
+				messageId: "missing",
+				data: { property }
+			});
+		}
+	}
+});
+const validToolName = createApiRule({
+	name: "valid-tool-name",
+	description: "Validate static tool names against the target API.",
+	recommended: "error",
+	defaultOptions: [],
+	messages: { invalid: "Tool names must contain 1–128 ASCII letters, digits, underscores, hyphens or dots." },
+	check(call, analyzer, context) {
+		if (!isDefinition(call)) return;
+		const node = call.tool?.properties.get("name")?.value;
+		const name = readString(analyzer.source, node);
+		if (node && name !== void 0 && !isValidToolName(name)) context.report({
+			node,
+			messageId: "invalid"
+		});
+	}
+});
+const validExecute = createApiRule({
+	name: "valid-execute",
+	description: "Reject definitely non-callable execute values.",
+	recommended: "error",
+	defaultOptions: [],
+	messages: { invalid: "The execute property must be callable; an async keyword is not required." },
+	check(call, analyzer, context) {
+		const node = isDefinition(call) ? call.tool?.properties.get("execute")?.value : void 0;
+		const value = readValue(analyzer.source, node);
+		if (node && !(value.kind === "known" && value.value === void 0) && isDefinitelyNonCallable(analyzer.source, node)) context.report({
+			node,
+			messageId: "invalid"
+		});
+	}
+});
+const noEmptyDescription = createApiRule({
+	name: "no-empty-description",
+	description: "Require nonempty, non-whitespace tool descriptions.",
+	type: "suggestion",
+	recommended: "warn",
+	defaultOptions: [],
+	messages: { empty: "Describe what this tool does; its description is empty or whitespace-only." },
+	check(call, analyzer, context) {
+		const node = isDefinition(call) ? call.tool?.properties.get("description")?.value : void 0;
+		const description = readString(analyzer.source, node);
+		if (node && description !== void 0 && description.trim().length === 0) context.report({
+			node,
+			messageId: "empty"
+		});
+	}
+});
+const noUnsupportedApi = createApiRule({
+	name: "no-unsupported-api",
+	description: "Report legacy WebMCP entry points and removed methods.",
+	recommended: "error",
+	defaultOptions: [],
+	messages: {
+		legacy: "{{target}} uses document.modelContext; migrate the entry point and registration lifecycle together.",
+		removed: "{{method}} is not supported by {{target}}. Registration lifetime is controlled by options.signal."
+	},
+	check(call, analyzer, context) {
+		if (!isNativeMethod(call)) return;
+		if (call.receiver === "navigator") context.report({
+			node: call.node.callee,
+			messageId: "legacy",
+			data: { target: analyzer.settings.target }
+		});
+		else if (LEGACY_METHODS.includes(call.method)) context.report({
+			node: call.node.callee,
+			messageId: "removed",
+			data: {
+				target: analyzer.settings.target,
+				method: call.method
+			}
+		});
+	}
+});
+const noUnboundApiCall = createApiRule({
+	name: "no-unbound-api-call",
+	description: "Keep the native ModelContext receiver when calling its methods.",
+	recommended: "error",
+	defaultOptions: [],
+	messages: { unbound: "Call {{method}} on its ModelContext receiver, or explicitly bind the method to that receiver." },
+	check(call, _analyzer, context) {
+		if (isNativeMethod(call) && !call.bound) context.report({
+			node: call.node.callee,
+			messageId: "unbound",
+			data: { method: call.method }
+		});
+	}
+});
+//#endregion
+//#region src/rules/metadata.ts
+const noUnknownToolProperties = createApiRule({
+	name: "no-unknown-tool-properties",
+	description: "Catch unrecognized tool definition properties.",
+	type: "suggestion",
+	strict: "warn",
+	defaultOptions: [{ allowProperties: [] }],
+	schema: stringListOption("allowProperties"),
+	messages: { unknown: "Tool property \"{{name}}\" is not declared by {{target}} and may be ignored." },
+	check(call, analyzer, context, [options]) {
+		if (!isDefinition(call)) return;
+		for (const [name, property] of call.tool?.properties ?? []) if (!TOOL_PROPERTIES.includes(name) && !options.allowProperties.includes(name)) context.report({
+			node: property.key,
+			messageId: "unknown",
+			data: {
+				name,
+				target: analyzer.settings.target
+			}
+		});
+	}
+});
+const validAnnotations = createApiRule({
+	name: "valid-annotations",
+	description: "Use supported hint names and explicit boolean values.",
+	type: "suggestion",
+	strict: "warn",
+	defaultOptions: [],
+	messages: {
+		unknown: "Annotation \"{{name}}\" is not declared by {{target}} and may be ignored.",
+		boolean: "Write an explicit boolean for \"{{name}}\"; Web IDL coerces other values by truthiness.",
+		dictionary: "Use an annotations dictionary with explicit boolean hint values."
+	},
+	check(call, analyzer, context) {
+		const node = isDefinition(call) ? call.tool?.properties.get("annotations")?.value : void 0;
+		if (!node) return;
+		const fact = readValue(analyzer.source, node);
+		if (fact.kind === "known" && fact.value !== null && fact.value !== void 0 && typeof fact.value !== "object") {
+			context.report({
+				node,
+				messageId: "dictionary"
+			});
+			return;
+		}
+		for (const [name, property] of readObject(analyzer.source, node)?.properties ?? []) if (ANNOTATIONS.includes(name)) {
+			const value = readValue(analyzer.source, property.value);
+			if (value.kind === "known" && value.value !== void 0 && typeof value.value !== "boolean") context.report({
+				node: property.value,
+				messageId: "boolean",
+				data: { name }
+			});
+		} else context.report({
+			node: property.key,
+			messageId: "unknown",
+			data: {
+				name,
+				target: analyzer.settings.target
+			}
+		});
+	}
+});
+//#endregion
+//#region src/rules/schema.ts
+function containsBigInt(value) {
+	if (typeof value === "bigint") return true;
+	return typeof value === "object" && value !== null && Object.values(value).some((entry) => containsBigInt(entry));
+}
+let validator = null;
+function getValidator() {
+	validator ??= new Ajv2020({
+		strict: false,
+		allErrors: false,
+		validateFormats: false
+	});
+	return validator;
+}
+/**
+* Visit schema keywords only, never enum/default/example data or remote references.
+*
+* @param source The source containing schema expressions
+* @param node The root schema expression
+* @param visit Called for each known parameter definition
+* @param depth Current recursion depth
+* @param budget Shared remaining node budget
+*/
+function visitParameters(source, node, visit, depth = 0, budget) {
+	const remaining = budget ?? { remaining: 1e3 };
+	if (depth > 20 || remaining.remaining-- <= 0) return;
+	const object = readObject(source, node);
+	if (!object) return;
+	for (const [key, property] of object.properties) if ([
+		"properties",
+		"$defs",
+		"patternProperties",
+		"dependentSchemas"
+	].includes(key)) for (const [name, child] of readObject(source, property.value)?.properties ?? []) {
+		if (key === "properties") visit(name, child.value);
+		visitParameters(source, child.value, visit, depth + 1, remaining);
+	}
+	else if ([
+		"items",
+		"additionalProperties",
+		"contains",
+		"not",
+		"if",
+		"then",
+		"else",
+		"propertyNames",
+		"unevaluatedProperties",
+		"unevaluatedItems"
+	].includes(key)) visitParameters(source, property.value, visit, depth + 1, remaining);
+	else if ([
+		"allOf",
+		"anyOf",
+		"oneOf",
+		"prefixItems"
+	].includes(key)) {
+		const array = resolveExpression(source, property.value);
+		const elements = array.type === "ArrayExpression" ? array.elements : [];
+		for (const child of elements) if (child && child.type !== "SpreadElement") visitParameters(source, child, visit, depth + 1, remaining);
+	}
+}
+const validInputSchema = createApiRule({
+	name: "valid-input-schema",
+	description: "Check platform schema boundaries and optionally JSON Schema 2020-12 syntax.",
+	recommended: "error",
+	defaultOptions: [{ mode: "platform" }],
+	schema: [{ oneOf: [{
+		type: "object",
+		properties: { mode: {
+			type: "string",
+			enum: ["platform"]
+		} },
+		required: ["mode"],
+		additionalProperties: false
+	}, {
+		type: "object",
+		properties: {
+			mode: {
+				type: "string",
+				enum: ["json-schema"]
+			},
+			dialect: {
+				type: "string",
+				enum: ["2020-12"]
+			}
+		},
+		required: ["mode", "dialect"],
+		additionalProperties: false
+	}] }],
+	messages: {
+		object: "inputSchema must be an object when provided.",
+		serialization: "inputSchema contains a BigInt and cannot be JSON serialized.",
+		schema: "Invalid JSON Schema 2020-12: {{reason}}."
+	},
+	check(call, analyzer, context, [options]) {
+		const node = isDefinition(call) ? call.tool?.properties.get("inputSchema")?.value : void 0;
+		if (!node) return;
+		const fact = readValue(analyzer.source, node);
+		if (fact.kind !== "known" || fact.value === void 0) return;
+		if (fact.value === null || typeof fact.value !== "object") {
+			context.report({
+				node,
+				messageId: "object"
+			});
+			return;
+		}
+		if (containsBigInt(fact.value)) {
+			context.report({
+				node,
+				messageId: "serialization"
+			});
+			return;
+		}
+		if (options.mode !== "json-schema") return;
+		const schema = JSON.parse(JSON.stringify(fact.value));
+		if (typeof schema !== "object" || schema === null) return;
+		if ("$schema" in schema && schema.$schema !== "https://json-schema.org/draft/2020-12/schema" && schema.$schema !== "https://json-schema.org/draft/2020-12/schema#") return;
+		const ajv = getValidator();
+		if (!ajv.validateSchema(schema)) context.report({
+			node,
+			messageId: "schema",
+			data: { reason: ajv.errorsText(ajv.errors) }
+		});
+	}
+});
+const noIncompatibleExecuteArguments = createApiRule({
+	name: "no-incompatible-execute-arguments",
+	description: "Use the executeTool input representation required by the target.",
+	recommended: "error",
+	defaultOptions: [],
+	messages: {
+		object: "{{target}} expects an input object; do not pass JSON text or primitives.",
+		text: "{{target}} expects JSON text; explicitly serialize the input object."
+	},
+	check(call, analyzer, context) {
+		if (call.receiver !== "document" || !call.bound || call.method !== "executeTool" || call.node.arguments.some((argument, index) => index <= 1 && argument.type === "SpreadElement")) return;
+		const [, node] = call.node.arguments;
+		if (!node) return;
+		const fact = readValue(analyzer.source, node);
+		const expression = resolveExpression(analyzer.source, node);
+		if (analyzer.settings.target === "draft-2026-09-04") {
+			if (fact.kind === "known" && fact.value !== void 0 && (fact.value === null || typeof fact.value !== "object")) context.report({
+				node,
+				messageId: "object",
+				data: { target: analyzer.settings.target }
+			});
+		} else if (expression.type === "ObjectExpression" || expression.type === "ArrayExpression") context.report({
+			node,
+			messageId: "text",
+			data: { target: analyzer.settings.target }
+		});
+	}
+});
+const preferParameterDescriptions = createApiRule({
+	name: "prefer-parameter-descriptions",
+	description: "Describe statically known input parameters.",
+	type: "suggestion",
+	strict: "warn",
+	defaultOptions: [],
+	messages: { missing: "Describe input parameter \"{{name}}\"." },
+	check(call, analyzer, context) {
+		const node = isDefinition(call) ? call.tool?.properties.get("inputSchema")?.value : void 0;
+		if (!node) return;
+		visitParameters(analyzer.source, node, (name, schema) => {
+			const object = readObject(analyzer.source, schema);
+			if (!object || object.properties.has("$ref")) return;
+			const description = object.properties.get("description")?.value;
+			const text = readString(analyzer.source, description);
+			if (!description && object.complete || text !== void 0 && text.trim().length === 0) context.report({
+				node: description ?? schema,
+				messageId: "missing",
+				data: { name }
+			});
+		});
+	}
+});
+//#endregion
+//#region src/rules/quality.ts
+const preferToolTitle = createApiRule({
+	name: "prefer-tool-title",
+	description: "Opt into human-readable tool titles.",
+	type: "suggestion",
+	defaultOptions: [],
+	messages: { title: "Provide a human-readable title for this tool." },
+	check(call, analyzer, context) {
+		if (!isDefinition(call) || !call.toolNode) return;
+		const title = getField(call.tool, "title");
+		const value = title.kind === "known" ? readValue(analyzer.source, title.node) : void 0;
+		if (title.kind === "missing" || value?.kind === "known" && (value.value === void 0 || typeof value.value === "string" && value.value.trim().length === 0)) context.report({
+			node: title.kind === "known" ? title.node : call.toolNode,
+			messageId: "title"
+		});
+	}
+});
+const noPlaceholderDescription = createApiRule({
+	name: "no-placeholder-description",
+	description: "Replace complete placeholder descriptions with useful text.",
+	type: "suggestion",
+	strict: "warn",
+	defaultOptions: [{ placeholders: [
+		"TODO",
+		"TBD",
+		"FIXME"
+	] }],
+	schema: stringListOption("placeholders"),
+	messages: { placeholder: "Replace the placeholder description \"{{description}}\" with the tool’s purpose." },
+	check(call, analyzer, context, [options]) {
+		const node = isDefinition(call) ? call.tool?.properties.get("description")?.value : void 0;
+		const description = readString(analyzer.source, node);
+		if (node && description && options.placeholders.some((placeholder) => placeholder.trim().toLowerCase() === description.trim().toLowerCase())) context.report({
+			node,
+			messageId: "placeholder",
+			data: { description }
+		});
+	}
+});
+const maxDescriptionLength = createApiRule({
+	name: "max-description-length",
+	description: "Apply configurable Unicode code-point budgets to descriptions.",
+	type: "suggestion",
+	defaultOptions: [{
+		tool: 500,
+		parameter: 150,
+		unit: "codePoint"
+	}],
+	schema: [{
+		type: "object",
+		properties: {
+			tool: {
+				type: "integer",
+				minimum: 1
+			},
+			parameter: {
+				type: "integer",
+				minimum: 1
+			},
+			unit: {
+				type: "string",
+				enum: ["codePoint"]
+			}
+		},
+		additionalProperties: false
+	}],
+	messages: { long: "This description has {{length}} Unicode code points; the configured limit is {{limit}}." },
+	check(call, analyzer, context, [options]) {
+		if (!isDefinition(call)) return;
+		const reportDescription = (node, limit) => {
+			const description = readString(analyzer.source, node);
+			if (node && description !== void 0 && [...description].length > limit) context.report({
+				node,
+				messageId: "long",
+				data: {
+					length: [...description].length,
+					limit
+				}
+			});
+		};
+		reportDescription(call.tool?.properties.get("description")?.value, options.tool ?? 500);
+		const schema = call.tool?.properties.get("inputSchema")?.value;
+		if (schema) visitParameters(analyzer.source, schema, (_name, parameter) => {
+			reportDescription(readObject(analyzer.source, parameter)?.properties.get("description")?.value, options.parameter ?? 150);
+		});
+	}
+});
+const NAME_PATTERNS = {
+	snake_case: /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/u,
+	"kebab-case": /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u,
+	camelCase: /^[a-z][a-zA-Z0-9]*$/u
+};
+//#endregion
+//#region src/rules/index.ts
+const rules = {
+	"require-tool-properties": requireToolProperties,
+	"valid-tool-name": validToolName,
+	"valid-execute": validExecute,
+	"no-empty-description": noEmptyDescription,
+	"no-unsupported-api": noUnsupportedApi,
+	"no-unbound-api-call": noUnboundApiCall,
+	"valid-input-schema": validInputSchema,
+	"no-incompatible-execute-arguments": noIncompatibleExecuteArguments,
+	"prefer-parameter-descriptions": preferParameterDescriptions,
+	"no-unknown-tool-properties": noUnknownToolProperties,
+	"valid-annotations": validAnnotations,
+	"require-api-arguments": requireApiArguments,
+	"no-unknown-api-options": noUnknownApiOptions,
+	"valid-abort-signal": validAbortSignal,
+	"valid-origin-list": validOriginList,
+	"prefer-canonical-origin": preferCanonicalOrigin,
+	"no-preaborted-registration-signal": noPreabortedRegistrationSignal,
+	"valid-registered-tool": validRegisteredTool,
+	"no-unknown-model-context-events": noUnknownModelContextEvents,
+	"prefer-tool-title": preferToolTitle,
+	"max-description-length": maxDescriptionLength,
+	"no-placeholder-description": noPlaceholderDescription,
+	"tool-name-convention": createApiRule({
+		name: "tool-name-convention",
+		description: "Apply a project-specific naming convention to valid tool names.",
+		type: "suggestion",
+		defaultOptions: [{
+			style: "snake_case",
+			segmentStyle: "kebab-case",
+			prefix: ""
+		}],
+		schema: [{
+			type: "object",
+			properties: {
+				style: {
+					type: "string",
+					enum: [
+						"snake_case",
+						"kebab-case",
+						"camelCase",
+						"dot-separated"
+					]
+				},
+				segmentStyle: {
+					type: "string",
+					enum: [
+						"snake_case",
+						"kebab-case",
+						"camelCase"
+					]
+				},
+				prefix: { type: "string" }
+			},
+			additionalProperties: false
+		}],
+		messages: { convention: "Tool name \"{{name}}\" does not follow the configured {{style}} style and prefix \"{{prefix}}\"." },
+		check(call, analyzer, context, [options]) {
+			const node = isDefinition(call) ? call.tool?.properties.get("name")?.value : void 0;
+			const name = readString(analyzer.source, node);
+			if (!node || name === void 0 || !isValidToolName(name)) return;
+			const { style = "snake_case", segmentStyle = "kebab-case", prefix = "" } = options;
+			const suffix = name.slice(prefix.length);
+			const matchesStyle = style === "dot-separated" ? suffix.split(".").every((segment) => NAME_PATTERNS[segmentStyle].test(segment)) : NAME_PATTERNS[style].test(suffix);
+			if (!name.startsWith(prefix) || !matchesStyle) context.report({
+				node,
+				messageId: "convention",
+				data: {
+					name,
+					style,
+					prefix
+				}
+			});
+		}
+	}),
+	"require-explicit-annotations": createApiRule({
+		name: "require-explicit-annotations",
+		description: "Require explicit evaluation of configured tool hints.",
+		type: "suggestion",
+		defaultOptions: [{ fields: ["readOnlyHint", "consequentialHint"] }],
+		schema: [{
+			type: "object",
+			properties: { fields: {
+				type: "array",
+				items: {
+					type: "string",
+					enum: ANNOTATIONS
+				},
+				minItems: 1,
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}],
+		messages: { missing: "Explicitly evaluate the \"{{name}}\" annotation for this tool." },
+		check(call, analyzer, context, [options]) {
+			if (!isDefinition(call) || !call.toolNode) return;
+			const field = getField(call.tool, "annotations");
+			const object = field.kind === "known" ? readObject(analyzer.source, field.node) : void 0;
+			const value = field.kind === "known" ? readValue(analyzer.source, field.node) : void 0;
+			for (const name of options.fields) {
+				const annotation = getField(object, name);
+				const hint = annotation.kind === "known" ? readValue(analyzer.source, annotation.node) : void 0;
+				if (field.kind === "missing" || value?.kind === "known" && (value.value === null || value.value === void 0) || annotation.kind === "missing" || hint?.kind === "known" && hint.value === void 0) context.report({
+					node: field.kind === "known" ? field.node : call.toolNode,
+					messageId: "missing",
+					data: { name }
+				});
+			}
+		}
+	})
+};
+//#endregion
+//#region src/index.ts
+const plugin = {
+	meta: {
+		name,
+		version
+	},
+	rules
+};
+/**
+* Create a parser-independent Flat Config for a fixed WebMCP API snapshot.
+*
+* @param options Target, preset and optional file globs
+* @returns A standalone Flat Config referencing this plugin
+*/
+function createConfig(options = {}) {
+	const target = resolveTarget(options.target);
+	const preset = options.preset ?? "recommended";
+	if (preset !== "recommended" && preset !== "strict") throw new Error("webmcp: preset must be \"recommended\" or \"strict\".");
+	if (options.files !== void 0 && (!Array.isArray(options.files) || options.files.length === 0 || !options.files.every((file) => typeof file === "string" && file.length > 0))) throw new Error("webmcp: files must be a nonempty array of glob strings.");
+	const enabled = {};
+	for (const [ruleName, rule] of Object.entries(rules)) {
+		const severity = rule.meta.docs?.recommended ?? (preset === "strict" ? rule.meta.docs?.strict : void 0);
+		if (severity) enabled[`webmcp/${ruleName}`] = severity;
+	}
+	return {
+		name: `webmcp/${preset}/${target}`,
+		files: options.files ? [...options.files] : ["**/*.{js,mjs,cjs,jsx,ts,mts,cts,tsx}"],
+		plugins: { webmcp: plugin },
+		settings: { webmcp: { target } },
+		rules: enabled
+	};
+}
+const configs = {
+	recommended: createConfig(),
+	strict: createConfig({ preset: "strict" })
+};
+const webmcp = Object.assign(plugin, { configs });
+//#endregion
+export { createConfig, webmcp as default };