@cyanmycelium/mcp-broker 1.3.4 → 1.4.0

package/dist/{chunk-J5TN5RYU.js → chunk-YTRVLPHP.js}

@@ -6,9 +6,9 @@ import * as nodePath from 'path';
 import { join, dirname, resolve, relative, isAbsolute, sep } from 'path';
 import { randomUUID, timingSafeEqual, X509Certificate, createPublicKey, verify } from 'crypto';
 import { WebSocket, WebSocketServer } from 'ws';
+import { McpAuthError, McpGrammar, McpBehavior, McpAdapterBase, McpToolResults, LoopbackTransport, McpServerBuilder, scopesOf as scopesOf$1, buildProtectedResourceMetadata, PROTECTED_RESOURCE_METADATA_PREFIX, bearerToken, buildChallengeHeader, createEventEmitter } from '@cyanmycelium/mcp-core';
 import { StdioTransport, StreamableHttpEndpoint } from '@cyanmycelium/mcp-core/node';
 import { spawn } from 'child_process';
-import { McpAuthError, McpGrammar, McpBehavior, McpAdapterBase, McpToolResults, LoopbackTransport, McpServerBuilder, scopesOf as scopesOf$1, buildProtectedResourceMetadata, PROTECTED_RESOURCE_METADATA_PREFIX, bearerToken, buildChallengeHeader } from '@cyanmycelium/mcp-core';
 import { fileURLToPath } from 'url';
 import { createRemoteJWKSet, jwtVerify, errors } from 'jose';
 import { createRequire } from 'module';
@@ -639,6 +639,14 @@ var BrokerInfoBehavior = class _BrokerInfoBehavior extends McpBehavior {
       namespace: _BrokerInfoBehavior.NAMESPACE
     });
   }
+  /**
+   * Always reads live. `McpBehavior` caches the content of its root
+   * resource on first read and never refreshes it, which suits static
+   * content but froze this snapshot at whatever the first reader saw.
+   */
+  readResourceAsync(uri) {
+    return this.adapter.readResourceAsync(uri);
+  }
   _buildResources() {
     return [
       {
@@ -665,10 +673,18 @@ var BrokerInfoBehavior = class _BrokerInfoBehavior extends McpBehavior {
 };
 var PROVIDERS_URI = "broker://providers";
 var PROVIDER_URI_TEMPLATE = "broker://providers/{name}";
+function providerUri(name) {
+  return `broker://providers/${encodeURIComponent(name)}`;
+}
 var BrokerProvidersAdapter = class extends McpAdapterBase {
   constructor(_context) {
     super("broker");
     this._context = _context;
+    _context.onProvidersChanged?.subscribe((names) => {
+      if (names.length === 0) return;
+      this._forwardResourceContentChanged(PROVIDERS_URI);
+      for (const name of new Set(names)) this._forwardResourceContentChanged(providerUri(name));
+    });
   }
   _context;
   async readResourceAsync(uri) {
@@ -721,6 +737,14 @@ var BrokerProvidersBehavior = class _BrokerProvidersBehavior extends McpBehavior
       namespace: _BrokerProvidersBehavior.NAMESPACE
     });
   }
+  /**
+   * Always reads live. `McpBehavior` caches the content of its root
+   * resource on first read and never refreshes it, which suits static
+   * content but froze this snapshot at whatever the first reader saw.
+   */
+  readResourceAsync(uri) {
+    return this.adapter.readResourceAsync(uri);
+  }
   _buildResources() {
     return [
       {
@@ -1070,6 +1094,28 @@ var GUIDE_PUBLISH_PROVIDER = [
   "serving. A throttled background tab answers pings and still never replies to a",
   "request; `providerRequestTimeoutMs` is what covers that case.",
   "",
+  "### Resource updates",
+  "",
+  "The broker answers `resources/subscribe` and `resources/unsubscribe` itself and",
+  "sends your provider **one** subscribe per URI, however many clients asked, and",
+  "one unsubscribe when the last of them leaves. Implement them the plain MCP way;",
+  "an mcp-core `McpServer` (1.3.0 or later) does it for you, and a behavior only",
+  "raises `onResourceUpdated(uri)` (an `McpAdapterBase` calls",
+  "`_forwardResourceContentChanged(uri)`).",
+  "",
+  "- Every `notifications/resources/updated` must carry `params.uri`, the exact",
+  "  string the client subscribed with. The broker delivers it to the sessions",
+  "  subscribed to that URI and to no one else. One without a usable `uri` is",
+  "  dropped and logged once per slot, never broadcast.",
+  "- After a reconnect the broker restores what clients still hold: it replays the",
+  "  last `initialize` a client sent on the slot, then `notifications/initialized`,",
+  "  then one `resources/subscribe` per URI. **Install your message handler before",
+  "  the socket opens**, or that handshake waits for `providerRequestTimeoutMs`.",
+  "  Each subscriber then gets one `notifications/resources/updated`, since the",
+  "  content may have changed while you were away.",
+  "- A URI you refuse on replay is dropped along with its subscribers; their",
+  "  re-read then fails, which is how they learn.",
+  "",
   "## 8. Refusals you can receive",
   "",
   "On the slot-scoped socket a refusal is a WebSocket close with code 1008; the",
@@ -1150,6 +1196,13 @@ var GUIDE_CONNECT_CLIENT = [
   "`broker://providers/{name}` and `broker://guide/{topic}`. It does not proxy any",
   "other provider. It is available from the moment the broker finishes starting.",
   "",
+  "`broker://providers` and `broker://providers/<name>` can be subscribed to: a",
+  "slot appearing, a provider attaching or detaching, a slot joining or leaving",
+  "`_all` each send `notifications/resources/updated`. Counters (`pendingCount`,",
+  "`clientCount`, `sessionCount`) never do, since reading moves them; read them",
+  "when you need them. A slot name is percent-encoded in its URI, so slot `a/b`",
+  "is `broker://providers/a%2Fb`.",
+  "",
   "### `_all`",
   "",
   "An aggregate, not a proxy. It presents the union of the tools and prompts of",
@@ -1183,6 +1236,26 @@ var GUIDE_CONNECT_CLIENT = [
   "changes its catalog. A client that subscribes sees a provider that arrives",
   "mid-session without reconnecting.",
   "",
+  "### Subscribing to resources",
+  "",
+  "On any slot but `_all`, `resources/subscribe` and `resources/unsubscribe` work on",
+  "every transport (WebSocket, SSE, Streamable HTTP, stdio). The broker keeps the",
+  "subscriptions per session and sends the provider one subscribe per URI, so N",
+  "clients cost the provider one. `notifications/resources/updated` reaches only",
+  "the sessions subscribed to that exact URI (no normalization); every other",
+  "notification is still broadcast to the whole slot.",
+  "",
+  "- Subscribing twice is one subscription; unsubscribing from something you do",
+  "  not hold succeeds.",
+  "- Closing the socket, the SSE stream, or sending `DELETE /<slot>/mcp` releases",
+  "  everything the session held. A Streamable HTTP session that is never deleted",
+  "  never expires, and neither do its subscriptions.",
+  "- Limits: 64 URIs per client, 1024 client subscriptions per slot, URIs of at",
+  "  most 2048 characters (`resourceSubscriptions` in the config). Past a limit the",
+  "  answer is `-32000`, an overlong URI `-32602`.",
+  "- If the provider disconnects, subscriptions are kept and restored when a",
+  "  provider comes back, followed by one `updated` per URI so you re-read.",
+  "",
   "## 4. Browser clients and the origin check",
   "",
   "All three HTTP client endpoints, `/<slot>/mcp`, `/<slot>/sse` and",
@@ -1444,7 +1517,8 @@ var GUIDE_DEPLOY = [
   '    "stdioUpstreams": [',
   '        { "name": "fs", "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/data"], "aggregate": true }',
   "    ],",
-  '    "mcpServers": [{ "name": "geo", "url": "https://geo.example.com/mcp" }]',
+  '    "mcpServers": [{ "name": "geo", "url": "https://geo.example.com/mcp" }],',
+  '    "resourceSubscriptions": { "maxSubscriptionsPerClient": 64, "maxSubscriptionsPerSlot": 1024, "maxResourceUriLength": 2048 }',
   "}",
   "```",
   "",
@@ -1513,6 +1587,9 @@ var GUIDE_TROUBLESHOOTING = [
   "| Browser provider gets a bare `error` event and never connects | provider auth is on; a browser cannot send the required header | run without a provider secret, or authenticate in a reverse proxy |",
   "| `-32601 Method not found` on `_all` for `resources/list` | `_all` covers tools and prompts only | connect to the provider's own slot for resources |",
   "| `-32602 Unknown aggregated tool` on a name you built yourself | prefixed names are capped, hashed and de-duplicated | re-run `tools/list` and pass the returned name back verbatim |",
+  "| Subscribed, but `notifications/resources/updated` never arrives | the provider's notification names a different URI (matching is exact), carries no `params.uri` (dropped and logged once), or your read grant was revoked (you were unsubscribed) | compare the URI byte for byte; check the broker log for a dropped update |",
+  "| `-32000 Subscription limit reached` | `maxSubscriptionsPerClient` or `maxSubscriptionsPerSlot` | unsubscribe what you no longer watch; raise the limit in `resourceSubscriptions` |",
+  "| `resourceSubscriptionCount` in `provider_status` only grows | Streamable HTTP clients leave without `DELETE`; their sessions and subscriptions never expire | send the DELETE on shutdown; restart the broker if the count is already large |",
   "",
   "## The transport/path mismatch, in detail",
   "",
@@ -1588,7 +1665,8 @@ var GUIDE_TROUBLESHOOTING = [
   "",
   "Streamable HTTP and SSE sessions do not expire. A client that closes its tab",
   "without sending `DELETE /<slot>/mcp` leaves its session alive, and every",
-  "notification the provider broadcasts is queued into it, without bound.",
+  "notification the provider broadcasts is queued into it, without bound, and",
+  "every resource subscription it took stays held, pinning the provider's own.",
   "",
   "The broker cannot tell a live session from an abandoned one, so no single",
   "reading proves a leak. `sessionCount` in `provider_status` growing monotonically",
@@ -2224,6 +2302,11 @@ var ResourcePathPattern = class _ResourcePathPattern {
 var STATIC_CAPABILITIES = {
   "resources/list": "mcp.resources.read",
   "resources/read": "mcp.resources.read",
+  "resources/templates/list": "mcp.resources.read",
+  // Subscribing is reading over time. Unsubscribing is deliberately absent:
+  // an unclassified method is not refused, and a client whose grant was
+  // revoked must still be able to drop what it holds.
+  "resources/subscribe": "mcp.resources.read",
   "tools/list": "mcp.tools.list",
   "prompts/list": "mcp.prompts.read",
   "prompts/get": "mcp.prompts.read",
@@ -2234,6 +2317,7 @@ var STATIC_CAPABILITIES = {
   "notifications/prompts/list_changed": "mcp.prompts.read"
 };
 var BROKER_READ_TOOLS = /* @__PURE__ */ new Set(["broker_info", "providers_list", "provider_status"]);
+var BROKER_READ_METHODS = /* @__PURE__ */ new Set(["tools/list", "resources/list", "resources/read", "resources/templates/list", "resources/subscribe", "notifications/resources/updated"]);
 function toolNameFrom(params) {
   if (typeof params !== "object" || params === null || Array.isArray(params)) return void 0;
   const name = params["name"];
@@ -2269,7 +2353,7 @@ var ConfiguredCapabilityClassifier = class {
     const method = operation.method;
     if (!method) return void 0;
     if (provider === "_broker") {
-      if (method === "tools/list" || method === "resources/list" || method === "resources/read") {
+      if (BROKER_READ_METHODS.has(method)) {
         return { capability: "broker.providers.read" };
       }
       if (method === "tools/call") {
@@ -2928,6 +3012,11 @@ var AggregateServer = class _AggregateServer {
   onOpen = null;
   onClose = null;
   onError = null;
+  /**
+   * Called with a slot name whenever it joins or leaves the aggregate, so the
+   * broker can announce the change on `broker://providers`.
+   */
+  onMembershipChanged = null;
   constructor(openClient) {
     this._openClient = openClient;
   }
@@ -2988,6 +3077,7 @@ var AggregateServer = class _AggregateServer {
     if (name === _AggregateServer.SLOT || this._sessions.has(name)) return;
     const session = new ProviderClientSession(name, this._openClient(name));
     this._sessions.set(name, session);
+    this.onMembershipChanged?.(name);
     session.onCatalogChanged = () => {
       this._catalog.setProvider(name, { tools: session.tools, prompts: session.prompts });
       this._emitListChanged();
@@ -3019,6 +3109,7 @@ var AggregateServer = class _AggregateServer {
     session.close();
     this._catalog.removeProvider(name);
     this._emitListChanged();
+    this.onMembershipChanged?.(name);
   }
   _subjectFor(principal) {
     if (principal?.subject) return principal.subject;
@@ -3476,6 +3567,263 @@ var pkg = require2("../package.json");
 var VERSION = pkg.version;
 var PACKAGE_NAME = pkg.name;
 
+// src/subscriptions/resource.subscription.registry.ts
+var DEFAULT_RESOURCE_SUBSCRIPTION_LIMITS = Object.freeze({
+  maxSubscriptionsPerClient: 64,
+  maxSubscriptionsPerSlot: 1024,
+  maxResourceUriLength: 2048
+});
+var SUBSCRIPTION_LIMIT_ERROR_CODE = -32e3;
+var OK = Object.freeze({ ok: true });
+var ResourceSubscriptionRegistry = class {
+  _upstream;
+  _limits;
+  /** slot → uri → entry. */
+  _slots = /* @__PURE__ */ new Map();
+  /**
+   * client → slot → URIs, counting subscriptions still being confirmed.
+   * Counting those is what makes the per-client limit hold under concurrent
+   * requests: a reservation is taken before the upstream call, not after.
+   */
+  _clients = /* @__PURE__ */ new Map();
+  /** slot → number of client/URI pairs, reserved ones included. */
+  _slotCounts = /* @__PURE__ */ new Map();
+  constructor(upstream, limits = {}) {
+    this._upstream = upstream;
+    this._limits = { ...DEFAULT_RESOURCE_SUBSCRIPTION_LIMITS, ...limits };
+  }
+  get limits() {
+    return this._limits;
+  }
+  /**
+   * Subscribes `client` to `uri` on `slot`. Idempotent: subscribing twice
+   * keeps one entry and answers success.
+   */
+  subscribe(slot, client, sink, uri) {
+    if (uri.length === 0) return Promise.resolve(failure(-32602, "Missing required parameter: uri"));
+    if (uri.length > this._limits.maxResourceUriLength) {
+      return Promise.resolve(
+        failure(-32602, `Resource URI is ${uri.length} characters long; this broker accepts at most ${this._limits.maxResourceUriLength} (maxResourceUriLength).`)
+      );
+    }
+    const alreadyHeld = this._clients.get(client)?.get(slot)?.has(uri) ?? false;
+    if (!alreadyHeld) {
+      if (this._clientTotal(client) >= this._limits.maxSubscriptionsPerClient) {
+        return Promise.resolve(
+          failure(
+            SUBSCRIPTION_LIMIT_ERROR_CODE,
+            `Subscription limit reached: this client already holds ${this._limits.maxSubscriptionsPerClient} resource subscriptions (maxSubscriptionsPerClient). Unsubscribe from one first.`
+          )
+        );
+      }
+      if ((this._slotCounts.get(slot) ?? 0) >= this._limits.maxSubscriptionsPerSlot) {
+        return Promise.resolve(
+          failure(
+            SUBSCRIPTION_LIMIT_ERROR_CODE,
+            `Subscription limit reached on slot "${slot}": it already holds ${this._limits.maxSubscriptionsPerSlot} client subscriptions (maxSubscriptionsPerSlot).`
+          )
+        );
+      }
+      this._reserve(slot, client, uri);
+    }
+    const entry = this._entry(slot, uri, true);
+    return this._enqueue(entry, async () => {
+      if (!this._isReserved(slot, client, uri)) return OK;
+      if (entry.state === "active") {
+        entry.subscribers.set(client, sink);
+        return OK;
+      }
+      entry.state = "subscribing";
+      const outcome = await this._upstream.request(slot, "resources/subscribe", uri);
+      if (outcome.ok) {
+        entry.state = "active";
+        if (this._isReserved(slot, client, uri)) entry.subscribers.set(client, sink);
+        return OK;
+      }
+      entry.state = "inactive";
+      this._release(slot, client, uri);
+      this._dropIfUnused(slot, uri, entry);
+      return outcome;
+    });
+  }
+  /**
+   * Unsubscribes `client` from `uri`. Always succeeds, including for a URI
+   * the client never subscribed to: the client asked not to be subscribed,
+   * and it is not. The provider is told only when the last subscriber leaves,
+   * and only when it is connected; its answer does not change ours.
+   */
+  unsubscribe(slot, client, uri) {
+    if (!this._isReserved(slot, client, uri)) return Promise.resolve(OK);
+    this._release(slot, client, uri);
+    const entry = this._entry(slot, uri, false);
+    if (!entry) return Promise.resolve(OK);
+    return this._enqueue(entry, async () => {
+      entry.subscribers.delete(client);
+      if (entry.subscribers.size > 0 || this._hasReservation(slot, uri)) return OK;
+      if (entry.state === "active" && this._upstream.isConnected(slot)) {
+        entry.state = "unsubscribing";
+        await this._upstream.request(slot, "resources/unsubscribe", uri);
+      }
+      entry.state = "inactive";
+      this._dropIfUnused(slot, uri, entry);
+      return OK;
+    });
+  }
+  /** Confirmed subscribers of `uri` on `slot`, the only ones a notification may reach. */
+  subscribers(slot, uri) {
+    const entry = this._slots.get(slot)?.get(uri);
+    if (!entry) return [];
+    return [...entry.subscribers].map(([client, sink]) => ({ client, sink }));
+  }
+  /** Where `uri` stands with the provider behind `slot`. */
+  stateOf(slot, uri) {
+    return this._slots.get(slot)?.get(uri)?.state ?? "inactive";
+  }
+  /** Number of client/URI pairs on `slot`, subscriptions being confirmed included. */
+  countFor(slot) {
+    return this._slotCounts.get(slot) ?? 0;
+  }
+  /** `true` when `slot` has at least one URI someone is subscribed to. */
+  hasSubscriptions(slot) {
+    for (const entry of this._slots.get(slot)?.values() ?? []) {
+      if (entry.subscribers.size > 0) return true;
+    }
+    return false;
+  }
+  /**
+   * Drops every subscription `client` holds, on every slot. Safe to call
+   * repeatedly and for a client that holds nothing.
+   */
+  async removeClient(client) {
+    const perSlot = this._clients.get(client);
+    if (!perSlot) return;
+    const pending = [];
+    for (const [slot, uris] of [...perSlot]) {
+      for (const uri of [...uris]) pending.push(this.unsubscribe(slot, client, uri));
+    }
+    await Promise.all(pending);
+  }
+  /**
+   * Records that the provider behind `slot` went away: whatever it had
+   * subscribed is gone with it. Subscribers are kept, so {@link replay} can
+   * restore them when a provider comes back.
+   */
+  providerDisconnected(slot) {
+    for (const entry of this._slots.get(slot)?.values() ?? []) entry.state = "inactive";
+  }
+  /**
+   * Re-sends one upstream `resources/subscribe` per URI that still has
+   * subscribers, after a provider (re)attached to `slot`. A URI the new
+   * provider refuses is dropped along with its subscribers, since nothing
+   * will ever notify them; the result lists them so the caller can tell them.
+   */
+  async replay(slot) {
+    const entries = [...this._slots.get(slot) ?? []].filter(([, entry]) => entry.subscribers.size > 0);
+    return Promise.all(
+      entries.map(
+        ([uri, entry]) => this._enqueue(entry, async () => {
+          const subscribers = [...entry.subscribers].map(([client, sink]) => ({ client, sink }));
+          if (entry.state === "active" || entry.subscribers.size === 0) return { uri, outcome: OK, subscribers };
+          entry.state = "subscribing";
+          const outcome = await this._upstream.request(slot, "resources/subscribe", uri);
+          if (outcome.ok) {
+            entry.state = "active";
+          } else {
+            entry.state = "inactive";
+            for (const { client } of subscribers) {
+              entry.subscribers.delete(client);
+              this._release(slot, client, uri);
+            }
+            this._dropIfUnused(slot, uri, entry);
+          }
+          return { uri, outcome, subscribers };
+        })
+      )
+    );
+  }
+  /** Forgets everything without calling upstream. Used when the broker stops. */
+  clear() {
+    this._slots.clear();
+    this._clients.clear();
+    this._slotCounts.clear();
+  }
+  // -------------------------------------------------------------------------
+  // Internals
+  // -------------------------------------------------------------------------
+  _enqueue(entry, op) {
+    const run = entry.tail.then(op);
+    entry.tail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  _entry(slot, uri, create) {
+    let uris = this._slots.get(slot);
+    if (!uris) {
+      if (!create) return void 0;
+      uris = /* @__PURE__ */ new Map();
+      this._slots.set(slot, uris);
+    }
+    let entry = uris.get(uri);
+    if (!entry && create) {
+      entry = { state: "inactive", subscribers: /* @__PURE__ */ new Map(), tail: Promise.resolve() };
+      uris.set(uri, entry);
+    }
+    return entry;
+  }
+  /** Removes an entry nobody holds or waits for, once its queue is idle. */
+  _dropIfUnused(slot, uri, entry) {
+    if (entry.subscribers.size > 0 || this._hasReservation(slot, uri) || entry.state !== "inactive") return;
+    const uris = this._slots.get(slot);
+    if (uris?.get(uri) !== entry) return;
+    uris.delete(uri);
+    if (uris.size === 0) this._slots.delete(slot);
+  }
+  _reserve(slot, client, uri) {
+    let perSlot = this._clients.get(client);
+    if (!perSlot) {
+      perSlot = /* @__PURE__ */ new Map();
+      this._clients.set(client, perSlot);
+    }
+    let uris = perSlot.get(slot);
+    if (!uris) {
+      uris = /* @__PURE__ */ new Set();
+      perSlot.set(slot, uris);
+    }
+    uris.add(uri);
+    this._slotCounts.set(slot, (this._slotCounts.get(slot) ?? 0) + 1);
+  }
+  _release(slot, client, uri) {
+    const perSlot = this._clients.get(client);
+    const uris = perSlot?.get(slot);
+    if (!uris?.delete(uri)) return;
+    if (uris.size === 0) perSlot.delete(slot);
+    if (perSlot.size === 0) this._clients.delete(client);
+    const count = (this._slotCounts.get(slot) ?? 1) - 1;
+    if (count > 0) this._slotCounts.set(slot, count);
+    else this._slotCounts.delete(slot);
+  }
+  _isReserved(slot, client, uri) {
+    return this._clients.get(client)?.get(slot)?.has(uri) ?? false;
+  }
+  /** `true` when some client reserved `uri` on `slot`, confirmed or not. */
+  _hasReservation(slot, uri) {
+    for (const perSlot of this._clients.values()) {
+      if (perSlot.get(slot)?.has(uri)) return true;
+    }
+    return false;
+  }
+  _clientTotal(client) {
+    let n = 0;
+    for (const uris of this._clients.get(client)?.values() ?? []) n += uris.size;
+    return n;
+  }
+};
+function failure(code, message) {
+  return { ok: false, error: { code, message } };
+}
+
 // src/ws/ws.tunnel.ts
 var MIME = {
   ".html": "text/html; charset=utf-8",
@@ -3499,6 +3847,7 @@ function requestIdOf(frame) {
   return void 0;
 }
 var BROKER_REQUEST_ID_PREFIX = "brk-";
+var STDIO_CLIENT_KEY = "stdio";
 var DEFAULT_PROVIDER_HEARTBEAT_MS = 3e4;
 var DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS = 6e4;
 var MAX_CLOSE_REASON_BYTES = 123;
@@ -3644,6 +3993,24 @@ var WsTunnel = class {
   /** Provider principals captured during successful WebSocket upgrades. */
   _pendingProviderPrincipals = /* @__PURE__ */ new WeakMap();
   _providerPrincipals = /* @__PURE__ */ new WeakMap();
+  /**
+   * `resources/subscribe` bookkeeping for every slot: who is subscribed to
+   * what, and the one upstream subscription per URI that stands for them.
+   */
+  _subscriptions;
+  /** Stable id per raw WS client socket, the WS part of a {@link ClientKey}. */
+  _wsClientIds = /* @__PURE__ */ new WeakMap();
+  _nextWsClientId = 1;
+  /** Stable id per in-process client, the internal part of a {@link ClientKey}. */
+  _internalClientIds = /* @__PURE__ */ new WeakMap();
+  _nextInternalClientId = 1;
+  /** Emitter behind {@link onProvidersChanged}. */
+  _providersChanged = createEventEmitter();
+  /** Slots changed since the last {@link _providersChanged} batch went out. */
+  _changedSlots = /* @__PURE__ */ new Set();
+  _changedSlotsTimer = null;
+  /** Slots already warned about for a malformed `notifications/resources/updated`. */
+  _invalidUpdateWarnedProviders = /* @__PURE__ */ new Set();
   constructor(options) {
     this._options = options;
     this._authGuard = options.auth ? new HttpAuthGuard(options.auth, options.mcpPath ?? "/mcp") : null;
@@ -3651,6 +4018,16 @@ var WsTunnel = class {
     this._allowedOrigins = originPredicate(options.allowedOrigins);
     this._authorization = options.authorization ?? options.auth?.authorization ?? null;
     this._slotResourceResolver = options.slotResourceResolver ?? this._authorization?.slotResourceResolver ?? options.auth?.slotResourceResolver ?? new DefaultSlotResourceResolver();
+    this._subscriptions = new ResourceSubscriptionRegistry(
+      {
+        request: (slot, method, uri) => this._subscriptionRequest(slot, method, uri),
+        isConnected: (slot) => {
+          const state = this._providers.get(slot);
+          return state !== void 0 && this._isProviderConnected(slot, state);
+        }
+      },
+      options.resourceSubscriptions
+    );
   }
   // -------------------------------------------------------------------------
   // IBrokerContext implementation
@@ -3725,6 +4102,10 @@ var WsTunnel = class {
       providers: this._aggregateServer?.providerNames ?? []
     };
   }
+  /** See {@link IBrokerContext.onProvidersChanged}. */
+  get onProvidersChanged() {
+    return this._providersChanged;
+  }
   getProvidersInfo() {
     const out = [];
     for (const [name, state] of this._providers) {
@@ -3763,7 +4144,8 @@ var WsTunnel = class {
       connectedForMs: since !== null ? Math.max(0, Date.now() - since) : null,
       clientCount: state.wsClients.size,
       sessionCount: state.sseSessions.size + state.httpSessions.size,
-      pendingCount: state.pending.size
+      pendingCount: state.pending.size,
+      resourceSubscriptionCount: this._subscriptions.countFor(name)
     };
   }
   // -------------------------------------------------------------------------
@@ -3786,6 +4168,7 @@ var WsTunnel = class {
     const state = this._getOrCreateProviderState(name);
     this._loopbackProviders.set(name, transport);
     state.connectedSinceMs = Date.now();
+    this._onProviderAttached(name);
     transport.onMessage = (data) => this._routeFromProvider(state, name, data);
     transport.onClose = () => {
       this._loopbackProviders.delete(name);
@@ -3809,6 +4192,7 @@ var WsTunnel = class {
       onClose: null,
       send: (message) => {
         if (closed) return;
+        if (this._interceptClientFrame(state, providerName, message, { type: "internal", client })) return;
         if (this._isProviderConnected(providerName, state)) {
           this._sendToProvider(state, providerName, this._trackRequest(state, message, { type: "internal", client }));
         } else if (requestIdOf(message) !== void 0) {
@@ -3822,6 +4206,7 @@ var WsTunnel = class {
         for (const [brokerId, entry] of state.pending) {
           if (entry.sink.type === "internal" && entry.sink.client === client) state.pending.delete(brokerId);
         }
+        void this._subscriptions.removeClient(this._internalClientKey(client));
       }
     };
     state.internalClients.add(client);
@@ -3922,6 +4307,7 @@ var WsTunnel = class {
           };
           upstream.onOpen = () => {
             this._getOrCreateProviderState(cfg.name).connectedSinceMs = Date.now();
+            this._onProviderAttached(cfg.name);
             if (cfg.aggregate) void this._aggregateServer?.addProvider(cfg.name);
           };
           this._upstreams.set(cfg.name, upstream);
@@ -3941,6 +4327,7 @@ var WsTunnel = class {
             console.error(`[broker] stdio client transport: ${err.message}`);
           };
           transport.onClose = () => {
+            void this._subscriptions.removeClient(STDIO_CLIENT_KEY);
           };
           transport.connect();
         }
@@ -4017,6 +4404,7 @@ var WsTunnel = class {
       const server = new AggregateServer((providerName) => this.openInternalClient(providerName));
       server.setScopeFilter(this._options.auth?.aggregateScopeFilter ?? null);
       server.setPolicyAuthorization(this._authorization);
+      server.onMembershipChanged = (name) => this._emitProviderChanged(name);
       server.start();
       this.registerLoopbackProvider(AggregateServer.SLOT, server);
       this._aggregateServer = server;
@@ -4031,6 +4419,10 @@ var WsTunnel = class {
     this._stopHeartbeat();
     this._stopRequestTimeoutSweep();
     this._providerSockets.clear();
+    this._subscriptions.clear();
+    if (this._changedSlotsTimer) clearTimeout(this._changedSlotsTimer);
+    this._changedSlotsTimer = null;
+    this._changedSlots.clear();
     const brokerServer = this._brokerServer;
     this._brokerServer = null;
     if (brokerServer) {
@@ -4281,6 +4673,9 @@ var WsTunnel = class {
       case "internal":
         sink.client.onMessage?.(data);
         return;
+      case "broker":
+        sink.resolve(data);
+        return;
     }
   }
   /**
@@ -4735,6 +5130,7 @@ data: ${messagesUrl}?sessionId=${sessionId}
       for (const [brokerId, entry] of state.pending) {
         if (entry.sink.type === "sse" && entry.sink.sessionId === sessionId) state.pending.delete(brokerId);
       }
+      void this._subscriptions.removeClient(`sse:${sessionId}`);
     });
   }
   /**
@@ -4761,7 +5157,7 @@ data: ${messagesUrl}?sessionId=${sessionId}
         res.end(this._policyDeniedPayload(body));
         return;
       }
-      if (this._isProviderConnected(providerName, state)) {
+      if (this._interceptClientFrame(state, providerName, body, { type: "sse", sessionId })) ; else if (this._isProviderConnected(providerName, state)) {
         this._sendToProvider(state, providerName, this._trackRequest(state, body, { type: "sse", sessionId }), principal);
       } else {
         const sseRes = state.sseSessions.get(sessionId);
@@ -4815,6 +5211,7 @@ data: ${messagesUrl}?sessionId=${sessionId}
           start: () => openTransport(transport),
           stop: () => {
             state.httpSessions.delete(sessionId);
+            void this._subscriptions.removeClient(`http:${sessionId}`);
             for (const [brokerId, entry] of state.pending) {
               if (entry.sink.type === "http-session" && entry.sink.sessionId === sessionId) state.pending.delete(brokerId);
             }
@@ -4830,6 +5227,7 @@ data: ${messagesUrl}?sessionId=${sessionId}
       session.transport.send(this._policyDeniedPayload(frame));
       return;
     }
+    if (this._interceptClientFrame(state, providerName, frame, { type: "http-session", sessionId })) return;
     if (!this._isProviderConnected(providerName, state)) {
       session.transport.send(this._notConnectedPayload(providerName, frame));
       return;
@@ -4913,6 +5311,7 @@ data: ${data}
     state.ws = ws;
     state.connectedSinceMs = Date.now();
     this._watchProviderSocket(ws);
+    this._onProviderAttached(name);
     if (providerPrincipal) {
       this._logProviderRegistration(providerPrincipal, name, this._slotResourceResolver.resolve(name), true);
     }
@@ -5052,6 +5451,7 @@ data: ${data}
       for (const [brokerId, entry] of state.pending) {
         if (entry.sink.type === "ws" && entry.sink.socket === ws) state.pending.delete(brokerId);
       }
+      void this._subscriptions.removeClient(this._wsClientKey(ws));
     });
     ws.on("error", (err) => {
       console.error(`[broker] client socket error on slot "${providerName}": ${err.message}. The socket is being closed; the client should reconnect.`);
@@ -5121,6 +5521,7 @@ data: ${data}
         const state2 = this._getOrCreateProviderState(name);
         state2.ws = ws;
         state2.connectedSinceMs = Date.now();
+        this._onProviderAttached(name);
         if (providerPrincipal) {
           this._logProviderRegistration(providerPrincipal, name, this._slotResourceResolver.resolve(name), true);
         }
@@ -5178,6 +5579,7 @@ data: ${data}
     }
   }
   _routeFromStdioClient(state, data) {
+    if (this._interceptClientFrame(state, this._stdioClientProvider, data, { type: "stdio" })) return;
     if (this._isProviderConnected(this._stdioClientProvider, state)) {
       this._sendToProvider(state, this._stdioClientProvider, this._trackRequest(state, data, { type: "stdio" }));
     } else {
@@ -5206,6 +5608,7 @@ data: ${data}
       client.send(this._policyDeniedPayload(data));
       return;
     }
+    if (this._interceptClientFrame(state, providerName, data, { type: "ws", socket: client })) return;
     if (!this._isProviderConnected(providerName, state)) {
       client.send(
         JSON.stringify({
@@ -5233,6 +5636,8 @@ data: ${data}
         } else {
           this._warnUnmatchedResponseId(providerName, msg.id);
         }
+      } else if (msg.method === "notifications/resources/updated") {
+        this._routeResourceUpdated(state, providerName, msg, data);
       } else {
         this._broadcast(state, providerName, data);
       }
@@ -5301,6 +5706,8 @@ data: ${data}
    */
   _failProviderDisconnected(state, name) {
     state.connectedSinceMs = null;
+    this._subscriptions.providerDisconnected(name);
+    this._emitProviderChanged(name);
     for (const entry of state.pending.values()) {
       const error = JSON.stringify({
         jsonrpc: "2.0",
@@ -5340,10 +5747,225 @@ data: ${data}
         httpEndpoint: null
       };
       this._providers.set(name, state);
+      this._emitProviderChanged(name);
     }
     return state;
   }
   // -------------------------------------------------------------------------
+  // Resource subscriptions
+  // -------------------------------------------------------------------------
+  /** The {@link ClientKey} of a raw WS client socket. */
+  _wsClientKey(ws) {
+    let id = this._wsClientIds.get(ws);
+    if (id === void 0) {
+      id = this._nextWsClientId++;
+      this._wsClientIds.set(ws, id);
+    }
+    return `ws:${id}`;
+  }
+  /** The {@link ClientKey} of a sink that is a client, `null` for the broker's own and internal sinks. */
+  _clientKeyOf(sink) {
+    switch (sink.type) {
+      case "ws":
+        return this._wsClientKey(sink.socket);
+      case "sse":
+        return `sse:${sink.sessionId}`;
+      case "http-session":
+        return `http:${sink.sessionId}`;
+      case "stdio":
+        return STDIO_CLIENT_KEY;
+      case "internal":
+        return this._internalClientKey(sink.client);
+      default:
+        return null;
+    }
+  }
+  /** The {@link ClientKey} of an in-process client from {@link openInternalClient}. */
+  _internalClientKey(client) {
+    let id = this._internalClientIds.get(client);
+    if (id === void 0) {
+      id = this._nextInternalClientId++;
+      this._internalClientIds.set(client, id);
+    }
+    return `internal:${id}`;
+  }
+  /** The principal behind a client sink, for the per-notification policy check. */
+  _principalOfSink(state, sink) {
+    switch (sink.type) {
+      case "ws":
+        return this._clientPrincipals.get(sink.socket) ?? null;
+      case "sse": {
+        const res = state.sseSessions.get(sink.sessionId);
+        return res ? this._streamPrincipals.get(res) ?? null : null;
+      }
+      case "http-session":
+        return state.httpSessions.get(sink.sessionId)?.principal ?? null;
+      default:
+        return null;
+    }
+  }
+  /**
+   * Answers `resources/subscribe` and `resources/unsubscribe` from the
+   * broker's own registry instead of relaying them. Returns `true` when the
+   * frame was one of those and has been (or will be) answered.
+   *
+   * Also remembers the last `initialize` of the slot, for {@link _replaySubscriptions}.
+   *
+   * Runs after the policy check. `resources/unsubscribe` is not classified,
+   * so it is never refused: a client whose read grant was revoked must
+   * still be able to drop what it holds. `_all` is skipped: it serves tools
+   * and prompts only, and answers resources methods with `-32601` itself.
+   */
+  _interceptClientFrame(state, providerName, frame, sink) {
+    if (!frame.includes('"resources/') && !frame.includes('"initialize"')) return false;
+    const msg = parseObjectFrame(frame);
+    if (!msg) return false;
+    if (msg.method === "initialize") {
+      state.lastInitializeParams = msg.params;
+      return false;
+    }
+    if (msg.method !== "resources/subscribe" && msg.method !== "resources/unsubscribe") return false;
+    if (providerName === AggregateServer.SLOT) return false;
+    const id = msg.id;
+    if (typeof id !== "string" && typeof id !== "number") return false;
+    const client = this._clientKeyOf(sink);
+    if (!client) return false;
+    const answer = (outcome) => {
+      const reply = outcome.ok ? { jsonrpc: "2.0", id, result: {} } : { jsonrpc: "2.0", id, error: outcome.error };
+      this._deliverToSink(state, sink, JSON.stringify(reply));
+    };
+    const uri = msg.params?.uri;
+    if (typeof uri !== "string" || uri.length === 0) {
+      answer({ ok: false, error: { code: -32602, message: "Missing required parameter: uri" } });
+      return true;
+    }
+    const pending = msg.method === "resources/subscribe" ? this._subscriptions.subscribe(providerName, client, sink, uri) : this._subscriptions.unsubscribe(providerName, client, uri);
+    void pending.then(answer, (error) => answer({ ok: false, error: { code: -32603, message: `Subscription failed: ${error.message}` } }));
+    return true;
+  }
+  /**
+   * Sends one aggregated `resources/subscribe` or `resources/unsubscribe` to
+   * the provider behind `slot` and resolves with its answer. Never rejects:
+   * a disconnect or a timeout arrives as an error answer through the same
+   * pending-request machinery every client request uses.
+   */
+  _subscriptionRequest(slot, method, uri) {
+    return this._brokerRequest(slot, method, { uri }).then((reply) => reply.error ? { ok: false, error: reply.error } : { ok: true });
+  }
+  /** Sends a request of the broker's own to a provider and resolves with the parsed answer. */
+  _brokerRequest(slot, method, params) {
+    const state = this._providers.get(slot);
+    if (!state || !this._isProviderConnected(slot, state)) {
+      return Promise.resolve({ error: { code: -32e3, message: `Provider "${slot}" not connected` } });
+    }
+    return new Promise((resolve5) => {
+      const sink = {
+        type: "broker",
+        resolve: (frame) => {
+          const reply = parseObjectFrame(frame);
+          resolve5(reply ?? { error: { code: -32700, message: "Unparseable answer" } });
+        }
+      };
+      this._sendToProvider(state, slot, this._trackRequest(state, JSON.stringify({ jsonrpc: "2.0", id: 0, method, params }), sink));
+    });
+  }
+  /**
+   * Delivers a provider's `notifications/resources/updated` to the sessions
+   * subscribed to its URI, and to nobody else.
+   *
+   * A frame without a usable URI is dropped, never broadcast: there is no
+   * safe audience for it. Each recipient is re-checked against the policy,
+   * because a grant can be revoked after the subscription was accepted; a
+   * recipient that fails the check is unsubscribed as well as skipped.
+   */
+  _routeResourceUpdated(state, providerName, msg, data) {
+    const uri = msg.params?.uri;
+    if (typeof uri !== "string" || uri.length === 0 || uri.length > this._subscriptions.limits.maxResourceUriLength) {
+      if (!this._invalidUpdateWarnedProviders.has(providerName)) {
+        this._invalidUpdateWarnedProviders.add(providerName);
+        console.warn(
+          `[broker] provider "${providerName}" sent notifications/resources/updated without a usable params.uri; it was dropped, not broadcast. The notification must name the one URI that changed, as a string of at most ${this._subscriptions.limits.maxResourceUriLength} characters. Further such frames from this slot are not logged.`
+        );
+      }
+      return;
+    }
+    this._deliverResourceUpdated(state, providerName, uri, data);
+  }
+  _deliverResourceUpdated(state, providerName, uri, data) {
+    for (const { client, sink } of this._subscriptions.subscribers(providerName, uri)) {
+      if (sink.type !== "stdio" && sink.type !== "internal" && !this._authorizeMcpFrame(providerName, data, this._principalOfSink(state, sink))) {
+        void this._subscriptions.unsubscribe(providerName, client, uri);
+        continue;
+      }
+      this._deliverToSink(state, sink, data);
+    }
+  }
+  /** A provider now serves `name`: announce it, and restore the subscriptions it should hold. */
+  _onProviderAttached(name) {
+    this._emitProviderChanged(name);
+    if (this._subscriptions.hasSubscriptions(name)) {
+      void this._replaySubscriptions(name).catch((error) => {
+        console.error(`[broker] provider "${name}": restoring resource subscriptions failed: ${error.message}`);
+      });
+    }
+  }
+  /**
+   * Re-subscribes a provider that (re)attached to URIs clients still hold,
+   * once per URI.
+   *
+   * The provider is handshaken first, with the last `initialize` a client
+   * sent on this slot, because a fresh provider has no session: requests
+   * before `initialize` break the MCP lifecycle, and an mcp-core server
+   * suppresses its list_changed notifications until it sees
+   * `notifications/initialized`.
+   *
+   * Every subscriber then gets one `notifications/resources/updated`: the
+   * content may have changed while nobody was watching, so a re-read is due.
+   * Where the new provider refuses a URI, that is also what tells its
+   * subscribers, since their re-read fails; their subscription is dropped.
+   */
+  async _replaySubscriptions(name) {
+    const params = this._providers.get(name)?.lastInitializeParams ?? {
+      protocolVersion: "2025-06-18",
+      capabilities: {},
+      clientInfo: { name: this.name, version: this.version }
+    };
+    const init = await this._brokerRequest(name, "initialize", params);
+    if (init.error) {
+      console.warn(`[broker] provider "${name}" refused the initialize sent before restoring subscriptions: ${init.error.message}. Subscriptions are restored anyway.`);
+    } else {
+      const state2 = this._providers.get(name);
+      if (state2) this._sendToProvider(state2, name, JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }));
+    }
+    const state = this._providers.get(name);
+    for (const result of await this._subscriptions.replay(name)) {
+      if (!result.outcome.ok) {
+        console.warn(
+          `[broker] provider "${name}" refused to restore the subscription to "${result.uri}" after reconnecting: ${result.outcome.error.message}. Its ${result.subscribers.length} subscriber(s) were dropped and told to re-read.`
+        );
+      }
+      if (!state) continue;
+      const data = JSON.stringify({ jsonrpc: "2.0", method: "notifications/resources/updated", params: { uri: result.uri } });
+      for (const { sink } of result.subscribers) this._deliverToSink(state, sink, data);
+    }
+  }
+  /**
+   * Queues `name` for the next {@link onProvidersChanged} batch. Batched per
+   * tick, so a multiplexed socket announcing ten slots, or a slot attaching
+   * and joining `_all` in the same breath, produces one notification.
+   */
+  _emitProviderChanged(name) {
+    this._changedSlots.add(name);
+    if (this._changedSlotsTimer) return;
+    this._changedSlotsTimer = setTimeout(() => {
+      this._changedSlotsTimer = null;
+      const names = [...this._changedSlots];
+      this._changedSlots.clear();
+      if (names.length > 0) this._providersChanged.emit(names);
+    }, 0);
+    this._changedSlotsTimer.unref?.();
+  }
+  // -------------------------------------------------------------------------
   // Samples index
   // -------------------------------------------------------------------------
   _handleSamplesIndex(res) {
@@ -5421,6 +6043,7 @@ var WsTunnelBuilder = class {
   _providerHeartbeatIntervalMs = void 0;
   _providerTakeover = void 0;
   _providerRequestTimeoutMs = void 0;
+  _resourceSubscriptions = void 0;
   _staticMounts = [];
   _stdioUpstreams = [];
   _remoteUpstreams = [];
@@ -5575,6 +6198,15 @@ var WsTunnelBuilder = class {
     this._providerRequestTimeoutMs = timeoutMs;
     return this;
   }
+  /**
+   * Bounds what `resources/subscribe` can make the broker hold. Fields left
+   * out keep their default: 64 URIs per client, 1024 client subscriptions per
+   * slot, URIs of at most 2048 characters.
+   */
+  withResourceSubscriptionLimits(limits) {
+    this._resourceSubscriptions = { ...this._resourceSubscriptions, ...limits };
+    return this;
+  }
   /**
    * Adds a static-file mount served over plain HTTP.
    * Can be called multiple times; longest-prefix match wins at runtime.
@@ -5722,6 +6354,7 @@ var WsTunnelBuilder = class {
       providerHeartbeatIntervalMs: this._providerHeartbeatIntervalMs,
       providerTakeover: this._providerTakeover,
       providerRequestTimeoutMs: this._providerRequestTimeoutMs,
+      resourceSubscriptions: this._resourceSubscriptions,
       staticMounts: this._staticMounts.length > 0 ? [...this._staticMounts] : void 0,
       stdioUpstreams: this._stdioUpstreams.length > 0 ? [...this._stdioUpstreams] : void 0,
       remoteUpstreams: this._remoteUpstreams.length > 0 ? [...this._remoteUpstreams] : void 0,
@@ -5985,6 +6618,6 @@ function resolveOpenTarget(raw, baseUrl) {
   return { url: resolved.toString(), path: resolved.pathname };
 }
 
-export { AuthError, BROKER_AGGREGATE_NAME, BROKER_GUIDES, BROKER_GUIDE_MIME_TYPE, BROKER_GUIDE_TOPICS, BROKER_GUIDE_URI_PREFIX, BROKER_GUIDE_URI_TEMPLATE, BROKER_PROVIDER_NAME, BROKER_RESERVED_SLOTS, BrokerDiagnoseAdapter, BrokerDiagnoseBehavior, BrokerGuideAdapter, BrokerGuideBehavior, BrokerInfoBehavior, BrokerProvidersBehavior, ConfigPolicyEngine, ConfiguredCapabilityClassifier, DEFAULT_CONFIG_FILENAME, DefaultSlotResourceResolver, HttpAuthGuard, JwtSubjectMapper, JwtTokenValidator, PACKAGE_NAME, RemoteUpstream, ResourcePath, ResourcePathPattern, SharedSecretProviderAuthenticator, StdioUpstream, SubjectMappingError, VERSION, WsTunnel, WsTunnelBuilder, authorizationWithEngine, brokerGrammarKey, brokerGuide, brokerGuideIndex, brokerGuideTopicFromUri, brokerGuideUri, buildJwtAuth, buildResourceMetadata, compileAuthorizationPolicy, compileProviderAllowedResources, diagnoseBroker, hasAuthorizationPolicies, isReservedBrokerSlot, iterAvailableBrokerGrammars, iterBrokerGrammarsFrom, loadBrokerConfig, loadBrokerGrammar, loadMcpbBundle, normalizeProviderAuthentication, providerMayPublish, providerPublishDecision, resolveOpenTarget, scopesOf, startBrokerServer, unzipMcpb, validateCapability };
-//# sourceMappingURL=chunk-J5TN5RYU.js.map
-//# sourceMappingURL=chunk-J5TN5RYU.js.map
+export { AuthError, BROKER_AGGREGATE_NAME, BROKER_GUIDES, BROKER_GUIDE_MIME_TYPE, BROKER_GUIDE_TOPICS, BROKER_GUIDE_URI_PREFIX, BROKER_GUIDE_URI_TEMPLATE, BROKER_PROVIDER_NAME, BROKER_RESERVED_SLOTS, BrokerDiagnoseAdapter, BrokerDiagnoseBehavior, BrokerGuideAdapter, BrokerGuideBehavior, BrokerInfoBehavior, BrokerProvidersBehavior, ConfigPolicyEngine, ConfiguredCapabilityClassifier, DEFAULT_CONFIG_FILENAME, DEFAULT_RESOURCE_SUBSCRIPTION_LIMITS, DefaultSlotResourceResolver, HttpAuthGuard, JwtSubjectMapper, JwtTokenValidator, PACKAGE_NAME, RemoteUpstream, ResourcePath, ResourcePathPattern, ResourceSubscriptionRegistry, SUBSCRIPTION_LIMIT_ERROR_CODE, SharedSecretProviderAuthenticator, StdioUpstream, SubjectMappingError, VERSION, WsTunnel, WsTunnelBuilder, authorizationWithEngine, brokerGrammarKey, brokerGuide, brokerGuideIndex, brokerGuideTopicFromUri, brokerGuideUri, buildJwtAuth, buildResourceMetadata, compileAuthorizationPolicy, compileProviderAllowedResources, diagnoseBroker, hasAuthorizationPolicies, isReservedBrokerSlot, iterAvailableBrokerGrammars, iterBrokerGrammarsFrom, loadBrokerConfig, loadBrokerGrammar, loadMcpbBundle, normalizeProviderAuthentication, providerMayPublish, providerPublishDecision, resolveOpenTarget, scopesOf, startBrokerServer, unzipMcpb, validateCapability };
+//# sourceMappingURL=chunk-YTRVLPHP.js.map
+//# sourceMappingURL=chunk-YTRVLPHP.js.map