@mcp-b/global 2.0.3-canary.4 → 2.0.5

package/dist/index.js

@@ -1,1851 +1,150 @@
 import { IframeChildTransport, TabServerTransport } from "@mcp-b/transports";
-import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, Server } from "@mcp-b/webmcp-ts-sdk";
-import { jsonSchemaToZod } from "@n8n/json-schema-to-zod";
-import { z } from "zod";
-import { zodToJsonSchema as zodToJsonSchema$1 } from "zod-to-json-schema";
+import { initializeWebMCPPolyfill } from "@mcp-b/webmcp-polyfill";
+import { BrowserMcpServer } from "@mcp-b/webmcp-ts-sdk";
 
-//#region src/logger.ts
-/**
-* @license
-* Copyright 2025 Google LLC
-* SPDX-License-Identifier: Apache-2.0
-*/
-/**
-* Lightweight logging system for @mcp-b/global
-*
-* Design Decision: This implements a custom logger instead of using the 'debug'
-* package to reduce bundle size and eliminate external dependencies in the
-* browser build. The API is intentionally simpler, focusing on the specific
-* needs of browser-based MCP implementations.
-*
-* Configuration via localStorage:
-* - localStorage.setItem('WEBMCP_DEBUG', '*') - enable all debug logging
-* - localStorage.setItem('WEBMCP_DEBUG', 'WebModelContext') - enable specific namespace
-* - localStorage.setItem('WEBMCP_DEBUG', 'WebModelContext,NativeAdapter') - multiple namespaces
-* - localStorage.setItem('WEBMCP_DEBUG', 'WebModelContext:') - enable namespace and sub-namespaces
-* - localStorage.removeItem('WEBMCP_DEBUG') - disable debug logging (default)
-*
-* Environment Support:
-* - Automatically detects localStorage availability
-* - Gracefully degrades to "disabled" state when localStorage is inaccessible
-* - Never throws errors from configuration checks (safe for private browsing mode)
-*/
-/** localStorage key for debug configuration */
-const DEBUG_CONFIG_KEY = "WEBMCP_DEBUG";
+//#region src/global.ts
+let runtime = null;
+function isBrowserEnvironment() {
+	return typeof window !== "undefined" && typeof window.navigator !== "undefined";
+}
 /**
-* Check if debug logging is enabled for a namespace
-*
-* Supports namespace hierarchy via colons. Setting 'WebModelContext' will match
-* both 'WebModelContext' and 'WebModelContext:init', but NOT 'WebModelContextTesting'.
+* Replace navigator.modelContext with the given value.
+* Tries an own-property on the navigator instance first. If the native browser
+* defines modelContext as a non-configurable property (common in Chromium), this
+* will throw — in that case we fall back to redefining the getter on
+* Navigator.prototype so that `navigator.modelContext` resolves to our value.
 */
-function isDebugEnabled(namespace) {
-	if (typeof window === "undefined" || !window.localStorage) return false;
+function replaceModelContext(value) {
 	try {
-		const debugConfig = localStorage.getItem(DEBUG_CONFIG_KEY);
-		if (!debugConfig) return false;
-		if (debugConfig === "*") return true;
-		return debugConfig.split(",").map((p) => p.trim()).some((pattern) => namespace === pattern || namespace.startsWith(`${pattern}:`));
-	} catch (err) {
-		if (typeof console !== "undefined" && console.warn) {
-			const message = err instanceof Error ? err.message : String(err);
-			console.warn(`[WebMCP] localStorage access failed, debug logging disabled: ${message}`);
-		}
-		return false;
+		Object.defineProperty(navigator, "modelContext", {
+			configurable: true,
+			enumerable: true,
+			writable: false,
+			value
+		});
+	} catch {
+		Object.defineProperty(Object.getPrototypeOf(navigator), "modelContext", {
+			configurable: true,
+			enumerable: true,
+			get() {
+				return value;
+			}
+		});
 	}
+	if (navigator.modelContext !== value) console.error("[WebModelContext] Failed to replace navigator.modelContext.", "Descriptor:", Object.getOwnPropertyDescriptor(navigator, "modelContext"));
 }
-/**
-* No-op function for disabled log levels
-*/
-const noop = () => {};
-/**
-* Create a namespaced logger
-*
-* Uses .bind() to prepend namespace prefixes to console methods without manual
-* string concatenation. Debug enablement is determined at logger creation time
-* for performance - changes to localStorage after creation won't affect existing
-* loggers. Refresh the page to apply new WEBMCP_DEBUG settings.
-*
-* @param namespace - Namespace for the logger (e.g., 'WebModelContext', 'NativeAdapter')
-* @returns Logger instance with debug, info, warn, error methods
-*
-* @example
-* ```typescript
-* const logger = createLogger('WebModelContext');
-* logger.debug('Tool registered:', toolName); // Only shown if WEBMCP_DEBUG includes 'WebModelContext'
-* logger.error('Execution failed:', error); // Always enabled
-* ```
-*/
-function createLogger(namespace) {
-	const prefix = `[${namespace}]`;
-	const isDebug = isDebugEnabled(namespace);
-	const boundWarn = console.warn.bind(console, prefix);
-	const boundError = console.error.bind(console, prefix);
-	const boundLog = console.log.bind(console, prefix);
-	return {
-		warn: boundWarn,
-		error: boundError,
-		debug: isDebug ? boundLog : noop,
-		info: isDebug ? boundLog : noop
-	};
+function createTransport(config) {
+	if (window.parent !== window && config?.iframeServer !== false) {
+		const { allowedOrigins: allowedOrigins$1,...rest$1 } = typeof config?.iframeServer === "object" ? config.iframeServer : {};
+		return new IframeChildTransport({
+			allowedOrigins: allowedOrigins$1 ?? ["*"],
+			...rest$1
+		});
+	}
+	if (config?.tabServer === false) throw new Error("tabServer transport is disabled and iframe transport was not selected");
+	const { allowedOrigins,...rest } = typeof config?.tabServer === "object" ? config.tabServer : {};
+	return new TabServerTransport({
+		allowedOrigins: allowedOrigins ?? ["*"],
+		...rest
+	});
 }
-
-//#endregion
-//#region src/validation.ts
-const logger$2 = createLogger("WebModelContext");
-const isRecord = (value) => typeof value === "object" && value !== null;
-const stripSchemaMeta = (schema) => {
-	const { $schema: _,...rest } = schema;
-	return rest;
-};
-const isOptionalSchema = (schema) => {
-	const typeName = schema._def?.typeName;
-	return typeName === "ZodOptional" || typeName === "ZodDefault";
-};
-/**
-* Detect if schema is a Zod schema object (Record<string, ZodType>).
-* Only supports Zod 3.x schemas.
-*/
-function isZodSchema(schema) {
-	if (!isRecord(schema)) return false;
-	if ("type" in schema && typeof schema.type === "string") return false;
-	const values = Object.values(schema);
-	if (values.length === 0) return false;
-	return values.some((v) => isRecord(v) && "_def" in v);
-}
-/**
-* Convert Zod 3 schema object to JSON Schema.
-* Only supports Zod 3.x - Zod 4 is not supported.
-*/
-function zodToJsonSchema(schema) {
-	const properties = {};
-	const required = [];
-	for (const [key, zodSchema] of Object.entries(schema)) {
-		properties[key] = stripSchemaMeta(zodToJsonSchema$1(zodSchema, {
-			strictUnions: true,
-			$refStrategy: "none"
-		}));
-		if (!isOptionalSchema(zodSchema)) required.push(key);
-	}
-	const result = {
-		type: "object",
-		properties
-	};
-	if (required.length > 0) result.required = required;
-	return result;
-}
-function jsonSchemaToZod$1(jsonSchema) {
+function parseTestingInputSchema(inputSchema) {
+	if (!inputSchema) return;
 	try {
-		return jsonSchemaToZod(jsonSchema);
+		const parsed = JSON.parse(inputSchema);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return;
+		return parsed;
 	} catch (error) {
-		logger$2.warn("jsonSchemaToZod failed:", error);
-		return z.object({}).passthrough();
-	}
-}
-function normalizeSchema(schema) {
-	if (isZodSchema(schema)) {
-		const jsonSchema = zodToJsonSchema(schema);
-		return {
-			jsonSchema,
-			zodValidator: jsonSchemaToZod$1(jsonSchema)
-		};
+		console.warn("[WebMCP] Failed to parse testing inputSchema JSON:", error);
+		return;
 	}
-	return {
-		jsonSchema: schema,
-		zodValidator: jsonSchemaToZod$1(schema)
-	};
-}
-function validateWithZod(data, validator) {
-	const result = validator.safeParse(data);
-	if (result.success) return {
-		success: true,
-		data: result.data
-	};
-	return {
-		success: false,
-		error: `Validation failed:\n${result.error.issues.map((err) => `  - ${err.path.join(".") || "root"}: ${err.message}`).join("\n")}`
-	};
 }
-
-//#endregion
-//#region src/global.ts
-const logger$1 = createLogger("WebModelContext");
-const nativeLogger = createLogger("NativeAdapter");
-const bridgeLogger = createLogger("MCPBridge");
-const testingLogger = createLogger("ModelContextTesting");
-/**
-* Marker property name used to identify polyfill implementations.
-* This constant ensures single source of truth for the marker used in
-* both detection (detectNativeAPI) and definition (WebModelContextTesting).
-*/
-const POLYFILL_MARKER_PROPERTY = "__isWebMCPPolyfill";
-/**
-* Detect if the native Chromium Web Model Context API is available.
-* Checks for both navigator.modelContext and navigator.modelContextTesting,
-* and verifies they are native implementations (not polyfills).
-*
-* Detection uses a marker property (`__isWebMCPPolyfill`) on the testing API
-* to reliably distinguish polyfills from native implementations. This approach
-* works correctly even when class names are minified in production builds.
-*
-* @returns Detection result with flags for native context and testing API availability
-*/
-function detectNativeAPI() {
-	/* c8 ignore next 2 */
-	if (typeof window === "undefined" || typeof navigator === "undefined") return {
-		hasNativeContext: false,
-		hasNativeTesting: false
-	};
-	const modelContext = navigator.modelContext;
-	const modelContextTesting = navigator.modelContextTesting;
-	if (!modelContext || !modelContextTesting) return {
-		hasNativeContext: Boolean(modelContext),
-		hasNativeTesting: Boolean(modelContextTesting)
-	};
-	if (POLYFILL_MARKER_PROPERTY in modelContextTesting && modelContextTesting[POLYFILL_MARKER_PROPERTY] === true) return {
-		hasNativeContext: false,
-		hasNativeTesting: false
+function getTestingShimTools() {
+	const testingShim = navigator.modelContextTesting;
+	if (!testingShim) return;
+	if (typeof testingShim.getRegisteredTools === "function") return {
+		testingShim,
+		tools: testingShim.getRegisteredTools()
 	};
+	if (typeof testingShim.listTools !== "function") return;
 	return {
-		hasNativeContext: true,
-		hasNativeTesting: true
+		testingShim,
+		tools: testingShim.listTools().map((tool) => ({
+			name: tool.name,
+			description: tool.description ?? "",
+			inputSchema: parseTestingInputSchema(tool.inputSchema) ?? {
+				type: "object",
+				properties: {}
+			}
+		}))
 	};
 }
-/**
-* Adapter that wraps the native Chromium Web Model Context API.
-* Synchronizes tool changes from the native API to the MCP bridge,
-* enabling MCP clients to stay in sync with the native tool registry.
-*
-* Key features:
-* - Listens to native tool changes via registerToolsChangedCallback()
-* - Syncs native tools to MCP bridge automatically
-* - Delegates tool execution to native API
-* - Converts native results to MCP ToolResponse format
-*
-* @class NativeModelContextAdapter
-* @implements {InternalModelContext}
-*/
-var NativeModelContextAdapter = class {
-	nativeContext;
-	nativeTesting;
-	bridge;
-	syncInProgress = false;
-	/**
-	* Creates a new NativeModelContextAdapter.
-	*
-	* @param {MCPBridge} bridge - The MCP bridge instance
-	* @param {ModelContext} nativeContext - The native navigator.modelContext
-	* @param {ModelContextTesting} nativeTesting - The native navigator.modelContextTesting
-	*/
-	constructor(bridge, nativeContext, nativeTesting) {
-		this.bridge = bridge;
-		this.nativeContext = nativeContext;
-		this.nativeTesting = nativeTesting;
-		this.nativeTesting.registerToolsChangedCallback(() => {
-			this.syncToolsFromNative();
-		});
-		this.syncToolsFromNative();
-	}
-	/**
-	* Synchronizes tools from the native API to the MCP bridge.
-	* Fetches all tools from navigator.modelContextTesting.listTools()
-	* and updates the bridge's tool registry.
-	*
-	* @private
-	*/
-	syncToolsFromNative() {
-		if (this.syncInProgress) return;
-		this.syncInProgress = true;
-		try {
-			const nativeTools = this.nativeTesting.listTools();
-			this.bridge.tools.clear();
-			for (const toolInfo of nativeTools) try {
-				const inputSchema = JSON.parse(toolInfo.inputSchema);
-				const validatedTool = {
-					name: toolInfo.name,
-					description: toolInfo.description,
-					inputSchema,
-					execute: async (args) => {
-						const result = await this.nativeTesting.executeTool(toolInfo.name, JSON.stringify(args));
-						return this.convertToToolResponse(result);
-					},
-					inputValidator: jsonSchemaToZod$1(inputSchema)
-				};
-				this.bridge.tools.set(toolInfo.name, validatedTool);
-			} catch (error) {
-				nativeLogger.error(`Failed to sync tool "${toolInfo.name}":`, error);
-			}
-			this.notifyMCPServers();
-		} finally {
-			this.syncInProgress = false;
-		}
-	}
-	/**
-	* Converts native API result to MCP ToolResponse format.
-	* Native API returns simplified values (string, number, object, etc.)
-	* which need to be wrapped in the MCP CallToolResult format.
-	*
-	* @param {unknown} result - The result from native executeTool()
-	* @returns {ToolResponse} Formatted MCP ToolResponse
-	* @private
-	*/
-	convertToToolResponse(result) {
-		if (typeof result === "string") return { content: [{
-			type: "text",
-			text: result
-		}] };
-		if (result === void 0 || result === null) return { content: [{
-			type: "text",
-			text: ""
-		}] };
-		if (typeof result === "object") return {
+function syncToolsFromTestingShim(server) {
+	const shimState = getTestingShimTools();
+	if (!shimState) return 0;
+	const { testingShim, tools } = shimState;
+	return server.backfillTools(tools, async (name, args) => {
+		const serialized = await testingShim.executeTool(name, JSON.stringify(args ?? {}));
+		if (serialized === null) return {
 			content: [{
 				type: "text",
-				text: JSON.stringify(result, null, 2)
+				text: "Tool execution interrupted by navigation"
 			}],
-			structuredContent: result
+			isError: true
 		};
-		return { content: [{
-			type: "text",
-			text: String(result)
-		}] };
-	}
-	/**
-	* Notifies all connected MCP servers that the tools list has changed.
-	*
-	* @private
-	*/
-	notifyMCPServers() {
-		if (this.bridge.tabServer?.notification) this.bridge.tabServer.notification({
-			method: "notifications/tools/list_changed",
-			params: {}
-		});
-		if (this.bridge.iframeServer?.notification) this.bridge.iframeServer.notification({
-			method: "notifications/tools/list_changed",
-			params: {}
-		});
-	}
-	/**
-	* Provides context (tools) to AI models via the native API.
-	* Delegates to navigator.modelContext.provideContext().
-	* Tool change callback will fire and trigger sync automatically.
-	*
-	* @param {ModelContextInput} context - Context containing tools to register
-	*/
-	provideContext(context) {
-		this.nativeContext.provideContext(context);
-	}
-	/**
-	* Registers a single tool dynamically via the native API.
-	* Delegates to navigator.modelContext.registerTool().
-	* Tool change callback will fire and trigger sync automatically.
-	*
-	* @param {ToolDescriptor} tool - The tool descriptor to register
-	* @returns {{unregister: () => void}} Object with unregister function
-	*/
-	registerTool(tool) {
-		return this.nativeContext.registerTool(tool);
-	}
-	/**
-	* Unregisters a tool by name via the native API.
-	* Delegates to navigator.modelContext.unregisterTool().
-	*
-	* @param {string} name - Name of the tool to unregister
-	*/
-	unregisterTool(name) {
-		this.nativeContext.unregisterTool(name);
-	}
-	/**
-	* Clears all registered tools via the native API.
-	* Delegates to navigator.modelContext.clearContext().
-	*/
-	clearContext() {
-		this.nativeContext.clearContext();
-	}
-	/**
-	* Executes a tool via the native API.
-	* Delegates to navigator.modelContextTesting.executeTool() with JSON string args.
-	*
-	* @param {string} toolName - Name of the tool to execute
-	* @param {Record<string, unknown>} args - Arguments to pass to the tool
-	* @returns {Promise<ToolResponse>} The tool's response in MCP format
-	* @internal
-	*/
-	async executeTool(toolName, args) {
+		let parsed;
 		try {
-			const result = await this.nativeTesting.executeTool(toolName, JSON.stringify(args));
-			return this.convertToToolResponse(result);
-		} catch (error) {
-			nativeLogger.error(`Error executing tool "${toolName}":`, error);
-			return {
-				content: [{
-					type: "text",
-					text: `Error: ${error instanceof Error ? error.message : String(error)}`
-				}],
-				isError: true
-			};
+			parsed = JSON.parse(serialized);
+		} catch (parseError) {
+			throw new Error(`Failed to parse serialized tool response for ${name}: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
 		}
-	}
-	/**
-	* Lists all registered tools from the MCP bridge.
-	* Returns tools synced from the native API.
-	*
-	* @returns {Array<{name: string, description: string, inputSchema: InputSchema}>} Array of tool descriptors
-	*/
-	listTools() {
-		return Array.from(this.bridge.tools.values()).map((tool) => ({
-			name: tool.name,
-			description: tool.description,
-			inputSchema: tool.inputSchema,
-			...tool.outputSchema && { outputSchema: tool.outputSchema },
-			...tool.annotations && { annotations: tool.annotations }
-		}));
-	}
-	/**
-	* Registers a resource dynamically.
-	* Note: Native Chromium API does not yet support resources.
-	* This is a polyfill-only feature.
-	*/
-	registerResource(_resource) {
-		nativeLogger.warn("registerResource is not supported by native API");
-		return { unregister: () => {} };
-	}
-	/**
-	* Unregisters a resource by URI.
-	* Note: Native Chromium API does not yet support resources.
-	*/
-	unregisterResource(_uri) {
-		nativeLogger.warn("unregisterResource is not supported by native API");
-	}
-	/**
-	* Lists all registered resources.
-	* Note: Native Chromium API does not yet support resources.
-	*/
-	listResources() {
-		return [];
-	}
-	/**
-	* Lists all resource templates.
-	* Note: Native Chromium API does not yet support resources.
-	*/
-	listResourceTemplates() {
-		return [];
-	}
-	/**
-	* Reads a resource by URI.
-	* Note: Native Chromium API does not yet support resources.
-	* @internal
-	*/
-	async readResource(_uri) {
-		throw new Error("[Native Adapter] readResource is not supported by native API");
-	}
-	/**
-	* Registers a prompt dynamically.
-	* Note: Native Chromium API does not yet support prompts.
-	* This is a polyfill-only feature.
-	*/
-	registerPrompt(_prompt) {
-		nativeLogger.warn("registerPrompt is not supported by native API");
-		return { unregister: () => {} };
-	}
-	/**
-	* Unregisters a prompt by name.
-	* Note: Native Chromium API does not yet support prompts.
-	*/
-	unregisterPrompt(_name) {
-		nativeLogger.warn("unregisterPrompt is not supported by native API");
-	}
-	/**
-	* Lists all registered prompts.
-	* Note: Native Chromium API does not yet support prompts.
-	*/
-	listPrompts() {
-		return [];
-	}
-	/**
-	* Gets a prompt with arguments.
-	* Note: Native Chromium API does not yet support prompts.
-	* @internal
-	*/
-	async getPrompt(_name, _args) {
-		throw new Error("[Native Adapter] getPrompt is not supported by native API");
-	}
-	/**
-	* Adds an event listener for tool call events.
-	* Delegates to the native API's addEventListener.
-	*
-	* @param {'toolcall'} type - Event type
-	* @param {(event: ToolCallEvent) => void | Promise<void>} listener - Event handler
-	* @param {boolean | AddEventListenerOptions} [options] - Event listener options
-	*/
-	addEventListener(type, listener, options) {
-		this.nativeContext.addEventListener(type, listener, options);
-	}
-	/**
-	* Removes an event listener for tool call events.
-	* Delegates to the native API's removeEventListener.
-	*
-	* @param {'toolcall'} type - Event type
-	* @param {(event: ToolCallEvent) => void | Promise<void>} listener - Event handler
-	* @param {boolean | EventListenerOptions} [options] - Event listener options
-	*/
-	removeEventListener(type, listener, options) {
-		this.nativeContext.removeEventListener(type, listener, options);
-	}
-	/**
-	* Dispatches a tool call event.
-	* Delegates to the native API's dispatchEvent.
-	*
-	* @param {Event} event - The event to dispatch
-	* @returns {boolean} False if event was cancelled, true otherwise
-	*/
-	dispatchEvent(event) {
-		return this.nativeContext.dispatchEvent(event);
-	}
-	/**
-	* Request an LLM completion from the connected client.
-	* Note: Native Chromium API does not yet support sampling.
-	* This is handled by the polyfill.
-	*/
-	async createMessage(params) {
-		const underlyingServer = this.bridge.tabServer.server;
-		if (!underlyingServer?.createMessage) throw new Error("Sampling is not supported: no connected client with sampling capability");
-		return underlyingServer.createMessage(params);
-	}
-	/**
-	* Request user input from the connected client.
-	* Note: Native Chromium API does not yet support elicitation.
-	* This is handled by the polyfill.
-	*/
-	async elicitInput(params) {
-		const underlyingServer = this.bridge.tabServer.server;
-		if (!underlyingServer?.elicitInput) throw new Error("Elicitation is not supported: no connected client with elicitation capability");
-		return underlyingServer.elicitInput(params);
-	}
-};
-/**
-* ToolCallEvent implementation for the Web Model Context API.
-* Represents an event fired when a tool is called, allowing event listeners
-* to intercept and provide custom responses.
-*
-* @class WebToolCallEvent
-* @extends {Event}
-* @implements {ToolCallEvent}
-*/
-var WebToolCallEvent = class extends Event {
-	name;
-	arguments;
-	_response = null;
-	_responded = false;
-	/**
-	* Creates a new ToolCallEvent.
-	*
-	* @param {string} toolName - Name of the tool being called
-	* @param {Record<string, unknown>} args - Validated arguments for the tool
-	*/
-	constructor(toolName, args) {
-		super("toolcall", { cancelable: true });
-		this.name = toolName;
-		this.arguments = args;
-	}
-	/**
-	* Provides a response for this tool call, preventing the default tool execution.
-	*
-	* @param {ToolResponse} response - The response to use instead of executing the tool
-	* @throws {Error} If a response has already been provided
-	*/
-	respondWith(response) {
-		if (this._responded) throw new Error("Response already provided for this tool call");
-		this._response = response;
-		this._responded = true;
-	}
-	/**
-	* Gets the response provided via respondWith().
-	*
-	* @returns {ToolResponse | null} The response, or null if none provided
-	*/
-	getResponse() {
-		return this._response;
-	}
-	/**
-	* Checks whether a response has been provided for this tool call.
-	*
-	* @returns {boolean} True if respondWith() was called
-	*/
-	hasResponse() {
-		return this._responded;
-	}
-};
-/**
-* Time window in milliseconds to detect rapid duplicate tool registrations.
-* Used to filter out double-registrations caused by React Strict Mode.
-*/
-const RAPID_DUPLICATE_WINDOW_MS = 50;
-/**
-* Testing API implementation for the Model Context Protocol.
-* Provides debugging, mocking, and testing capabilities for tool execution.
-* Implements both Chromium native methods and polyfill-specific extensions.
-*
-* @class WebModelContextTesting
-* @implements {ModelContextTesting}
-*/
-var WebModelContextTesting = class {
-	/**
-	* Marker property to identify this as a polyfill implementation.
-	* Used by detectNativeAPI() to distinguish polyfill from native Chromium API.
-	* This approach works reliably even when class names are minified in production builds.
-	*
-	* @see POLYFILL_MARKER_PROPERTY - The constant defining this property name
-	* @see MayHavePolyfillMarker - The interface for type-safe detection
-	*/
-	[POLYFILL_MARKER_PROPERTY] = true;
-	toolCallHistory = [];
-	mockResponses = /* @__PURE__ */ new Map();
-	toolsChangedCallbacks = /* @__PURE__ */ new Set();
-	bridge;
-	/**
-	* Creates a new WebModelContextTesting instance.
-	*
-	* @param {MCPBridge} bridge - The MCP bridge instance to test
-	*/
-	constructor(bridge) {
-		this.bridge = bridge;
-	}
-	/**
-	* Records a tool call in the history.
-	* Called internally by WebModelContext when tools are executed.
-	*
-	* @param {string} toolName - Name of the tool that was called
-	* @param {Record<string, unknown>} args - Arguments passed to the tool
-	* @internal
-	*/
-	recordToolCall(toolName, args) {
-		this.toolCallHistory.push({
-			toolName,
-			arguments: args,
-			timestamp: Date.now()
-		});
-	}
-	/**
-	* Checks if a mock response is registered for a specific tool.
-	*
-	* @param {string} toolName - Name of the tool to check
-	* @returns {boolean} True if a mock response exists
-	* @internal
-	*/
-	hasMockResponse(toolName) {
-		return this.mockResponses.has(toolName);
-	}
-	/**
-	* Retrieves the mock response for a specific tool.
-	*
-	* @param {string} toolName - Name of the tool
-	* @returns {ToolResponse | undefined} The mock response, or undefined if none exists
-	* @internal
-	*/
-	getMockResponse(toolName) {
-		return this.mockResponses.get(toolName);
-	}
-	/**
-	* Notifies all registered callbacks that the tools list has changed.
-	* Called internally when tools are registered, unregistered, or cleared.
-	*
-	* @internal
-	*/
-	notifyToolsChanged() {
-		for (const callback of this.toolsChangedCallbacks) try {
-			callback();
-		} catch (error) {
-			testingLogger.error("Error in tools changed callback:", error);
-		}
-	}
-	/**
-	* Executes a tool directly with JSON string input (Chromium native API).
-	* Parses the JSON input, validates it, and executes the tool.
-	*
-	* @param {string} toolName - Name of the tool to execute
-	* @param {string} inputArgsJson - JSON string of input arguments
-	* @returns {Promise<unknown>} The tool's result, or undefined on error
-	* @throws {SyntaxError} If the input JSON is invalid
-	* @throws {Error} If the tool does not exist
-	*/
-	async executeTool(toolName, inputArgsJson) {
-		let args;
-		try {
-			args = JSON.parse(inputArgsJson);
-		} catch (error) {
-			throw new SyntaxError(`Invalid JSON input: ${error instanceof Error ? error.message : String(error)}`);
-		}
-		if (!this.bridge.tools.get(toolName)) throw new Error(`Tool not found: ${toolName}`);
-		const result = await this.bridge.modelContext.executeTool(toolName, args);
-		if (result.isError) return;
-		if (result.structuredContent) return result.structuredContent;
-		if (result.content && result.content.length > 0) {
-			const firstContent = result.content[0];
-			if (firstContent && firstContent.type === "text") return firstContent.text;
-		}
-	}
-	/**
-	* Lists all registered tools with inputSchema as JSON string (Chromium native API).
-	* Returns an array of ToolInfo objects where inputSchema is stringified.
-	*
-	* @returns {Array<{name: string, description: string, inputSchema: string}>} Array of tool information
-	*/
-	listTools() {
-		return this.bridge.modelContext.listTools().map((tool) => ({
-			name: tool.name,
-			description: tool.description,
-			inputSchema: JSON.stringify(tool.inputSchema)
-		}));
-	}
-	/**
-	* Registers a callback that fires when the tools list changes (Chromium native API).
-	* The callback will be invoked on registerTool, unregisterTool, provideContext, and clearContext.
-	*
-	* @param {() => void} callback - Function to call when tools change
-	*/
-	registerToolsChangedCallback(callback) {
-		this.toolsChangedCallbacks.add(callback);
-	}
-	/**
-	* Gets all tool calls that have been recorded (polyfill extension).
-	*
-	* @returns {Array<{toolName: string, arguments: Record<string, unknown>, timestamp: number}>} Tool call history
-	*/
-	getToolCalls() {
-		return [...this.toolCallHistory];
-	}
-	/**
-	* Clears the tool call history (polyfill extension).
-	*/
-	clearToolCalls() {
-		this.toolCallHistory = [];
-	}
-	/**
-	* Sets a mock response for a specific tool (polyfill extension).
-	* When set, the tool's execute function will be bypassed.
-	*
-	* @param {string} toolName - Name of the tool to mock
-	* @param {ToolResponse} response - The mock response to return
-	*/
-	setMockToolResponse(toolName, response) {
-		this.mockResponses.set(toolName, response);
-	}
-	/**
-	* Clears the mock response for a specific tool (polyfill extension).
-	*
-	* @param {string} toolName - Name of the tool
-	*/
-	clearMockToolResponse(toolName) {
-		this.mockResponses.delete(toolName);
-	}
-	/**
-	* Clears all mock tool responses (polyfill extension).
-	*/
-	clearAllMockToolResponses() {
-		this.mockResponses.clear();
-	}
-	/**
-	* Gets the current tools registered in the system (polyfill extension).
-	*
-	* @returns {ReturnType<InternalModelContext['listTools']>} Array of registered tools
-	*/
-	getRegisteredTools() {
-		return this.bridge.modelContext.listTools();
-	}
-	/**
-	* Resets the entire testing state (polyfill extension).
-	* Clears both tool call history and all mock responses.
-	*/
-	reset() {
-		this.clearToolCalls();
-		this.clearAllMockToolResponses();
-	}
-};
-/**
-* ModelContext implementation that bridges to the Model Context Protocol SDK.
-* Implements the W3C Web Model Context API proposal with two-bucket tool management:
-* - Bucket A (provideContextTools): Tools registered via provideContext()
-* - Bucket B (dynamicTools): Tools registered via registerTool()
-*
-* This separation ensures that component-scoped dynamic tools persist across
-* app-level provideContext() calls.
-*
-* @class WebModelContext
-* @implements {InternalModelContext}
-*/
-var WebModelContext = class {
-	bridge;
-	eventTarget;
-	provideContextTools;
-	dynamicTools;
-	provideContextResources;
-	dynamicResources;
-	provideContextPrompts;
-	dynamicPrompts;
-	toolRegistrationTimestamps;
-	resourceRegistrationTimestamps;
-	promptRegistrationTimestamps;
-	toolUnregisterFunctions;
-	resourceUnregisterFunctions;
-	promptUnregisterFunctions;
-	/**
-	* Tracks which list change notifications are pending.
-	* Uses microtask-based batching to coalesce rapid registrations
-	* (e.g., React mount phase) into a single notification per list type.
-	*/
-	pendingNotifications = /* @__PURE__ */ new Set();
-	testingAPI;
-	/**
-	* Creates a new WebModelContext instance.
-	*
-	* @param {MCPBridge} bridge - The MCP bridge to use for communication
-	*/
-	constructor(bridge) {
-		this.bridge = bridge;
-		this.eventTarget = new EventTarget();
-		this.provideContextTools = /* @__PURE__ */ new Map();
-		this.dynamicTools = /* @__PURE__ */ new Map();
-		this.toolRegistrationTimestamps = /* @__PURE__ */ new Map();
-		this.toolUnregisterFunctions = /* @__PURE__ */ new Map();
-		this.provideContextResources = /* @__PURE__ */ new Map();
-		this.dynamicResources = /* @__PURE__ */ new Map();
-		this.resourceRegistrationTimestamps = /* @__PURE__ */ new Map();
-		this.resourceUnregisterFunctions = /* @__PURE__ */ new Map();
-		this.provideContextPrompts = /* @__PURE__ */ new Map();
-		this.dynamicPrompts = /* @__PURE__ */ new Map();
-		this.promptRegistrationTimestamps = /* @__PURE__ */ new Map();
-		this.promptUnregisterFunctions = /* @__PURE__ */ new Map();
-	}
-	/**
-	* Sets the testing API instance.
-	* Called during initialization to enable testing features.
-	*
-	* @param {WebModelContextTesting} testingAPI - The testing API instance
-	* @internal
-	*/
-	setTestingAPI(testingAPI) {
-		this.testingAPI = testingAPI;
-	}
-	/**
-	* Adds an event listener for tool call events.
-	*
-	* @param {'toolcall'} type - Event type (only 'toolcall' is supported)
-	* @param {(event: ToolCallEvent) => void | Promise<void>} listener - Event handler function
-	* @param {boolean | AddEventListenerOptions} [options] - Event listener options
-	*/
-	addEventListener(type, listener, options) {
-		this.eventTarget.addEventListener(type, listener, options);
-	}
-	/**
-	* Removes an event listener for tool call events.
-	*
-	* @param {'toolcall'} type - Event type (only 'toolcall' is supported)
-	* @param {(event: ToolCallEvent) => void | Promise<void>} listener - Event handler function
-	* @param {boolean | EventListenerOptions} [options] - Event listener options
-	*/
-	removeEventListener(type, listener, options) {
-		this.eventTarget.removeEventListener(type, listener, options);
-	}
-	/**
-	* Dispatches a tool call event to all registered listeners.
-	*
-	* @param {Event} event - The event to dispatch
-	* @returns {boolean} False if event was cancelled, true otherwise
-	*/
-	dispatchEvent(event) {
-		return this.eventTarget.dispatchEvent(event);
-	}
-	/**
-	* Provides context (tools, resources, prompts) to AI models by registering base items (Bucket A).
-	* Clears and replaces all previously registered base items while preserving
-	* dynamic items registered via register* methods.
-	*
-	* @param {ModelContextInput} context - Context containing tools, resources, and prompts to register
-	* @throws {Error} If a name/uri collides with existing dynamic items
-	*/
-	provideContext(context) {
-		this.provideContextTools.clear();
-		this.provideContextResources.clear();
-		this.provideContextPrompts.clear();
-		for (const tool of context.tools ?? []) {
-			if (tool.name.startsWith("_")) logger$1.warn(`⚠️ Warning: Tool name "${tool.name}" starts with underscore. This may cause compatibility issues with some MCP clients. Consider using a letter as the first character.`);
-			if (/^[0-9]/.test(tool.name)) logger$1.warn(`⚠️ Warning: Tool name "${tool.name}" starts with a number. This may cause compatibility issues. Consider using a letter as the first character.`);
-			if (tool.name.startsWith("-")) logger$1.warn(`⚠️ Warning: Tool name "${tool.name}" starts with hyphen. This may cause compatibility issues. Consider using a letter as the first character.`);
-			if (this.dynamicTools.has(tool.name)) throw new Error(`[Web Model Context] Tool name collision: "${tool.name}" is already registered via registerTool(). Please use a different name or unregister the dynamic tool first.`);
-			const { jsonSchema: inputJson, zodValidator: inputZod } = normalizeSchema(tool.inputSchema);
-			const normalizedOutput = tool.outputSchema ? normalizeSchema(tool.outputSchema) : null;
-			const validatedTool = {
-				name: tool.name,
-				description: tool.description,
-				inputSchema: inputJson,
-				...normalizedOutput && { outputSchema: normalizedOutput.jsonSchema },
-				...tool.annotations && { annotations: tool.annotations },
-				execute: tool.execute,
-				inputValidator: inputZod,
-				...normalizedOutput && { outputValidator: normalizedOutput.zodValidator }
-			};
-			this.provideContextTools.set(tool.name, validatedTool);
-		}
-		for (const resource of context.resources ?? []) {
-			if (this.dynamicResources.has(resource.uri)) throw new Error(`[Web Model Context] Resource URI collision: "${resource.uri}" is already registered via registerResource(). Please use a different URI or unregister the dynamic resource first.`);
-			const validatedResource = this.validateResource(resource);
-			this.provideContextResources.set(resource.uri, validatedResource);
-		}
-		for (const prompt of context.prompts ?? []) {
-			if (this.dynamicPrompts.has(prompt.name)) throw new Error(`[Web Model Context] Prompt name collision: "${prompt.name}" is already registered via registerPrompt(). Please use a different name or unregister the dynamic prompt first.`);
-			const validatedPrompt = this.validatePrompt(prompt);
-			this.provideContextPrompts.set(prompt.name, validatedPrompt);
-		}
-		this.updateBridgeTools();
-		this.updateBridgeResources();
-		this.updateBridgePrompts();
-		this.scheduleListChanged("tools");
-		this.scheduleListChanged("resources");
-		this.scheduleListChanged("prompts");
-	}
-	/**
-	* Validates and normalizes a resource descriptor.
-	* @private
-	*/
-	validateResource(resource) {
-		const templateParamRegex = /\{([^}]{1,100})\}/g;
-		const templateParams = [];
-		for (const match of resource.uri.matchAll(templateParamRegex)) {
-			const paramName = match[1];
-			templateParams.push(paramName);
-		}
-		return {
-			uri: resource.uri,
-			name: resource.name,
-			description: resource.description,
-			mimeType: resource.mimeType,
-			read: resource.read,
-			isTemplate: templateParams.length > 0,
-			templateParams
-		};
-	}
-	/**
-	* Validates and normalizes a prompt descriptor.
-	* @private
-	*/
-	validatePrompt(prompt) {
-		let argsSchema;
-		let argsValidator;
-		if (prompt.argsSchema) {
-			const normalized = normalizeSchema(prompt.argsSchema);
-			argsSchema = normalized.jsonSchema;
-			argsValidator = normalized.zodValidator;
-		}
-		return {
-			name: prompt.name,
-			description: prompt.description,
-			argsSchema,
-			get: prompt.get,
-			argsValidator
-		};
-	}
-	/**
-	* Registers a single tool dynamically (Bucket B).
-	* Dynamic tools persist across provideContext() calls and can be independently managed.
-	*
-	* @param {ToolDescriptor} tool - The tool descriptor to register
-	* @returns {{unregister: () => void}} Object with unregister function
-	* @throws {Error} If tool name collides with existing tools
-	*/
-	registerTool(tool) {
-		if (tool.name.startsWith("_")) logger$1.warn(`⚠️ Warning: Tool name "${tool.name}" starts with underscore. This may cause compatibility issues with some MCP clients. Consider using a letter as the first character.`);
-		if (/^[0-9]/.test(tool.name)) logger$1.warn(`⚠️ Warning: Tool name "${tool.name}" starts with a number. This may cause compatibility issues. Consider using a letter as the first character.`);
-		if (tool.name.startsWith("-")) logger$1.warn(`⚠️ Warning: Tool name "${tool.name}" starts with hyphen. This may cause compatibility issues. Consider using a letter as the first character.`);
-		const now = Date.now();
-		const lastRegistration = this.toolRegistrationTimestamps.get(tool.name);
-		if (lastRegistration && now - lastRegistration < RAPID_DUPLICATE_WINDOW_MS) {
-			logger$1.warn(`Tool "${tool.name}" registered multiple times within ${RAPID_DUPLICATE_WINDOW_MS}ms. This is likely due to React Strict Mode double-mounting. Ignoring duplicate registration.`);
-			const existingUnregister = this.toolUnregisterFunctions.get(tool.name);
-			if (existingUnregister) return { unregister: existingUnregister };
-		}
-		if (this.provideContextTools.has(tool.name)) throw new Error(`[Web Model Context] Tool name collision: "${tool.name}" is already registered via provideContext(). Please use a different name or update your provideContext() call.`);
-		if (this.dynamicTools.has(tool.name)) throw new Error(`[Web Model Context] Tool name collision: "${tool.name}" is already registered via registerTool(). Please unregister it first or use a different name.`);
-		const { jsonSchema: inputJson, zodValidator: inputZod } = normalizeSchema(tool.inputSchema);
-		const normalizedOutput = tool.outputSchema ? normalizeSchema(tool.outputSchema) : null;
-		const validatedTool = {
-			name: tool.name,
-			description: tool.description,
-			inputSchema: inputJson,
-			...normalizedOutput && { outputSchema: normalizedOutput.jsonSchema },
-			...tool.annotations && { annotations: tool.annotations },
-			execute: tool.execute,
-			inputValidator: inputZod,
-			...normalizedOutput && { outputValidator: normalizedOutput.zodValidator }
-		};
-		this.dynamicTools.set(tool.name, validatedTool);
-		this.toolRegistrationTimestamps.set(tool.name, now);
-		this.updateBridgeTools();
-		this.scheduleListChanged("tools");
-		const unregisterFn = () => {
-			if (this.provideContextTools.has(tool.name)) throw new Error(`[Web Model Context] Cannot unregister tool "${tool.name}": This tool was registered via provideContext(). Use provideContext() to update the base tool set.`);
-			if (!this.dynamicTools.has(tool.name)) {
-				logger$1.warn(`Tool "${tool.name}" is not registered, ignoring unregister call`);
-				return;
-			}
-			this.dynamicTools.delete(tool.name);
-			this.toolRegistrationTimestamps.delete(tool.name);
-			this.toolUnregisterFunctions.delete(tool.name);
-			this.updateBridgeTools();
-			this.scheduleListChanged("tools");
-		};
-		this.toolUnregisterFunctions.set(tool.name, unregisterFn);
-		return { unregister: unregisterFn };
-	}
-	/**
-	* Registers a single resource dynamically (Bucket B).
-	* Dynamic resources persist across provideContext() calls and can be independently managed.
-	*
-	* @param {ResourceDescriptor} resource - The resource descriptor to register
-	* @returns {{unregister: () => void}} Object with unregister function
-	* @throws {Error} If resource URI collides with existing resources
-	*/
-	registerResource(resource) {
-		const now = Date.now();
-		const lastRegistration = this.resourceRegistrationTimestamps.get(resource.uri);
-		if (lastRegistration && now - lastRegistration < RAPID_DUPLICATE_WINDOW_MS) {
-			logger$1.warn(`Resource "${resource.uri}" registered multiple times within ${RAPID_DUPLICATE_WINDOW_MS}ms. This is likely due to React Strict Mode double-mounting. Ignoring duplicate registration.`);
-			const existingUnregister = this.resourceUnregisterFunctions.get(resource.uri);
-			if (existingUnregister) return { unregister: existingUnregister };
-		}
-		if (this.provideContextResources.has(resource.uri)) throw new Error(`[Web Model Context] Resource URI collision: "${resource.uri}" is already registered via provideContext(). Please use a different URI or update your provideContext() call.`);
-		if (this.dynamicResources.has(resource.uri)) throw new Error(`[Web Model Context] Resource URI collision: "${resource.uri}" is already registered via registerResource(). Please unregister it first or use a different URI.`);
-		const validatedResource = this.validateResource(resource);
-		this.dynamicResources.set(resource.uri, validatedResource);
-		this.resourceRegistrationTimestamps.set(resource.uri, now);
-		this.updateBridgeResources();
-		this.scheduleListChanged("resources");
-		const unregisterFn = () => {
-			if (this.provideContextResources.has(resource.uri)) throw new Error(`[Web Model Context] Cannot unregister resource "${resource.uri}": This resource was registered via provideContext(). Use provideContext() to update the base resource set.`);
-			if (!this.dynamicResources.has(resource.uri)) {
-				logger$1.warn(`Resource "${resource.uri}" is not registered, ignoring unregister call`);
-				return;
-			}
-			this.dynamicResources.delete(resource.uri);
-			this.resourceRegistrationTimestamps.delete(resource.uri);
-			this.resourceUnregisterFunctions.delete(resource.uri);
-			this.updateBridgeResources();
-			this.scheduleListChanged("resources");
-		};
-		this.resourceUnregisterFunctions.set(resource.uri, unregisterFn);
-		return { unregister: unregisterFn };
-	}
-	/**
-	* Unregisters a resource by URI.
-	* Can unregister resources from either Bucket A (provideContext) or Bucket B (registerResource).
-	*
-	* @param {string} uri - URI of the resource to unregister
-	*/
-	unregisterResource(uri) {
-		const inProvideContext = this.provideContextResources.has(uri);
-		const inDynamic = this.dynamicResources.has(uri);
-		if (!inProvideContext && !inDynamic) {
-			logger$1.warn(`Resource "${uri}" is not registered, ignoring unregister call`);
-			return;
-		}
-		if (inProvideContext) this.provideContextResources.delete(uri);
-		if (inDynamic) {
-			this.dynamicResources.delete(uri);
-			this.resourceRegistrationTimestamps.delete(uri);
-			this.resourceUnregisterFunctions.delete(uri);
-		}
-		this.updateBridgeResources();
-		this.scheduleListChanged("resources");
-	}
-	/**
-	* Lists all registered resources in MCP format.
-	* Returns static resources from both buckets (not templates).
-	*
-	* @returns {Resource[]} Array of resource descriptors
-	*/
-	listResources() {
-		return Array.from(this.bridge.resources.values()).filter((r) => !r.isTemplate).map((resource) => ({
-			uri: resource.uri,
-			name: resource.name,
-			description: resource.description,
-			mimeType: resource.mimeType
-		}));
-	}
-	/**
-	* Lists all registered resource templates.
-	* Returns only resources with URI templates (dynamic resources).
-	*
-	* @returns {Array<{uriTemplate: string, name: string, description?: string, mimeType?: string}>}
-	*/
-	listResourceTemplates() {
-		return Array.from(this.bridge.resources.values()).filter((r) => r.isTemplate).map((resource) => ({
-			uriTemplate: resource.uri,
-			name: resource.name,
-			...resource.description !== void 0 && { description: resource.description },
-			...resource.mimeType !== void 0 && { mimeType: resource.mimeType }
-		}));
-	}
-	/**
-	* Registers a single prompt dynamically (Bucket B).
-	* Dynamic prompts persist across provideContext() calls and can be independently managed.
-	*
-	* @param {PromptDescriptor} prompt - The prompt descriptor to register
-	* @returns {{unregister: () => void}} Object with unregister function
-	* @throws {Error} If prompt name collides with existing prompts
-	*/
-	registerPrompt(prompt) {
-		const now = Date.now();
-		const lastRegistration = this.promptRegistrationTimestamps.get(prompt.name);
-		if (lastRegistration && now - lastRegistration < RAPID_DUPLICATE_WINDOW_MS) {
-			logger$1.warn(`Prompt "${prompt.name}" registered multiple times within ${RAPID_DUPLICATE_WINDOW_MS}ms. This is likely due to React Strict Mode double-mounting. Ignoring duplicate registration.`);
-			const existingUnregister = this.promptUnregisterFunctions.get(prompt.name);
-			if (existingUnregister) return { unregister: existingUnregister };
-		}
-		if (this.provideContextPrompts.has(prompt.name)) throw new Error(`[Web Model Context] Prompt name collision: "${prompt.name}" is already registered via provideContext(). Please use a different name or update your provideContext() call.`);
-		if (this.dynamicPrompts.has(prompt.name)) throw new Error(`[Web Model Context] Prompt name collision: "${prompt.name}" is already registered via registerPrompt(). Please unregister it first or use a different name.`);
-		const validatedPrompt = this.validatePrompt(prompt);
-		this.dynamicPrompts.set(prompt.name, validatedPrompt);
-		this.promptRegistrationTimestamps.set(prompt.name, now);
-		this.updateBridgePrompts();
-		this.scheduleListChanged("prompts");
-		const unregisterFn = () => {
-			if (this.provideContextPrompts.has(prompt.name)) throw new Error(`[Web Model Context] Cannot unregister prompt "${prompt.name}": This prompt was registered via provideContext(). Use provideContext() to update the base prompt set.`);
-			if (!this.dynamicPrompts.has(prompt.name)) {
-				logger$1.warn(`Prompt "${prompt.name}" is not registered, ignoring unregister call`);
-				return;
-			}
-			this.dynamicPrompts.delete(prompt.name);
-			this.promptRegistrationTimestamps.delete(prompt.name);
-			this.promptUnregisterFunctions.delete(prompt.name);
-			this.updateBridgePrompts();
-			this.scheduleListChanged("prompts");
-		};
-		this.promptUnregisterFunctions.set(prompt.name, unregisterFn);
-		return { unregister: unregisterFn };
-	}
-	/**
-	* Unregisters a prompt by name.
-	* Can unregister prompts from either Bucket A (provideContext) or Bucket B (registerPrompt).
-	*
-	* @param {string} name - Name of the prompt to unregister
-	*/
-	unregisterPrompt(name) {
-		const inProvideContext = this.provideContextPrompts.has(name);
-		const inDynamic = this.dynamicPrompts.has(name);
-		if (!inProvideContext && !inDynamic) {
-			logger$1.warn(`Prompt "${name}" is not registered, ignoring unregister call`);
-			return;
-		}
-		if (inProvideContext) this.provideContextPrompts.delete(name);
-		if (inDynamic) {
-			this.dynamicPrompts.delete(name);
-			this.promptRegistrationTimestamps.delete(name);
-			this.promptUnregisterFunctions.delete(name);
-		}
-		this.updateBridgePrompts();
-		this.scheduleListChanged("prompts");
-	}
-	/**
-	* Lists all registered prompts in MCP format.
-	* Returns prompts from both buckets.
-	*
-	* @returns {Prompt[]} Array of prompt descriptors
-	*/
-	listPrompts() {
-		return Array.from(this.bridge.prompts.values()).map((prompt) => ({
-			name: prompt.name,
-			description: prompt.description,
-			arguments: prompt.argsSchema?.properties ? Object.entries(prompt.argsSchema.properties).map(([name, schema]) => ({
-				name,
-				description: schema.description,
-				required: prompt.argsSchema?.required?.includes(name) ?? false
-			})) : void 0
-		}));
-	}
-	/**
-	* Unregisters a tool by name (Chromium native API).
-	* Can unregister tools from either Bucket A (provideContext) or Bucket B (registerTool).
-	*
-	* @param {string} name - Name of the tool to unregister
-	*/
-	unregisterTool(name) {
-		const inProvideContext = this.provideContextTools.has(name);
-		const inDynamic = this.dynamicTools.has(name);
-		if (!inProvideContext && !inDynamic) {
-			logger$1.warn(`Tool "${name}" is not registered, ignoring unregister call`);
-			return;
-		}
-		if (inProvideContext) this.provideContextTools.delete(name);
-		if (inDynamic) {
-			this.dynamicTools.delete(name);
-			this.toolRegistrationTimestamps.delete(name);
-			this.toolUnregisterFunctions.delete(name);
-		}
-		this.updateBridgeTools();
-		this.scheduleListChanged("tools");
-	}
-	/**
-	* Clears all registered context from both buckets (Chromium native API).
-	* Removes all tools, resources, and prompts registered via provideContext() and register* methods.
-	*/
-	clearContext() {
-		this.provideContextTools.clear();
-		this.dynamicTools.clear();
-		this.toolRegistrationTimestamps.clear();
-		this.toolUnregisterFunctions.clear();
-		this.provideContextResources.clear();
-		this.dynamicResources.clear();
-		this.resourceRegistrationTimestamps.clear();
-		this.resourceUnregisterFunctions.clear();
-		this.provideContextPrompts.clear();
-		this.dynamicPrompts.clear();
-		this.promptRegistrationTimestamps.clear();
-		this.promptUnregisterFunctions.clear();
-		this.updateBridgeTools();
-		this.updateBridgeResources();
-		this.updateBridgePrompts();
-		this.scheduleListChanged("tools");
-		this.scheduleListChanged("resources");
-		this.scheduleListChanged("prompts");
-	}
-	/**
-	* Updates the bridge tools map with merged tools from both buckets.
-	* The final tool list is the union of Bucket A (provideContext) and Bucket B (dynamic).
-	*
-	* @private
-	*/
-	updateBridgeTools() {
-		this.bridge.tools.clear();
-		for (const [name, tool] of this.provideContextTools) this.bridge.tools.set(name, tool);
-		for (const [name, tool] of this.dynamicTools) this.bridge.tools.set(name, tool);
-	}
-	/**
-	* Notifies all servers and testing callbacks that the tools list has changed.
-	* Sends MCP notifications to connected servers and invokes registered testing callbacks.
-	*
-	* @private
-	*/
-	notifyToolsListChanged() {
-		if (this.bridge.tabServer.notification) this.bridge.tabServer.notification({
-			method: "notifications/tools/list_changed",
-			params: {}
-		});
-		if (this.bridge.iframeServer?.notification) this.bridge.iframeServer.notification({
-			method: "notifications/tools/list_changed",
-			params: {}
-		});
-		if (this.testingAPI && "notifyToolsChanged" in this.testingAPI) this.testingAPI.notifyToolsChanged();
-	}
-	/**
-	* Updates the bridge resources map with merged resources from both buckets.
-	*
-	* @private
-	*/
-	updateBridgeResources() {
-		this.bridge.resources.clear();
-		for (const [uri, resource] of this.provideContextResources) this.bridge.resources.set(uri, resource);
-		for (const [uri, resource] of this.dynamicResources) this.bridge.resources.set(uri, resource);
-	}
-	/**
-	* Notifies all servers that the resources list has changed.
-	*
-	* @private
-	*/
-	notifyResourcesListChanged() {
-		if (this.bridge.tabServer.notification) this.bridge.tabServer.notification({
-			method: "notifications/resources/list_changed",
-			params: {}
-		});
-		if (this.bridge.iframeServer?.notification) this.bridge.iframeServer.notification({
-			method: "notifications/resources/list_changed",
-			params: {}
-		});
-	}
-	/**
-	* Updates the bridge prompts map with merged prompts from both buckets.
-	*
-	* @private
-	*/
-	updateBridgePrompts() {
-		this.bridge.prompts.clear();
-		for (const [name, prompt] of this.provideContextPrompts) this.bridge.prompts.set(name, prompt);
-		for (const [name, prompt] of this.dynamicPrompts) this.bridge.prompts.set(name, prompt);
-	}
-	/**
-	* Notifies all servers that the prompts list has changed.
-	*
-	* @private
-	*/
-	notifyPromptsListChanged() {
-		if (this.bridge.tabServer.notification) this.bridge.tabServer.notification({
-			method: "notifications/prompts/list_changed",
-			params: {}
-		});
-		if (this.bridge.iframeServer?.notification) this.bridge.iframeServer.notification({
-			method: "notifications/prompts/list_changed",
-			params: {}
-		});
-	}
-	/**
-	* Schedules a list changed notification using microtask batching.
-	* Multiple calls for the same list type within the same task are coalesced
-	* into a single notification. This dramatically reduces notification spam
-	* during React mount/unmount cycles.
-	*
-	* @param listType - The type of list that changed ('tools' | 'resources' | 'prompts')
-	* @private
-	*/
-	scheduleListChanged(listType) {
-		if (this.pendingNotifications.has(listType)) return;
-		this.pendingNotifications.add(listType);
-		queueMicrotask(() => {
-			this.pendingNotifications.delete(listType);
-			switch (listType) {
-				case "tools":
-					this.notifyToolsListChanged();
-					break;
-				case "resources":
-					this.notifyResourcesListChanged();
-					break;
-				case "prompts":
-					this.notifyPromptsListChanged();
-					break;
-				default: {
-					const _exhaustive = listType;
-					logger$1.error(`Unknown list type: ${_exhaustive}`);
-				}
-			}
-		});
-	}
-	/**
-	* Reads a resource by URI (internal use only by MCP bridge).
-	* Handles both static resources and URI templates.
-	*
-	* @param {string} uri - The URI of the resource to read
-	* @returns {Promise<{contents: ResourceContents[]}>} The resource contents
-	* @throws {Error} If resource is not found
-	* @internal
-	*/
-	async readResource(uri) {
-		const staticResource = this.bridge.resources.get(uri);
-		if (staticResource && !staticResource.isTemplate) try {
-			let parsedUri;
-			try {
-				parsedUri = new URL(uri);
-			} catch {
-				parsedUri = new URL(`custom-scheme:///${encodeURIComponent(uri)}`);
-				parsedUri.originalUri = uri;
-			}
-			return await staticResource.read(parsedUri);
-		} catch (error) {
-			logger$1.error(`Error reading resource ${uri}:`, error);
-			throw error;
-		}
-		for (const resource of this.bridge.resources.values()) {
-			if (!resource.isTemplate) continue;
-			const params = this.matchUriTemplate(resource.uri, uri);
-			if (params) try {
-				let parsedUri;
-				try {
-					parsedUri = new URL(uri);
-				} catch {
-					parsedUri = new URL(`custom-scheme:///${encodeURIComponent(uri)}`);
-					parsedUri.originalUri = uri;
-				}
-				return await resource.read(parsedUri, params);
-			} catch (error) {
-				logger$1.error(`Error reading resource ${uri}:`, error);
-				throw error;
-			}
-		}
-		throw new Error(`Resource not found: ${uri}`);
-	}
-	/**
-	* Matches a URI against a URI template and extracts parameters.
-	*
-	* @param {string} template - The URI template (e.g., "file://{path}")
-	* @param {string} uri - The actual URI to match
-	* @returns {Record<string, string> | null} Extracted parameters or null if no match
-	* @private
-	*/
-	matchUriTemplate(template, uri) {
-		const paramNames = [];
-		let regexPattern = template.replace(/[.*+?^${}()|[\]\\]/g, (char) => {
-			if (char === "{" || char === "}") return char;
-			return `\\${char}`;
-		});
-		regexPattern = regexPattern.replace(/\{([^}]+)\}/g, (_, paramName) => {
-			paramNames.push(paramName);
-			return "(.+)";
-		});
-		const regex = /* @__PURE__ */ new RegExp(`^${regexPattern}$`);
-		const match = uri.match(regex);
-		if (!match) return null;
-		const params = {};
-		for (let i = 0; i < paramNames.length; i++) {
-			const paramName = paramNames[i];
-			params[paramName] = match[i + 1];
-		}
-		return params;
-	}
-	/**
-	* Gets a prompt with arguments (internal use only by MCP bridge).
-	*
-	* @param {string} name - Name of the prompt
-	* @param {Record<string, unknown>} args - Arguments to pass to the prompt
-	* @returns {Promise<{messages: PromptMessage[]}>} The prompt messages
-	* @throws {Error} If prompt is not found
-	* @internal
-	*/
-	async getPrompt(name, args) {
-		const prompt = this.bridge.prompts.get(name);
-		if (!prompt) throw new Error(`Prompt not found: ${name}`);
-		if (prompt.argsValidator && args) {
-			const validation = validateWithZod(args, prompt.argsValidator);
-			if (!validation.success) {
-				logger$1.error(`Argument validation failed for prompt ${name}:`, validation.error);
-				throw new Error(`Argument validation error for prompt "${name}":\n${validation.error}`);
-			}
-		}
-		try {
-			return await prompt.get(args ?? {});
-		} catch (error) {
-			logger$1.error(`Error getting prompt ${name}:`, error);
-			throw error;
-		}
-	}
-	/**
-	* Executes a tool with validation and event dispatch.
-	* Follows this sequence:
-	* 1. Validates input arguments against schema
-	* 2. Records tool call in testing API (if available)
-	* 3. Checks for mock response (if testing)
-	* 4. Dispatches 'toolcall' event to listeners
-	* 5. Executes tool function if not prevented
-	* 6. Validates output (permissive mode - warns only)
-	*
-	* @param {string} toolName - Name of the tool to execute
-	* @param {Record<string, unknown>} args - Arguments to pass to the tool
-	* @returns {Promise<ToolResponse>} The tool's response
-	* @throws {Error} If tool is not found
-	* @internal
-	*/
-	async executeTool(toolName, args) {
-		const tool = this.bridge.tools.get(toolName);
-		if (!tool) throw new Error(`Tool not found: ${toolName}`);
-		const validation = validateWithZod(args, tool.inputValidator);
-		if (!validation.success) {
-			logger$1.error(`Input validation failed for ${toolName}:`, validation.error);
-			return {
-				content: [{
-					type: "text",
-					text: `Input validation error for tool "${toolName}":\n${validation.error}`
-				}],
-				isError: true
-			};
-		}
-		const validatedArgs = validation.data;
-		if (this.testingAPI) this.testingAPI.recordToolCall(toolName, validatedArgs);
-		if (this.testingAPI?.hasMockResponse(toolName)) {
-			const mockResponse = this.testingAPI.getMockResponse(toolName);
-			if (mockResponse) return mockResponse;
-		}
-		const event = new WebToolCallEvent(toolName, validatedArgs);
-		this.dispatchEvent(event);
-		if (event.defaultPrevented && event.hasResponse()) {
-			const response = event.getResponse();
-			if (response) return response;
-		}
-		try {
-			const response = await tool.execute(validatedArgs);
-			if (tool.outputValidator && response.structuredContent) {
-				const outputValidation = validateWithZod(response.structuredContent, tool.outputValidator);
-				if (!outputValidation.success) logger$1.warn(`Output validation failed for ${toolName}:`, outputValidation.error);
-			}
-			if (response.metadata && typeof response.metadata === "object" && "willNavigate" in response.metadata) logger$1.info(`Tool "${toolName}" will trigger navigation`, response.metadata);
-			return response;
-		} catch (error) {
-			logger$1.error(`Error executing tool ${toolName}:`, error);
-			return {
-				content: [{
-					type: "text",
-					text: `Error: ${error instanceof Error ? error.message : String(error)}`
-				}],
-				isError: true
-			};
-		}
-	}
-	/**
-	* Lists all registered tools in MCP format.
-	* Returns tools from both buckets with full MCP specification including
-	* annotations and output schemas.
-	*
-	* @returns {Array<{name: string, description: string, inputSchema: InputSchema, outputSchema?: InputSchema, annotations?: ToolAnnotations}>} Array of tool descriptors
-	*/
-	listTools() {
-		return Array.from(this.bridge.tools.values()).map((tool) => ({
-			name: tool.name,
-			description: tool.description,
-			inputSchema: tool.inputSchema,
-			...tool.outputSchema && { outputSchema: tool.outputSchema },
-			...tool.annotations && { annotations: tool.annotations }
-		}));
-	}
-	/**
-	* Request an LLM completion from the connected client.
-	* This sends a sampling request to the connected MCP client.
-	*
-	* @param {SamplingRequestParams} params - Parameters for the sampling request
-	* @returns {Promise<SamplingResult>} The LLM completion result
-	*/
-	async createMessage(params) {
-		const underlyingServer = this.bridge.tabServer.server;
-		if (!underlyingServer?.createMessage) throw new Error("Sampling is not supported: no connected client with sampling capability");
-		return underlyingServer.createMessage(params);
-	}
-	/**
-	* Request user input from the connected client.
-	* This sends an elicitation request to the connected MCP client.
-	*
-	* @param {ElicitationParams} params - Parameters for the elicitation request
-	* @returns {Promise<ElicitationResult>} The user's response
-	*/
-	async elicitInput(params) {
-		const underlyingServer = this.bridge.tabServer.server;
-		if (!underlyingServer?.elicitInput) throw new Error("Elicitation is not supported: no connected client with elicitation capability");
-		return underlyingServer.elicitInput(params);
-	}
-};
-/**
-* Initializes the MCP bridge with dual-server support.
-* Creates TabServer for same-window communication and optionally IframeChildServer
-* for parent-child iframe communication.
-*
-* @param {WebModelContextInitOptions} [options] - Configuration options
-* @returns {MCPBridge} The initialized MCP bridge
-*/
-function initializeMCPBridge(options) {
-	const hostname = window.location.hostname || "localhost";
-	const transportOptions = options?.transport;
-	const setupServerHandlers = (server, bridge$1) => {
-		server.setRequestHandler(ListToolsRequestSchema, async () => {
-			return { tools: bridge$1.modelContext.listTools() };
-		});
-		server.setRequestHandler(CallToolRequestSchema, async (request) => {
-			const toolName = request.params.name;
-			const args = request.params.arguments || {};
-			try {
-				const response = await bridge$1.modelContext.executeTool(toolName, args);
-				return {
-					content: response.content,
-					isError: response.isError,
-					...response.structuredContent && { structuredContent: response.structuredContent }
-				};
-			} catch (error) {
-				bridgeLogger.error(`Error calling tool ${toolName}:`, error);
-				throw error;
-			}
-		});
-		server.setRequestHandler(ListResourcesRequestSchema, async () => {
-			return { resources: bridge$1.modelContext.listResources() };
-		});
-		server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-			try {
-				return await bridge$1.modelContext.readResource(request.params.uri);
-			} catch (error) {
-				bridgeLogger.error(`Error reading resource ${request.params.uri}:`, error);
-				throw error;
-			}
-		});
-		server.setRequestHandler(ListPromptsRequestSchema, async () => {
-			return { prompts: bridge$1.modelContext.listPrompts() };
-		});
-		server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-			try {
-				return await bridge$1.modelContext.getPrompt(request.params.name, request.params.arguments);
-			} catch (error) {
-				bridgeLogger.error(`Error getting prompt ${request.params.name}:`, error);
-				throw error;
-			}
-		});
-	};
-	const customTransport = transportOptions?.create?.();
-	if (customTransport) {
-		const server = new Server({
-			name: hostname,
-			version: "1.0.0"
-		}, { capabilities: {
-			tools: { listChanged: true },
-			resources: { listChanged: true },
-			prompts: { listChanged: true }
-		} });
-		const bridge$1 = {
-			tabServer: server,
-			tools: /* @__PURE__ */ new Map(),
-			resources: /* @__PURE__ */ new Map(),
-			prompts: /* @__PURE__ */ new Map(),
-			modelContext: void 0,
-			isInitialized: true
-		};
-		bridge$1.modelContext = new WebModelContext(bridge$1);
-		setupServerHandlers(server, bridge$1);
-		server.connect(customTransport);
-		return bridge$1;
-	}
-	const tabServerEnabled = transportOptions?.tabServer !== false;
-	const tabServer = new Server({
-		name: `${hostname}-tab`,
-		version: "1.0.0"
-	}, { capabilities: {
-		tools: { listChanged: true },
-		resources: { listChanged: true },
-		prompts: { listChanged: true }
-	} });
-	const bridge = {
-		tabServer,
-		tools: /* @__PURE__ */ new Map(),
-		resources: /* @__PURE__ */ new Map(),
-		prompts: /* @__PURE__ */ new Map(),
-		modelContext: void 0,
-		isInitialized: true
-	};
-	bridge.modelContext = new WebModelContext(bridge);
-	setupServerHandlers(tabServer, bridge);
-	if (tabServerEnabled) {
-		const { allowedOrigins,...restTabServerOptions } = typeof transportOptions?.tabServer === "object" ? transportOptions.tabServer : {};
-		const tabTransport = new TabServerTransport({
-			allowedOrigins: allowedOrigins ?? ["*"],
-			...restTabServerOptions
-		});
-		tabServer.connect(tabTransport);
-	}
-	const isInIframe = typeof window !== "undefined" && window.parent !== window;
-	const iframeServerConfig = transportOptions?.iframeServer;
-	if (iframeServerConfig !== false && (iframeServerConfig !== void 0 || isInIframe)) {
-		const iframeServer = new Server({
-			name: `${hostname}-iframe`,
-			version: "1.0.0"
-		}, { capabilities: {
-			tools: { listChanged: true },
-			resources: { listChanged: true },
-			prompts: { listChanged: true }
-		} });
-		setupServerHandlers(iframeServer, bridge);
-		const { allowedOrigins,...restIframeServerOptions } = typeof iframeServerConfig === "object" ? iframeServerConfig : {};
-		const iframeTransport = new IframeChildTransport({
-			allowedOrigins: allowedOrigins ?? ["*"],
-			...restIframeServerOptions
-		});
-		iframeServer.connect(iframeTransport);
-		bridge.iframeServer = iframeServer;
-	}
-	return bridge;
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`Invalid serialized tool response for ${name}`);
+		return parsed;
+	});
 }
-/**
-* Initializes the Web Model Context API on window.navigator.
-* Creates and exposes navigator.modelContext and navigator.modelContextTesting.
-* Automatically detects and uses native Chromium implementation if available.
-*
-* @param {WebModelContextInitOptions} [options] - Configuration options
-* @throws {Error} If initialization fails
-* @example
-* ```typescript
-* import { initializeWebModelContext } from '@mcp-b/global';
-*
-* initializeWebModelContext({
-*   transport: {
-*     tabServer: {
-*       allowedOrigins: ['https://example.com']
-*     }
-*   }
-* });
-* ```
-*/
 function initializeWebModelContext(options) {
-	/* c8 ignore next 4 */
-	if (typeof window === "undefined") {
-		logger$1.warn("Not in browser environment, skipping initialization");
-		return;
-	}
-	const effectiveOptions = options ?? window.__webModelContextOptions;
-	const native = detectNativeAPI();
-	if (native.hasNativeContext && native.hasNativeTesting) {
-		const nativeContext = window.navigator.modelContext;
-		const nativeTesting = window.navigator.modelContextTesting;
-		if (!nativeContext || !nativeTesting) {
-			logger$1.error("Native API detection mismatch");
-			return;
-		}
-		logger$1.info("✅ Native Chromium API detected");
-		logger$1.info("   Using native implementation with MCP bridge synchronization");
-		logger$1.info("   Native API will automatically collect tools from embedded iframes");
-		try {
-			const bridge = initializeMCPBridge(effectiveOptions);
-			bridge.modelContext = new NativeModelContextAdapter(bridge, nativeContext, nativeTesting);
-			bridge.modelContextTesting = nativeTesting;
-			Object.defineProperty(window, "__mcpBridge", {
-				value: bridge,
-				writable: false,
-				configurable: true
-			});
-			logger$1.info("✅ MCP bridge synced with native API");
-			logger$1.info("   MCP clients will receive automatic tool updates from native registry");
-		} catch (error) {
-			logger$1.error("Failed to initialize native adapter:", error);
-			throw error;
-		}
-		return;
-	}
-	if (native.hasNativeContext && !native.hasNativeTesting) {
-		logger$1.warn("Partial native API detected");
-		logger$1.warn("   navigator.modelContext exists but navigator.modelContextTesting is missing");
-		logger$1.warn("   Cannot sync with native API. Please enable experimental features:");
-		logger$1.warn("      - Navigate to chrome://flags");
-		logger$1.warn("      - Enable \"Experimental Web Platform Features\"");
-		logger$1.warn("      - Or launch with: --enable-experimental-web-platform-features");
-		logger$1.warn("   Skipping initialization to avoid conflicts");
-		return;
-	}
-	if (window.navigator.modelContext) {
-		logger$1.warn("window.navigator.modelContext already exists, skipping initialization");
-		return;
-	}
-	logger$1.info("Native API not detected, installing polyfill");
-	try {
-		const bridge = initializeMCPBridge(effectiveOptions);
-		Object.defineProperty(window.navigator, "modelContext", {
-			value: bridge.modelContext,
-			writable: false,
-			configurable: false
-		});
-		Object.defineProperty(window, "__mcpBridge", {
-			value: bridge,
-			writable: false,
-			configurable: true
-		});
-		logger$1.info("✅ window.navigator.modelContext initialized successfully");
-		testingLogger.info("Installing polyfill");
-		testingLogger.info("   💡 To use the native implementation in Chromium:");
-		testingLogger.info("      - Navigate to chrome://flags");
-		testingLogger.info("      - Enable \"Experimental Web Platform Features\"");
-		testingLogger.info("      - Or launch with: --enable-experimental-web-platform-features");
-		const testingAPI = new WebModelContextTesting(bridge);
-		bridge.modelContextTesting = testingAPI;
-		bridge.modelContext.setTestingAPI(testingAPI);
-		Object.defineProperty(window.navigator, "modelContextTesting", {
-			value: testingAPI,
-			writable: false,
-			configurable: true
-		});
-		testingLogger.info("✅ Polyfill installed at window.navigator.modelContextTesting");
-	} catch (error) {
-		logger$1.error("Failed to initialize:", error);
-		throw error;
-	}
+	if (!isBrowserEnvironment()) return;
+	if (runtime) return;
+	initializeWebMCPPolyfill({ installTestingShim: options?.installTestingShim ?? "if-missing" });
+	const native = navigator.modelContext;
+	if (!native) throw new Error("navigator.modelContext is not available");
+	const server = new BrowserMcpServer({
+		name: `${window.location.hostname || "localhost"}-webmcp`,
+		version: "1.0.0"
+	}, { native });
+	server.syncNativeTools();
+	syncToolsFromTestingShim(server);
+	replaceModelContext(server);
+	const transport = createTransport(options?.transport);
+	runtime = {
+		native,
+		server,
+		transport
+	};
+	server.connect(transport).catch((error) => {
+		console.error("[WebModelContext] Failed to connect MCP transport:", error);
+	});
 }
-/**
-* Cleans up the Web Model Context API.
-* Closes all MCP servers and removes API from window.navigator.
-* Useful for testing and hot module replacement.
-*
-* @example
-* ```typescript
-* import { cleanupWebModelContext } from '@mcp-b/global';
-*
-* cleanupWebModelContext();
-* ```
-*/
 function cleanupWebModelContext() {
-	/* c8 ignore next */
-	if (typeof window === "undefined") return;
-	if (window.__mcpBridge) try {
-		window.__mcpBridge.tabServer.close();
-		if (window.__mcpBridge.iframeServer) window.__mcpBridge.iframeServer.close();
-	} catch (error) {
-		logger$1.warn("Error closing MCP servers:", error);
-	}
-	delete window.navigator.modelContext;
-	delete window.navigator.modelContextTesting;
-	delete window.__mcpBridge;
-	logger$1.info("Cleaned up");
+	if (!runtime) return;
+	const { native, server, transport } = runtime;
+	runtime = null;
+	server.close();
+	transport.close();
+	replaceModelContext(native);
 }
 
 //#endregion
 //#region src/index.ts
-const logger = createLogger("WebModelContext");
-function mergeTransportOptions(base, override) {
-	if (!base) return override;
-	if (!override) return base;
-	return {
-		...base,
-		...override,
-		tabServer: {
-			...base.tabServer ?? {},
-			...override.tabServer ?? {}
-		}
-	};
-}
-function mergeInitOptions(base, override) {
-	if (!base) return override;
-	if (!override) return base;
-	return {
-		...base,
-		...override,
-		transport: mergeTransportOptions(base.transport ?? {}, override.transport ?? {})
-	};
-}
-function parseScriptTagOptions(script) {
-	if (!script || !script.dataset) return;
-	const { dataset } = script;
-	if (dataset.webmcpOptions) try {
-		return JSON.parse(dataset.webmcpOptions);
-	} catch (error) {
-		logger.error("Invalid JSON in data-webmcp-options:", error);
-		return;
-	}
-	const options = {};
-	let hasOptions = false;
-	if (dataset.webmcpAutoInitialize !== void 0) {
-		options.autoInitialize = dataset.webmcpAutoInitialize !== "false";
-		hasOptions = true;
-	}
-	const tabServerOptions = {};
-	let hasTabServerOptions = false;
-	if (dataset.webmcpAllowedOrigins) {
-		const origins = dataset.webmcpAllowedOrigins.split(",").map((origin) => origin.trim()).filter((origin) => origin.length > 0);
-		if (origins.length > 0) {
-			tabServerOptions.allowedOrigins = origins;
-			hasOptions = true;
-			hasTabServerOptions = true;
-		}
-	}
-	if (dataset.webmcpChannelId) {
-		tabServerOptions.channelId = dataset.webmcpChannelId;
-		hasOptions = true;
-		hasTabServerOptions = true;
-	}
-	if (hasTabServerOptions) options.transport = {
-		...options.transport ?? {},
-		tabServer: {
-			...options.transport?.tabServer ?? {},
-			...tabServerOptions
-		}
-	};
-	return hasOptions ? options : void 0;
-}
 if (typeof window !== "undefined" && typeof document !== "undefined") {
-	const globalOptions = window.__webModelContextOptions;
-	const scriptElement = document.currentScript;
-	const scriptOptions = parseScriptTagOptions(scriptElement);
-	const mergedOptions = mergeInitOptions(globalOptions, scriptOptions) ?? globalOptions ?? scriptOptions;
-	if (mergedOptions) window.__webModelContextOptions = mergedOptions;
-	const shouldAutoInitialize = mergedOptions?.autoInitialize !== false;
-	try {
-		if (shouldAutoInitialize) initializeWebModelContext(mergedOptions);
+	const options = window.__webModelContextOptions;
+	if (options?.autoInitialize !== false) try {
+		initializeWebModelContext(options);
 	} catch (error) {
-		logger.error("Auto-initialization failed:", error);
+		console.error("[WebModelContext] Auto-initialization failed:", error);
 	}
 }
 
 //#endregion
-export { cleanupWebModelContext, createLogger, initializeWebModelContext, zodToJsonSchema };
+export { cleanupWebModelContext, initializeWebModelContext };
 //# sourceMappingURL=index.js.map