archgen-skill 0.1.1 → 0.1.2

package/lib/node_modules/archgen-mcp/node_modules/@modelcontextprotocol/server/dist/listenRouter-Bartj63y.mjs

@@ -0,0 +1,426 @@
+import { v as DEFAULT_SSE_KEEP_ALIVE_MS, y as armSseKeepAlive } from "./mcp-oHn3ureC.mjs";
+import { It as SERVER_INFO_META_KEY, Lt as SUBSCRIPTION_ID_META_KEY, ct as codecForVersion, st as MODERN_WIRE_REVISION } from "./src-DdvbAHrR.mjs";
+
+//#region src/server/serverEventBus.ts
+/**
+* A `ServerEventBus` backed by an in-process listener set.
+*
+* `publish()` delivers synchronously to the live listener set (a listener
+* unsubscribing itself mid-dispatch is safe; the entry's listen-router
+* listeners never unsubscribe peers). A throwing listener does not stop
+* delivery to the others.
+*/
+var InMemoryServerEventBus = class {
+	_listeners = /* @__PURE__ */ new Set();
+	/**
+	* @param onerror - Optional callback for errors thrown by listeners
+	*   during dispatch.
+	*/
+	constructor(onerror) {
+		this.onerror = onerror;
+	}
+	publish(event) {
+		for (const listener of this._listeners) try {
+			listener(event);
+		} catch (error) {
+			this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+	subscribe(listener) {
+		this._listeners.add(listener);
+		let live = true;
+		return () => {
+			if (!live) return;
+			live = false;
+			this._listeners.delete(listener);
+		};
+	}
+	/** The number of currently registered listeners (test/introspection only — the routers track capacity via their own open-subscription set). */
+	get listenerCount() {
+		return this._listeners.size;
+	}
+};
+/** Build a {@linkcode ServerNotifier} over a bus. */
+function createServerNotifier(bus) {
+	return {
+		toolsChanged: () => bus.publish({ kind: "tools_list_changed" }),
+		promptsChanged: () => bus.publish({ kind: "prompts_list_changed" }),
+		resourcesChanged: () => bus.publish({ kind: "resources_list_changed" }),
+		resourceUpdated: (uri) => bus.publish({
+			kind: "resource_updated",
+			uri
+		})
+	};
+}
+/**
+* Whether a `subscriptions/listen` filter accepts a given change event.
+*
+* Pure: no I/O, no mutation. The filter governs ONLY the four
+* subscription-gated change types — non-gated notifications never reach the
+* bus and are not modeled here.
+*
+* `resource_updated` matches only when `resourceSubscriptions` is present and
+* contains the event's URI exactly (per the spec: "for these resource URIs").
+*/
+function listenFilterAccepts(filter, event) {
+	switch (event.kind) {
+		case "tools_list_changed": return filter.toolsListChanged === true;
+		case "prompts_list_changed": return filter.promptsListChanged === true;
+		case "resources_list_changed": return filter.resourcesListChanged === true;
+		case "resource_updated": return filter.resourceSubscriptions !== void 0 && filter.resourceSubscriptions.includes(event.uri);
+	}
+}
+/**
+* The honored subset of a requested filter: keeps only the fields the client
+* explicitly opted in to (drops `false` and absent fields), narrowed against
+* the server's declared capabilities when supplied. The serving entry sends
+* this back in `notifications/subscriptions/acknowledged` so the ack reflects
+* what the server can actually deliver.
+*
+* - `toolsListChanged` is honored only when `capabilities.tools.listChanged`
+*   is advertised; likewise `promptsListChanged` / `resourcesListChanged`.
+* - `resourceSubscriptions` is honored only when
+*   `capabilities.resources.subscribe` is advertised.
+*
+* `capabilities` is optional on this pure helper for test convenience only —
+* both wired routers REQUIRE capabilities at the call site (the HTTP router's
+* `serve()` takes a required parameter; `StdioListenRouter.serve()` throws
+* before `setServerCapabilities()` was called), so the fail-open
+* `undefined → honor everything` branch is never reachable on a wired entry.
+*/
+function honoredSubset(requested, capabilities) {
+	const honored = {};
+	const allow = (bit) => capabilities === void 0 || bit === true;
+	if (requested.toolsListChanged === true && allow(capabilities?.tools?.listChanged)) honored.toolsListChanged = true;
+	if (requested.promptsListChanged === true && allow(capabilities?.prompts?.listChanged)) honored.promptsListChanged = true;
+	if (requested.resourcesListChanged === true && allow(capabilities?.resources?.listChanged)) honored.resourcesListChanged = true;
+	if (requested.resourceSubscriptions !== void 0 && requested.resourceSubscriptions.length > 0 && allow(capabilities?.resources?.subscribe)) honored.resourceSubscriptions = [...requested.resourceSubscriptions];
+	return honored;
+}
+/** Map a {@linkcode ServerEvent} onto its wire notification `{method, params}`. */
+function serverEventToNotification(event) {
+	switch (event.kind) {
+		case "tools_list_changed": return {
+			method: "notifications/tools/list_changed",
+			...event.params !== void 0 && { params: event.params }
+		};
+		case "prompts_list_changed": return {
+			method: "notifications/prompts/list_changed",
+			...event.params !== void 0 && { params: event.params }
+		};
+		case "resources_list_changed": return {
+			method: "notifications/resources/list_changed",
+			...event.params !== void 0 && { params: event.params }
+		};
+		case "resource_updated": return {
+			method: "notifications/resources/updated",
+			params: {
+				...event.params,
+				uri: event.uri
+			}
+		};
+	}
+}
+
+//#endregion
+//#region src/server/listenRouter.ts
+/** Default capacity guard: refuse a new subscription when this many are already open. */
+const DEFAULT_MAX_SUBSCRIPTIONS = 1024;
+function jsonRpcError(id, code, message) {
+	return Response.json({
+		jsonrpc: "2.0",
+		error: {
+			code,
+			message
+		},
+		id
+	}, { status: 200 });
+}
+/** Stamp the subscription id onto a notification's `_meta`. Non-mutating. */
+function stampSubscriptionId(notification, subscriptionId) {
+	return {
+		method: notification.method,
+		params: {
+			...notification.params,
+			_meta: {
+				...notification.params?._meta,
+				[SUBSCRIPTION_ID_META_KEY]: subscriptionId
+			}
+		}
+	};
+}
+/**
+* Read the requested filter off a `subscriptions/listen` request body.
+* Returns the validated filter, or `undefined` when `params.notifications`
+* is absent or fails the schema (the caller answers `-32602` — the spec
+* marks `notifications` REQUIRED on the listen request).
+*/
+function parseListenFilter(message) {
+	const outcome = codecForVersion(MODERN_WIRE_REVISION).validateRequest("subscriptions/listen", message);
+	return outcome.ok ? outcome.value.params?.notifications : void 0;
+}
+function createListenRouter(options) {
+	const { bus, onerror } = options;
+	const maxSubscriptions = options.maxSubscriptions ?? DEFAULT_MAX_SUBSCRIPTIONS;
+	const keepAliveMs = options.keepAliveMs ?? DEFAULT_SSE_KEEP_ALIVE_MS;
+	const open = /* @__PURE__ */ new Set();
+	function serve(message, signal, capabilities, serverInfo) {
+		if (open.size >= maxSubscriptions) {
+			onerror?.(/* @__PURE__ */ new Error(`subscriptions/listen refused: subscription limit reached (${maxSubscriptions})`));
+			return jsonRpcError(message.id, -32603, "Subscription limit reached");
+		}
+		const filter = parseListenFilter(message);
+		if (filter === void 0) return jsonRpcError(message.id, -32602, "Invalid params: 'notifications' is required and must be a valid SubscriptionFilter");
+		const honored = honoredSubset(filter, capabilities);
+		const subscriptionId = message.id;
+		const encoder = new TextEncoder();
+		let controller;
+		let closed = false;
+		let unsubscribe;
+		let keepAliveTimer;
+		let abortCleanup;
+		const writeFrame = (frame) => {
+			if (closed) return;
+			try {
+				controller.enqueue(encoder.encode(frame));
+			} catch (error) {
+				onerror?.(error instanceof Error ? error : new Error(String(error)));
+			}
+		};
+		const writeNotification = (method, params) => {
+			writeFrame(`event: message\ndata: ${JSON.stringify({
+				jsonrpc: "2.0",
+				method,
+				params
+			})}\n\n`);
+		};
+		const teardown = (graceful) => {
+			if (closed) return;
+			if (graceful) writeFrame(`event: message\ndata: ${JSON.stringify({
+				jsonrpc: "2.0",
+				id: subscriptionId,
+				result: {
+					resultType: "complete",
+					_meta: {
+						[SUBSCRIPTION_ID_META_KEY]: subscriptionId,
+						[SERVER_INFO_META_KEY]: serverInfo
+					}
+				}
+			})}\n\n`);
+			closed = true;
+			try {
+				unsubscribe?.();
+			} catch (error) {
+				onerror?.(error instanceof Error ? error : new Error(String(error)));
+			}
+			if (keepAliveTimer !== void 0) clearInterval(keepAliveTimer);
+			abortCleanup?.();
+			open.delete(teardown);
+			try {
+				controller.close();
+			} catch {}
+		};
+		const readable = new ReadableStream({
+			start(streamController) {
+				controller = streamController;
+				const ack = stampSubscriptionId({
+					method: "notifications/subscriptions/acknowledged",
+					params: { notifications: honored }
+				}, subscriptionId);
+				writeNotification(ack.method, ack.params);
+				if (Object.keys(honored).length === 0) {
+					teardown(true);
+					return;
+				}
+				unsubscribe = bus.subscribe((event) => {
+					if (closed || !listenFilterAccepts(honored, event)) return;
+					const note = stampSubscriptionId(serverEventToNotification(event), subscriptionId);
+					writeNotification(note.method, note.params);
+				});
+				keepAliveTimer = armSseKeepAlive(keepAliveMs, () => writeFrame(": keepalive\n\n"));
+				open.add(teardown);
+			},
+			cancel() {
+				teardown(false);
+			}
+		});
+		if (signal !== void 0) if (signal.aborted) teardown(false);
+		else {
+			const onAbort = () => teardown(false);
+			signal.addEventListener("abort", onAbort, { once: true });
+			abortCleanup = () => signal.removeEventListener("abort", onAbort);
+		}
+		return new Response(readable, {
+			status: 200,
+			headers: {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache, no-transform",
+				Connection: "keep-alive",
+				"X-Accel-Buffering": "no"
+			}
+		});
+	}
+	return {
+		serve,
+		closeAll() {
+			for (const teardown of open) teardown(true);
+		},
+		get openCount() {
+			return open.size;
+		}
+	};
+}
+const CHANGE_NOTIFICATION_METHODS = new Set([
+	"notifications/tools/list_changed",
+	"notifications/prompts/list_changed",
+	"notifications/resources/list_changed",
+	"notifications/resources/updated"
+]);
+/**
+* Per-connection listen state for the stdio entry. One instance is held by
+* `serveStdio` for the connection lifetime; it routes inbound
+* `subscriptions/listen` / `notifications/cancelled` and rewrites outbound
+* change notifications onto the active subscriptions. No bus — the long-lived
+* pinned instance's existing `send*ListChanged()` calls feed straight into
+* `routeOutbound()`.
+*/
+var StdioListenRouter = class {
+	/** Active subscriptions, keyed by the listen request's JSON-RPC id verbatim. */
+	_subs = /* @__PURE__ */ new Map();
+	/**
+	* The serving instance's declared capabilities. Filled in by the entry
+	* once the modern instance is constructed (the router is created before
+	* the instance exists), so the acknowledged filter is narrowed against
+	* what the server can actually deliver.
+	*/
+	_serverCapabilities;
+	/**
+	* The serving instance's identity, stamped onto the graceful-close
+	* results' `_meta` (the spec's `SubscriptionsListenResultMetaObject` extends
+	* `ResultMetaObject`). Handed over together with the capabilities.
+	*/
+	_serverInfo;
+	constructor(_maxSubscriptions = DEFAULT_MAX_SUBSCRIPTIONS, serverCapabilities, serverInfo) {
+		this._maxSubscriptions = _maxSubscriptions;
+		this._serverCapabilities = serverCapabilities;
+		this._serverInfo = serverInfo;
+	}
+	/**
+	* Record the serving instance's declared capabilities and identity once
+	* it has been constructed. Called by `serveStdio`'s connect path;
+	* subsequent `serve()` calls narrow the honored filter against the
+	* capabilities, and `teardownAll()` stamps the identity.
+	*/
+	setServerCapabilities(capabilities, serverInfo) {
+		this._serverCapabilities = capabilities;
+		if (serverInfo !== void 0) this._serverInfo = serverInfo;
+	}
+	/** Whether `id` is an active listen subscription on this connection. */
+	has(id) {
+		return this._subs.has(id);
+	}
+	/**
+	* Serve one inbound `subscriptions/listen` request: registers the
+	* subscription and returns the stamped acknowledged notification (or, on
+	* capacity / params rejection, the in-band JSON-RPC error response).
+	*
+	* @throws when called before {@linkcode setServerCapabilities} (or the
+	* constructor) has supplied the serving instance's capabilities. Honoring a
+	* filter without knowing the server's advertised capabilities would fail
+	* open (deliver unadvertised types); the entry guarantees capabilities are
+	* set before any listen request is routed here.
+	*/
+	serve(message) {
+		if (this._serverCapabilities === void 0) throw new Error("StdioListenRouter.serve() called before setServerCapabilities(); refusing to honor a filter without capabilities");
+		if (this._subs.size >= this._maxSubscriptions) return {
+			jsonrpc: "2.0",
+			id: message.id,
+			error: {
+				code: -32603,
+				message: "Subscription limit reached"
+			}
+		};
+		const filter = parseListenFilter(message);
+		if (filter === void 0) return {
+			jsonrpc: "2.0",
+			id: message.id,
+			error: {
+				code: -32602,
+				message: "Invalid params: 'notifications' is required and must be a valid SubscriptionFilter"
+			}
+		};
+		const honored = honoredSubset(filter, this._serverCapabilities);
+		this._subs.set(message.id, honored);
+		return stampSubscriptionId({
+			method: "notifications/subscriptions/acknowledged",
+			params: { notifications: honored }
+		}, message.id);
+	}
+	/**
+	* Tear down one subscription (inbound `notifications/cancelled`). Returns
+	* `true` when a subscription was removed. After this call NOTHING further
+	* is delivered for that subscription id (the post-cancel hardening).
+	*/
+	cancel(id) {
+		return this._subs.delete(id);
+	}
+	/**
+	* Route an outbound notification through the active subscriptions.
+	*
+	* - For a subscription-gated change notification, returns one stamped copy
+	*   per subscription that opted in to it (an empty array means it is
+	*   dropped — the modern era never delivers an un-requested change type).
+	* - For any other outbound message, returns `'passthrough'` (the entry
+	*   forwards it as-is).
+	*/
+	routeOutbound(message) {
+		if (!CHANGE_NOTIFICATION_METHODS.has(message.method)) return "passthrough";
+		const uriParam = message.params?.["uri"];
+		const uri = typeof uriParam === "string" ? uriParam : void 0;
+		const event = notificationToServerEvent(message.method, uri);
+		const out = [];
+		for (const [subscriptionId, filter] of this._subs) if (listenFilterAccepts(filter, event)) out.push(stampSubscriptionId({
+			method: message.method,
+			params: message.params ?? {}
+		}, subscriptionId));
+		return out;
+	}
+	/**
+	* Server-side graceful teardown of every active subscription: returns the
+	* empty `subscriptions/listen` JSON-RPC result for each subscription id —
+	* the spec's graceful-close signal, `_meta` carrying the subscription id
+	* and the serving instance's identity — for the entry to emit before
+	* closing the wire. Clears the set so nothing further is delivered.
+	*/
+	teardownAll() {
+		const out = [];
+		for (const id of this._subs.keys()) out.push({
+			jsonrpc: "2.0",
+			id,
+			result: {
+				resultType: "complete",
+				_meta: {
+					[SUBSCRIPTION_ID_META_KEY]: id,
+					...this._serverInfo !== void 0 && { [SERVER_INFO_META_KEY]: this._serverInfo }
+				}
+			}
+		});
+		this._subs.clear();
+		return out;
+	}
+};
+function notificationToServerEvent(method, uri) {
+	switch (method) {
+		case "notifications/tools/list_changed": return { kind: "tools_list_changed" };
+		case "notifications/prompts/list_changed": return { kind: "prompts_list_changed" };
+		case "notifications/resources/list_changed": return { kind: "resources_list_changed" };
+		default: return {
+			kind: "resource_updated",
+			uri: uri ?? ""
+		};
+	}
+}
+
+//#endregion
+export { createServerNotifier as a, InMemoryServerEventBus as i, StdioListenRouter as n, createListenRouter as r, DEFAULT_MAX_SUBSCRIPTIONS as t };
+//# sourceMappingURL=listenRouter-Bartj63y.mjs.map

package/lib/node_modules/archgen-mcp/node_modules/@modelcontextprotocol/server/dist/listenRouter-Bartj63y.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"listenRouter-Bartj63y.mjs","names":["onerror?: (error: Error) => void","honored: SubscriptionFilter","controller!: ReadableStreamDefaultController<Uint8Array>","unsubscribe: (() => void) | undefined","keepAliveTimer: ReturnType<typeof setInterval> | undefined","abortCleanup: (() => void) | undefined","CHANGE_NOTIFICATION_METHODS: ReadonlySet<string>","_maxSubscriptions: number","uriParam: unknown","out: NotificationBody[]","out: ListenCloseFrame[]"],"sources":["../src/server/serverEventBus.ts","../src/server/listenRouter.ts"],"sourcesContent":["import type { JSONRPCNotification, ServerCapabilities, SubscriptionFilter } from '@modelcontextprotocol/core-internal';\n\n/**\n * A change event a server publishes for delivery on open `subscriptions/listen`\n * streams. Each variant maps onto exactly one notification method:\n *\n * - `tools_list_changed` → `notifications/tools/list_changed`\n * - `prompts_list_changed` → `notifications/prompts/list_changed`\n * - `resources_list_changed` → `notifications/resources/list_changed`\n * - `resource_updated` → `notifications/resources/updated` (carries the URI)\n *\n * The bus carries the event and any forwarded notification params — the\n * entry's listen router owns subscription-id stamping and per-stream filtering.\n */\nexport type ServerEvent = (\n    | { kind: 'tools_list_changed' }\n    | { kind: 'prompts_list_changed' }\n    | { kind: 'resources_list_changed' }\n    | { kind: 'resource_updated'; uri: string }\n) & {\n    /** Forwarded notification params; the router stamps its own subscription ID and the event's resource URI. */\n    params?: JSONRPCNotification['params'];\n};\n\n/**\n * The server-side change-event seam for `subscriptions/listen`.\n *\n * The serving entry (`createMcpHandler`) owns the per-stream listen router:\n * each open `subscriptions/listen` stream registers a listener via\n * `subscribe()`, and consumer code (typically via `handler.notify.*` sugar)\n * publishes change events via `publish()`. In-process servers can use the\n * default {@linkcode InMemoryServerEventBus}; multi-process deployments\n * implement this interface over their own pub/sub.\n *\n * The SDK owns wire semantics (ack-first, filtering, subscription-id\n * stamping, teardown); a `ServerEventBus` only sources the events. It MUST\n * NOT echo back to the listener that published an event when called from\n * inside that listener (no surprise here — the default delivers\n * synchronously and listeners never publish).\n */\nexport interface ServerEventBus {\n    /**\n     * Publish a change event to every registered listener.\n     */\n    publish(event: ServerEvent): void;\n    /**\n     * Register a listener; returns an idempotent unsubscribe function.\n     */\n    subscribe(listener: (event: ServerEvent) => void): () => void;\n}\n\n/**\n * A `ServerEventBus` backed by an in-process listener set.\n *\n * `publish()` delivers synchronously to the live listener set (a listener\n * unsubscribing itself mid-dispatch is safe; the entry's listen-router\n * listeners never unsubscribe peers). A throwing listener does not stop\n * delivery to the others.\n */\nexport class InMemoryServerEventBus implements ServerEventBus {\n    private readonly _listeners = new Set<(event: ServerEvent) => void>();\n\n    /**\n     * @param onerror - Optional callback for errors thrown by listeners\n     *   during dispatch.\n     */\n    constructor(private readonly onerror?: (error: Error) => void) {}\n\n    publish(event: ServerEvent): void {\n        for (const listener of this._listeners) {\n            try {\n                listener(event);\n            } catch (error) {\n                this.onerror?.(error instanceof Error ? error : new Error(String(error)));\n            }\n        }\n    }\n\n    subscribe(listener: (event: ServerEvent) => void): () => void {\n        this._listeners.add(listener);\n        let live = true;\n        return () => {\n            if (!live) return;\n            live = false;\n            this._listeners.delete(listener);\n        };\n    }\n\n    /** The number of currently registered listeners (test/introspection only — the routers track capacity via their own open-subscription set). */\n    get listenerCount(): number {\n        return this._listeners.size;\n    }\n}\n\n/**\n * Typed publish-side facade over `bus.publish` returned by `createMcpHandler`:\n * each method publishes the corresponding {@linkcode ServerEvent}. Prefer this\n * over calling `bus.publish` directly — the names match the wire methods.\n */\nexport interface ServerNotifier {\n    /** Publish `notifications/tools/list_changed` to every open subscription that opted in. */\n    toolsChanged(): void;\n    /** Publish `notifications/prompts/list_changed` to every open subscription that opted in. */\n    promptsChanged(): void;\n    /** Publish `notifications/resources/list_changed` to every open subscription that opted in. */\n    resourcesChanged(): void;\n    /** Publish `notifications/resources/updated` for `uri` to every open subscription that opted in to that URI. */\n    resourceUpdated(uri: string): void;\n}\n\n/** Build a {@linkcode ServerNotifier} over a bus. */\nexport function createServerNotifier(bus: ServerEventBus): ServerNotifier {\n    return {\n        toolsChanged: () => bus.publish({ kind: 'tools_list_changed' }),\n        promptsChanged: () => bus.publish({ kind: 'prompts_list_changed' }),\n        resourcesChanged: () => bus.publish({ kind: 'resources_list_changed' }),\n        resourceUpdated: (uri: string) => bus.publish({ kind: 'resource_updated', uri })\n    };\n}\n\n/**\n * Whether a `subscriptions/listen` filter accepts a given change event.\n *\n * Pure: no I/O, no mutation. The filter governs ONLY the four\n * subscription-gated change types — non-gated notifications never reach the\n * bus and are not modeled here.\n *\n * `resource_updated` matches only when `resourceSubscriptions` is present and\n * contains the event's URI exactly (per the spec: \"for these resource URIs\").\n */\nexport function listenFilterAccepts(filter: SubscriptionFilter, event: ServerEvent): boolean {\n    switch (event.kind) {\n        case 'tools_list_changed': {\n            return filter.toolsListChanged === true;\n        }\n        case 'prompts_list_changed': {\n            return filter.promptsListChanged === true;\n        }\n        case 'resources_list_changed': {\n            return filter.resourcesListChanged === true;\n        }\n        case 'resource_updated': {\n            return filter.resourceSubscriptions !== undefined && filter.resourceSubscriptions.includes(event.uri);\n        }\n    }\n}\n\n/**\n * The honored subset of a requested filter: keeps only the fields the client\n * explicitly opted in to (drops `false` and absent fields), narrowed against\n * the server's declared capabilities when supplied. The serving entry sends\n * this back in `notifications/subscriptions/acknowledged` so the ack reflects\n * what the server can actually deliver.\n *\n * - `toolsListChanged` is honored only when `capabilities.tools.listChanged`\n *   is advertised; likewise `promptsListChanged` / `resourcesListChanged`.\n * - `resourceSubscriptions` is honored only when\n *   `capabilities.resources.subscribe` is advertised.\n *\n * `capabilities` is optional on this pure helper for test convenience only —\n * both wired routers REQUIRE capabilities at the call site (the HTTP router's\n * `serve()` takes a required parameter; `StdioListenRouter.serve()` throws\n * before `setServerCapabilities()` was called), so the fail-open\n * `undefined → honor everything` branch is never reachable on a wired entry.\n */\nexport function honoredSubset(requested: SubscriptionFilter, capabilities?: ServerCapabilities): SubscriptionFilter {\n    const honored: SubscriptionFilter = {};\n    const allow = (bit: unknown): boolean => capabilities === undefined || bit === true;\n    if (requested.toolsListChanged === true && allow(capabilities?.tools?.listChanged)) honored.toolsListChanged = true;\n    if (requested.promptsListChanged === true && allow(capabilities?.prompts?.listChanged)) honored.promptsListChanged = true;\n    if (requested.resourcesListChanged === true && allow(capabilities?.resources?.listChanged)) honored.resourcesListChanged = true;\n    if (\n        requested.resourceSubscriptions !== undefined &&\n        requested.resourceSubscriptions.length > 0 &&\n        allow(capabilities?.resources?.subscribe)\n    ) {\n        honored.resourceSubscriptions = [...requested.resourceSubscriptions];\n    }\n    return honored;\n}\n\n/** Map a {@linkcode ServerEvent} onto its wire notification `{method, params}`. */\nexport function serverEventToNotification(event: ServerEvent): { method: string; params?: JSONRPCNotification['params'] } {\n    switch (event.kind) {\n        case 'tools_list_changed': {\n            return { method: 'notifications/tools/list_changed', ...(event.params !== undefined && { params: event.params }) };\n        }\n        case 'prompts_list_changed': {\n            return { method: 'notifications/prompts/list_changed', ...(event.params !== undefined && { params: event.params }) };\n        }\n        case 'resources_list_changed': {\n            return { method: 'notifications/resources/list_changed', ...(event.params !== undefined && { params: event.params }) };\n        }\n        case 'resource_updated': {\n            return { method: 'notifications/resources/updated', params: { ...event.params, uri: event.uri } };\n        }\n    }\n}\n","/**\n * The entry-handled `subscriptions/listen` router for the HTTP serving entry.\n *\n * `createMcpHandler` recognizes a modern-classified `subscriptions/listen`\n * request and routes it here: the entry owns ack-first, per-stream filtering,\n * subscription-id stamping, keepalive, capacity guarding, and teardown. The\n * consumer's factory IS constructed for listen, to read the instance's\n * declared `ServerCapabilities` only — the probe instance is never connected\n * and is closed immediately after the capabilities read. Token verification\n * and any per-request authorization still belong at the middleware layer\n * mounted in front of `createMcpHandler` (the entry's documented authz\n * posture).\n *\n * Per the spec at protocol revision 2026-07-28:\n * - The acknowledged notification is the FIRST message on the stream and\n *   carries the honored subset of the requested filter.\n * - Every notification on the stream (including the ack) carries the listen\n *   request's JSON-RPC id under `_meta['io.modelcontextprotocol/subscriptionId']`.\n * - The server MUST NOT deliver a notification type the client did not request.\n * - Server-side graceful close (`closeAll()`) emits the empty\n *   `subscriptions/listen` JSON-RPC result (the `SubscriptionsListenResult` —\n *   `_meta` carries the subscription id) before closing the stream; an abrupt\n *   transport close carries no response and the client treats it as a\n *   disconnect.\n */\nimport type {\n    Implementation,\n    JSONRPCRequest,\n    RequestId,\n    ServerCapabilities,\n    SubscriptionFilter\n} from '@modelcontextprotocol/core-internal';\nimport { codecForVersion, MODERN_WIRE_REVISION, SERVER_INFO_META_KEY, SUBSCRIPTION_ID_META_KEY } from '@modelcontextprotocol/core-internal';\n\nimport type { ServerEventBus } from './serverEventBus';\nimport { honoredSubset, listenFilterAccepts, serverEventToNotification } from './serverEventBus';\nimport { armSseKeepAlive, DEFAULT_SSE_KEEP_ALIVE_MS } from './sseKeepAlive';\n\n/** Default capacity guard: refuse a new subscription when this many are already open. */\nexport const DEFAULT_MAX_SUBSCRIPTIONS = 1024;\n\n/** Options for {@linkcode createListenRouter}. */\nexport interface ListenRouterOptions {\n    /** The event bus listen streams subscribe to. */\n    bus: ServerEventBus;\n    /** Reject a new listen with `-32603` when this many subscriptions are already open (default 1024). */\n    maxSubscriptions?: number;\n    /** SSE comment-frame keepalive interval; `0` disables keepalive (default 15000). */\n    keepAliveMs?: number;\n    /** Out-of-band error reporting (never alters the response). */\n    onerror?: (error: Error) => void;\n}\n\n/**\n * A wire-shape notification body (method + loose params).\n * @internal\n */\nexport interface NotificationBody {\n    method: string;\n    params: { _meta?: Record<string, unknown>; [key: string]: unknown };\n}\n\nfunction jsonRpcError(id: RequestId | null, code: number, message: string): Response {\n    return Response.json({ jsonrpc: '2.0', error: { code, message }, id }, { status: 200 });\n}\n\n/** Stamp the subscription id onto a notification's `_meta`. Non-mutating. */\nfunction stampSubscriptionId(\n    notification: { method: string; params?: { _meta?: Record<string, unknown>; [key: string]: unknown } },\n    subscriptionId: RequestId\n): NotificationBody {\n    return {\n        method: notification.method,\n        params: {\n            ...notification.params,\n            _meta: { ...notification.params?._meta, [SUBSCRIPTION_ID_META_KEY]: subscriptionId }\n        }\n    };\n}\n\n/**\n * Read the requested filter off a `subscriptions/listen` request body.\n * Returns the validated filter, or `undefined` when `params.notifications`\n * is absent or fails the schema (the caller answers `-32602` — the spec\n * marks `notifications` REQUIRED on the listen request).\n */\nexport function parseListenFilter(message: JSONRPCRequest): SubscriptionFilter | undefined {\n    // `subscriptions/listen` is 2026-only vocabulary; route through the era\n    // codec's request validator (the wire layer owns the filter schema).\n    const outcome = codecForVersion(MODERN_WIRE_REVISION).validateRequest('subscriptions/listen', message);\n    return outcome.ok ? outcome.value.params?.notifications : undefined;\n}\n\n/**\n * The HTTP listen router: holds the set of open subscriptions and serves\n * each listen request as an SSE response.\n */\nexport interface ListenRouter {\n    /**\n     * Serve one `subscriptions/listen` request and return the SSE `Response`\n     * (or, on capacity / params rejection, the in-band JSON-RPC error\n     * `Response`). The ack notification is the first SSE frame.\n     *\n     * `capabilities` is required: the acknowledged filter is always narrowed\n     * against what the serving instance advertises (honoring a filter without\n     * capabilities would fail open and deliver unadvertised types).\n     * `serverInfo` is the serving instance's identity, stamped onto the\n     * graceful-close result's `_meta` (the spec's `SubscriptionsListenResultMetaObject`\n     * extends `ResultMetaObject`, so the serverInfo SHOULD applies there too).\n     */\n    serve(message: JSONRPCRequest, signal: AbortSignal | undefined, capabilities: ServerCapabilities, serverInfo: Implementation): Response;\n    /**\n     * Gracefully close every open subscription stream: emits the empty\n     * `subscriptions/listen` JSON-RPC result (the spec's graceful-close\n     * signal) as the final SSE frame, then closes the stream.\n     */\n    closeAll(): void;\n    /** The number of currently open subscription streams (for tests / introspection). */\n    readonly openCount: number;\n}\n\nexport function createListenRouter(options: ListenRouterOptions): ListenRouter {\n    const { bus, onerror } = options;\n    const maxSubscriptions = options.maxSubscriptions ?? DEFAULT_MAX_SUBSCRIPTIONS;\n    const keepAliveMs = options.keepAliveMs ?? DEFAULT_SSE_KEEP_ALIVE_MS;\n\n    const open = new Set<(graceful: boolean) => void>();\n\n    function serve(\n        message: JSONRPCRequest,\n        signal: AbortSignal | undefined,\n        capabilities: ServerCapabilities,\n        serverInfo: Implementation\n    ): Response {\n        // Capacity guard, pre-ack: in-band -32603 on HTTP 200.\n        if (open.size >= maxSubscriptions) {\n            onerror?.(new Error(`subscriptions/listen refused: subscription limit reached (${maxSubscriptions})`));\n            return jsonRpcError(message.id, -32_603, 'Subscription limit reached');\n        }\n        const filter = parseListenFilter(message);\n        if (filter === undefined) {\n            return jsonRpcError(message.id, -32_602, \"Invalid params: 'notifications' is required and must be a valid SubscriptionFilter\");\n        }\n        const honored = honoredSubset(filter, capabilities);\n        // The spec carries the listen request's JSON-RPC id verbatim as the\n        // subscription id; demux is per-connection (each HTTP listen has its\n        // own SSE stream) so client-chosen ids cannot route across requests.\n        const subscriptionId = message.id;\n\n        const encoder = new TextEncoder();\n        let controller!: ReadableStreamDefaultController<Uint8Array>;\n        let closed = false;\n        let unsubscribe: (() => void) | undefined;\n        let keepAliveTimer: ReturnType<typeof setInterval> | undefined;\n        let abortCleanup: (() => void) | undefined;\n\n        const writeFrame = (frame: string) => {\n            if (closed) return;\n            try {\n                controller.enqueue(encoder.encode(frame));\n            } catch (error) {\n                onerror?.(error instanceof Error ? error : new Error(String(error)));\n            }\n        };\n        const writeNotification = (method: string, params: { _meta?: Record<string, unknown>; [key: string]: unknown }) => {\n            writeFrame(`event: message\\ndata: ${JSON.stringify({ jsonrpc: '2.0', method, params })}\\n\\n`);\n        };\n\n        const teardown = (graceful: boolean) => {\n            if (closed) return;\n            if (graceful) {\n                // Server-side graceful close: emit the empty\n                // `subscriptions/listen` JSON-RPC result before closing the\n                // stream so the client distinguishes graceful end from a\n                // transport drop. Written before `closed = true` so writeFrame\n                // still enqueues.\n                writeFrame(\n                    `event: message\\ndata: ${JSON.stringify({\n                        jsonrpc: '2.0',\n                        id: subscriptionId,\n                        result: {\n                            resultType: 'complete',\n                            _meta: { [SUBSCRIPTION_ID_META_KEY]: subscriptionId, [SERVER_INFO_META_KEY]: serverInfo }\n                        }\n                    })}\\n\\n`\n                );\n            }\n            closed = true;\n            try {\n                unsubscribe?.();\n            } catch (error) {\n                onerror?.(error instanceof Error ? error : new Error(String(error)));\n            }\n            if (keepAliveTimer !== undefined) clearInterval(keepAliveTimer);\n            abortCleanup?.();\n            open.delete(teardown);\n            try {\n                controller.close();\n            } catch {\n                // Already closed/cancelled by the consumer.\n            }\n        };\n\n        const readable = new ReadableStream<Uint8Array>({\n            start(streamController) {\n                controller = streamController;\n\n                // Ack-first MUST: the acknowledged notification is the first\n                // frame on the stream, stamped with the subscription id.\n                const ack = stampSubscriptionId(\n                    { method: 'notifications/subscriptions/acknowledged', params: { notifications: honored } },\n                    subscriptionId\n                );\n                writeNotification(ack.method, ack.params);\n\n                // Nothing honored means nothing can ever be delivered: complete the subscription instead of holding the stream.\n                if (Object.keys(honored).length === 0) {\n                    teardown(true);\n                    return;\n                }\n\n                // Only after the ack frame is enqueued does delivery activate.\n                unsubscribe = bus.subscribe(event => {\n                    if (closed || !listenFilterAccepts(honored, event)) return;\n                    const note = stampSubscriptionId(serverEventToNotification(event), subscriptionId);\n                    writeNotification(note.method, note.params);\n                });\n\n                keepAliveTimer = armSseKeepAlive(keepAliveMs, () => writeFrame(': keepalive\\n\\n'));\n\n                open.add(teardown);\n            },\n            cancel() {\n                // The client closed the SSE stream — the spec's HTTP cancel\n                // signal. Not a server-side graceful close, so no listen\n                // result is written (and the consumer is gone anyway).\n                teardown(false);\n            }\n        });\n\n        if (signal !== undefined) {\n            if (signal.aborted) {\n                teardown(false);\n            } else {\n                const onAbort = () => teardown(false);\n                signal.addEventListener('abort', onAbort, { once: true });\n                abortCleanup = () => signal.removeEventListener('abort', onAbort);\n            }\n        }\n\n        return new Response(readable, {\n            status: 200,\n            headers: {\n                'Content-Type': 'text/event-stream',\n                'Cache-Control': 'no-cache, no-transform',\n                Connection: 'keep-alive',\n                'X-Accel-Buffering': 'no'\n            }\n        });\n    }\n\n    return {\n        serve,\n        closeAll() {\n            for (const teardown of open) teardown(true);\n        },\n        get openCount() {\n            return open.size;\n        }\n    };\n}\n\n/* ------------------------------------------------------------------------ *\n * Stdio listen router\n * ------------------------------------------------------------------------ */\n\n/** A graceful-close `subscriptions/listen` result frame emitted by {@linkcode StdioListenRouter.teardownAll}. */\nexport interface ListenCloseFrame {\n    jsonrpc: '2.0';\n    id: RequestId;\n    result: {\n        resultType: 'complete';\n        _meta: { [SUBSCRIPTION_ID_META_KEY]: RequestId; [SERVER_INFO_META_KEY]?: Implementation };\n    };\n}\n\nconst CHANGE_NOTIFICATION_METHODS: ReadonlySet<string> = new Set([\n    'notifications/tools/list_changed',\n    'notifications/prompts/list_changed',\n    'notifications/resources/list_changed',\n    'notifications/resources/updated'\n]);\n\n/**\n * Per-connection listen state for the stdio entry. One instance is held by\n * `serveStdio` for the connection lifetime; it routes inbound\n * `subscriptions/listen` / `notifications/cancelled` and rewrites outbound\n * change notifications onto the active subscriptions. No bus — the long-lived\n * pinned instance's existing `send*ListChanged()` calls feed straight into\n * `routeOutbound()`.\n */\nexport class StdioListenRouter {\n    /** Active subscriptions, keyed by the listen request's JSON-RPC id verbatim. */\n    private readonly _subs = new Map<RequestId, SubscriptionFilter>();\n    /**\n     * The serving instance's declared capabilities. Filled in by the entry\n     * once the modern instance is constructed (the router is created before\n     * the instance exists), so the acknowledged filter is narrowed against\n     * what the server can actually deliver.\n     */\n    private _serverCapabilities: ServerCapabilities | undefined;\n    /**\n     * The serving instance's identity, stamped onto the graceful-close\n     * results' `_meta` (the spec's `SubscriptionsListenResultMetaObject` extends\n     * `ResultMetaObject`). Handed over together with the capabilities.\n     */\n    private _serverInfo: Implementation | undefined;\n\n    constructor(\n        private readonly _maxSubscriptions: number = DEFAULT_MAX_SUBSCRIPTIONS,\n        serverCapabilities?: ServerCapabilities,\n        serverInfo?: Implementation\n    ) {\n        this._serverCapabilities = serverCapabilities;\n        this._serverInfo = serverInfo;\n    }\n\n    /**\n     * Record the serving instance's declared capabilities and identity once\n     * it has been constructed. Called by `serveStdio`'s connect path;\n     * subsequent `serve()` calls narrow the honored filter against the\n     * capabilities, and `teardownAll()` stamps the identity.\n     */\n    setServerCapabilities(capabilities: ServerCapabilities, serverInfo?: Implementation): void {\n        this._serverCapabilities = capabilities;\n        if (serverInfo !== undefined) this._serverInfo = serverInfo;\n    }\n\n    /** Whether `id` is an active listen subscription on this connection. */\n    has(id: RequestId): boolean {\n        return this._subs.has(id);\n    }\n\n    /**\n     * Serve one inbound `subscriptions/listen` request: registers the\n     * subscription and returns the stamped acknowledged notification (or, on\n     * capacity / params rejection, the in-band JSON-RPC error response).\n     *\n     * @throws when called before {@linkcode setServerCapabilities} (or the\n     * constructor) has supplied the serving instance's capabilities. Honoring a\n     * filter without knowing the server's advertised capabilities would fail\n     * open (deliver unadvertised types); the entry guarantees capabilities are\n     * set before any listen request is routed here.\n     */\n    serve(message: JSONRPCRequest): NotificationBody | { jsonrpc: '2.0'; id: RequestId; error: { code: number; message: string } } {\n        if (this._serverCapabilities === undefined) {\n            throw new Error(\n                'StdioListenRouter.serve() called before setServerCapabilities(); refusing to honor a filter without capabilities'\n            );\n        }\n        if (this._subs.size >= this._maxSubscriptions) {\n            return { jsonrpc: '2.0', id: message.id, error: { code: -32_603, message: 'Subscription limit reached' } };\n        }\n        const filter = parseListenFilter(message);\n        if (filter === undefined) {\n            return {\n                jsonrpc: '2.0',\n                id: message.id,\n                error: { code: -32_602, message: \"Invalid params: 'notifications' is required and must be a valid SubscriptionFilter\" }\n            };\n        }\n        const honored = honoredSubset(filter, this._serverCapabilities);\n        this._subs.set(message.id, honored);\n        return stampSubscriptionId({ method: 'notifications/subscriptions/acknowledged', params: { notifications: honored } }, message.id);\n    }\n\n    /**\n     * Tear down one subscription (inbound `notifications/cancelled`). Returns\n     * `true` when a subscription was removed. After this call NOTHING further\n     * is delivered for that subscription id (the post-cancel hardening).\n     */\n    cancel(id: RequestId): boolean {\n        return this._subs.delete(id);\n    }\n\n    /**\n     * Route an outbound notification through the active subscriptions.\n     *\n     * - For a subscription-gated change notification, returns one stamped copy\n     *   per subscription that opted in to it (an empty array means it is\n     *   dropped — the modern era never delivers an un-requested change type).\n     * - For any other outbound message, returns `'passthrough'` (the entry\n     *   forwards it as-is).\n     */\n    routeOutbound(message: { method: string; params?: { [key: string]: unknown } }): NotificationBody[] | 'passthrough' {\n        if (!CHANGE_NOTIFICATION_METHODS.has(message.method)) {\n            return 'passthrough';\n        }\n        const uriParam: unknown = message.params?.['uri'];\n        const uri = typeof uriParam === 'string' ? uriParam : undefined;\n        const event = notificationToServerEvent(message.method, uri);\n        const out: NotificationBody[] = [];\n        for (const [subscriptionId, filter] of this._subs) {\n            if (listenFilterAccepts(filter, event)) {\n                out.push(stampSubscriptionId({ method: message.method, params: message.params ?? {} }, subscriptionId));\n            }\n        }\n        return out;\n    }\n\n    /**\n     * Server-side graceful teardown of every active subscription: returns the\n     * empty `subscriptions/listen` JSON-RPC result for each subscription id —\n     * the spec's graceful-close signal, `_meta` carrying the subscription id\n     * and the serving instance's identity — for the entry to emit before\n     * closing the wire. Clears the set so nothing further is delivered.\n     */\n    teardownAll(): ListenCloseFrame[] {\n        const out: ListenCloseFrame[] = [];\n        for (const id of this._subs.keys()) {\n            out.push({\n                jsonrpc: '2.0',\n                id,\n                result: {\n                    resultType: 'complete',\n                    _meta: {\n                        [SUBSCRIPTION_ID_META_KEY]: id,\n                        ...(this._serverInfo !== undefined && { [SERVER_INFO_META_KEY]: this._serverInfo })\n                    }\n                }\n            });\n        }\n        this._subs.clear();\n        return out;\n    }\n}\n\nfunction notificationToServerEvent(method: string, uri: string | undefined): import('./serverEventBus').ServerEvent {\n    switch (method) {\n        case 'notifications/tools/list_changed': {\n            return { kind: 'tools_list_changed' };\n        }\n        case 'notifications/prompts/list_changed': {\n            return { kind: 'prompts_list_changed' };\n        }\n        case 'notifications/resources/list_changed': {\n            return { kind: 'resources_list_changed' };\n        }\n        default: {\n            return { kind: 'resource_updated', uri: uri ?? '' };\n        }\n    }\n}\n"],"mappings":"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"}