@langchain/langgraph 1.2.9 → 1.3.0

package/dist/stream/transformers/messages.js

@@ -0,0 +1,94 @@
+import { StreamChannel } from "../stream-channel.js";
+import { hasPrefix } from "../mux.js";
+import { ChatModelStream } from "@langchain/core/language_models/stream";
+//#region src/stream/transformers/messages.ts
+function getMessageStreamKey(data) {
+	const record = data;
+	if (typeof record.run_id === "string") return `run:${record.run_id}`;
+	if (data.event === "message-start" && typeof record.id === "string") return `message:${record.id}`;
+	return "__default__";
+}
+/**
+* Creates a {@link StreamTransformer} that groups `messages` channel events into
+* per-message {@link ChatModelStream} instances.
+*
+* A new `ChatModelStream` is created on `message-start` and closed on
+* `message-finish`. Content-block events in between are forwarded to the
+* active stream. Only events whose namespace exactly matches {@link path}
+* are processed; child namespaces are ignored.
+*
+* @param path - Namespace prefix to match against incoming events.
+* @param nodeFilter - If provided, only events emitted by this graph node
+*   are processed; all others are skipped.
+* @returns A `StreamTransformer` whose projection contains the `messages`
+*   async iterable.
+*/
+function createMessagesTransformer(path, nodeFilter) {
+	const log = StreamChannel.local();
+	const active = /* @__PURE__ */ new Map();
+	return {
+		init: () => ({ messages: log.toAsyncIterable() }),
+		process(event) {
+			if (event.method !== "messages") return true;
+			if (!hasPrefix(event.params.namespace, path)) return true;
+			if (event.params.namespace.length !== path.length + 1) return true;
+			if (nodeFilter !== void 0 && event.params.node !== nodeFilter) return true;
+			const data = event.params.data;
+			switch (data.event) {
+				case "message-start": {
+					const key = getMessageStreamKey(data);
+					const source = StreamChannel.local();
+					const stream = Object.assign(new ChatModelStream(source.toAsyncIterable()), {
+						namespace: event.params.namespace,
+						node: event.params.node
+					});
+					active.set(key, {
+						source,
+						stream
+					});
+					source.push(data);
+					log.push(stream);
+					break;
+				}
+				case "content-block-start":
+				case "content-block-delta":
+				case "content-block-finish":
+					active.get(getMessageStreamKey(data))?.source.push(data);
+					break;
+				case "message-finish": {
+					const key = getMessageStreamKey(data);
+					const stream = active.get(key);
+					if (stream) {
+						stream.source.push(data);
+						stream.source.close();
+						active.delete(key);
+					}
+					break;
+				}
+				case "error":
+					active.get(getMessageStreamKey(data))?.source.push(data);
+					break;
+			}
+			return true;
+		},
+		finalize() {
+			for (const [key, stream] of active) {
+				stream.source.push({ event: "message-finish" });
+				stream.source.close();
+				active.delete(key);
+			}
+			log.close();
+		},
+		fail(err) {
+			for (const [key, stream] of active) {
+				stream.source.fail(err);
+				active.delete(key);
+			}
+			log.fail(err);
+		}
+	};
+}
+//#endregion
+export { createMessagesTransformer };
+
+//# sourceMappingURL=messages.js.map

package/dist/stream/transformers/messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.js","names":["CoreChatModelStream"],"sources":["../../../src/stream/transformers/messages.ts"],"sourcesContent":["import type { ChatModelStreamEvent } from \"@langchain/core/language_models/event\";\nimport { ChatModelStream as CoreChatModelStream } from \"@langchain/core/language_models/stream\";\nimport { hasPrefix } from \"../mux.js\";\nimport { StreamChannel } from \"../stream-channel.js\";\nimport type {\n  ChatModelStream,\n  MessagesEventData,\n  Namespace,\n  ProtocolEvent,\n  StreamTransformer,\n} from \"../types.js\";\nimport type { MessagesTransformerProjection } from \"./types.js\";\n\ntype ActiveMessageStream = {\n  source: StreamChannel<ChatModelStreamEvent>;\n  stream: ChatModelStream;\n};\n\nfunction getMessageStreamKey(data: MessagesEventData): string {\n  const record = data as unknown as Record<string, unknown>;\n  if (typeof record.run_id === \"string\") return `run:${record.run_id}`;\n  if (data.event === \"message-start\" && typeof record.id === \"string\") {\n    return `message:${record.id}`;\n  }\n  return \"__default__\";\n}\n\n/**\n * Creates a {@link StreamTransformer} that groups `messages` channel events into\n * per-message {@link ChatModelStream} instances.\n *\n * A new `ChatModelStream` is created on `message-start` and closed on\n * `message-finish`. Content-block events in between are forwarded to the\n * active stream. Only events whose namespace exactly matches {@link path}\n * are processed; child namespaces are ignored.\n *\n * @param path - Namespace prefix to match against incoming events.\n * @param nodeFilter - If provided, only events emitted by this graph node\n *   are processed; all others are skipped.\n * @returns A `StreamTransformer` whose projection contains the `messages`\n *   async iterable.\n */\nexport function createMessagesTransformer(\n  path: Namespace,\n  nodeFilter?: string\n): StreamTransformer<MessagesTransformerProjection> {\n  const log = StreamChannel.local<ChatModelStream>();\n  const active = new Map<string, ActiveMessageStream>();\n\n  return {\n    init: () => ({\n      messages: log.toAsyncIterable(),\n    }),\n\n    process(event: ProtocolEvent): boolean {\n      if (event.method !== \"messages\") return true;\n      if (!hasPrefix(event.params.namespace, path)) return true;\n\n      // Only capture messages from this graph's own node executions,\n      // which sit exactly one namespace level deeper than `path`.\n      // Events at `path` itself are chain-level replays from the\n      // callback system (handleChainEnd re-emits finalized messages)\n      // and would duplicate the streamed content already captured\n      // at depth+1.\n      const depth = event.params.namespace.length;\n      if (depth !== path.length + 1) return true;\n\n      if (nodeFilter !== undefined && event.params.node !== nodeFilter) {\n        return true;\n      }\n\n      const data = event.params.data as MessagesEventData;\n\n      switch (data.event) {\n        case \"message-start\": {\n          const key = getMessageStreamKey(data);\n          const source = StreamChannel.local<ChatModelStreamEvent>();\n          const stream = Object.assign(\n            new CoreChatModelStream(source.toAsyncIterable()),\n            {\n              namespace: event.params.namespace,\n              node: event.params.node,\n            }\n          ) as ChatModelStream;\n          active.set(key, { source, stream });\n          source.push(data as unknown as ChatModelStreamEvent);\n          log.push(stream);\n          break;\n        }\n\n        case \"content-block-start\":\n        case \"content-block-delta\":\n        case \"content-block-finish\":\n          active\n            .get(getMessageStreamKey(data))\n            ?.source.push(data as unknown as ChatModelStreamEvent);\n          break;\n\n        case \"message-finish\": {\n          const key = getMessageStreamKey(data);\n          const stream = active.get(key);\n          if (stream) {\n            stream.source.push(data as unknown as ChatModelStreamEvent);\n            stream.source.close();\n            active.delete(key);\n          }\n          break;\n        }\n\n        case \"error\":\n          active\n            .get(getMessageStreamKey(data))\n            ?.source.push(data as unknown as ChatModelStreamEvent);\n          break;\n      }\n\n      return true;\n    },\n\n    finalize(): void {\n      for (const [key, stream] of active) {\n        stream.source.push({ event: \"message-finish\" });\n        stream.source.close();\n        active.delete(key);\n      }\n      log.close();\n    },\n\n    fail(err: unknown): void {\n      for (const [key, stream] of active) {\n        stream.source.fail(err);\n        active.delete(key);\n      }\n      log.fail(err);\n    },\n  };\n}\n"],"mappings":";;;;AAkBA,SAAS,oBAAoB,MAAiC;CAC5D,MAAM,SAAS;AACf,KAAI,OAAO,OAAO,WAAW,SAAU,QAAO,OAAO,OAAO;AAC5D,KAAI,KAAK,UAAU,mBAAmB,OAAO,OAAO,OAAO,SACzD,QAAO,WAAW,OAAO;AAE3B,QAAO;;;;;;;;;;;;;;;;;AAkBT,SAAgB,0BACd,MACA,YACkD;CAClD,MAAM,MAAM,cAAc,OAAwB;CAClD,MAAM,yBAAS,IAAI,KAAkC;AAErD,QAAO;EACL,aAAa,EACX,UAAU,IAAI,iBAAiB,EAChC;EAED,QAAQ,OAA+B;AACrC,OAAI,MAAM,WAAW,WAAY,QAAO;AACxC,OAAI,CAAC,UAAU,MAAM,OAAO,WAAW,KAAK,CAAE,QAAO;AASrD,OADc,MAAM,OAAO,UAAU,WACvB,KAAK,SAAS,EAAG,QAAO;AAEtC,OAAI,eAAe,KAAA,KAAa,MAAM,OAAO,SAAS,WACpD,QAAO;GAGT,MAAM,OAAO,MAAM,OAAO;AAE1B,WAAQ,KAAK,OAAb;IACE,KAAK,iBAAiB;KACpB,MAAM,MAAM,oBAAoB,KAAK;KACrC,MAAM,SAAS,cAAc,OAA6B;KAC1D,MAAM,SAAS,OAAO,OACpB,IAAIA,gBAAoB,OAAO,iBAAiB,CAAC,EACjD;MACE,WAAW,MAAM,OAAO;MACxB,MAAM,MAAM,OAAO;MACpB,CACF;AACD,YAAO,IAAI,KAAK;MAAE;MAAQ;MAAQ,CAAC;AACnC,YAAO,KAAK,KAAwC;AACpD,SAAI,KAAK,OAAO;AAChB;;IAGF,KAAK;IACL,KAAK;IACL,KAAK;AACH,YACG,IAAI,oBAAoB,KAAK,CAAC,EAC7B,OAAO,KAAK,KAAwC;AACxD;IAEF,KAAK,kBAAkB;KACrB,MAAM,MAAM,oBAAoB,KAAK;KACrC,MAAM,SAAS,OAAO,IAAI,IAAI;AAC9B,SAAI,QAAQ;AACV,aAAO,OAAO,KAAK,KAAwC;AAC3D,aAAO,OAAO,OAAO;AACrB,aAAO,OAAO,IAAI;;AAEpB;;IAGF,KAAK;AACH,YACG,IAAI,oBAAoB,KAAK,CAAC,EAC7B,OAAO,KAAK,KAAwC;AACxD;;AAGJ,UAAO;;EAGT,WAAiB;AACf,QAAK,MAAM,CAAC,KAAK,WAAW,QAAQ;AAClC,WAAO,OAAO,KAAK,EAAE,OAAO,kBAAkB,CAAC;AAC/C,WAAO,OAAO,OAAO;AACrB,WAAO,OAAO,IAAI;;AAEpB,OAAI,OAAO;;EAGb,KAAK,KAAoB;AACvB,QAAK,MAAM,CAAC,KAAK,WAAW,QAAQ;AAClC,WAAO,OAAO,KAAK,IAAI;AACvB,WAAO,OAAO,IAAI;;AAEpB,OAAI,KAAK,IAAI;;EAEhB"}

package/dist/stream/transformers/subgraphs.cjs

@@ -0,0 +1,125 @@
+const require_mux = require("../mux.cjs");
+//#region src/stream/transformers/subgraphs.ts
+/**
+* SubgraphDiscoveryTransformer - materializes a {@link StreamHandle} for
+* each newly observed top-level subgraph namespace and announces it on
+* the mux's shared {@link StreamMux._discoveries} channel.
+*
+* Previously this work was inlined in {@link StreamMux.push}.  Extracting
+* it into a transformer aligns discovery with the rest of the stream
+* architecture (lifecycle, values, messages are all transformers),
+* isolates the factory wiring, and makes discovery behavior
+* independently testable.
+*
+* The transformer also owns the read-side of discovery: it exposes an
+* `AsyncIterable<TStream>` projection (`subgraphs`) scoped to the root
+* namespace, and a {@link filterSubgraphHandles} helper that callers
+* can use to scope the same channel to any descendant namespace.  This
+* lets `GraphRunStream` drop its bespoke `subscribeSubgraphs`
+* delegation and surface child streams via the standard native
+* projection pattern.
+*
+* Only first-level namespace segments are announced.  Deeper segments
+* (e.g. `["researcher:uuid", "tools:uuid"]`) are internal Pregel
+* checkpoint namespaces for nodes inside a subgraph and should not
+* appear as user-facing `SubgraphRunStream` instances; the mux still
+* resolves their values via its own `#streamMap` when registered
+* elsewhere.
+*/
+/**
+* Filter a {@link SubgraphDiscovery} channel to only the direct children
+* of a given namespace.
+*
+* Returns an `AsyncIterable` whose iterator yields stream handles for
+* discoveries whose namespace is exactly one segment deeper than
+* {@link path} and shares it as a prefix.  Iteration begins at
+* {@link startAt} (so each caller picks up only discoveries added
+* after its construction) and terminates when the underlying log
+* closes or fails.
+*
+* @typeParam TStream - Concrete stream type recorded in the log.
+*   Callers may cast if the log was populated by a specific factory.
+* @param log - The shared discovery channel (`mux._discoveries`).
+* @param path - Parent namespace whose direct children should be
+*   yielded.
+* @param startAt - Zero-based index into the discovery log to begin
+*   from.
+* @returns An async iterable of stream handles.
+*/
+function filterSubgraphHandles(log, path, startAt = 0) {
+	const targetDepth = path.length + 1;
+	return { [Symbol.asyncIterator]() {
+		const base = log.iterate(startAt);
+		return { async next() {
+			while (true) {
+				const result = await base.next();
+				if (result.done) return {
+					value: void 0,
+					done: true
+				};
+				const { ns, stream } = result.value;
+				if (ns.length === targetDepth && require_mux.hasPrefix(ns, path)) return {
+					value: stream,
+					done: false
+				};
+			}
+		} };
+	} };
+}
+/**
+* Create the subgraph discovery transformer.
+*
+* Registering this transformer against a mux replaces the legacy
+* inline behavior that previously lived in {@link StreamMux.push}.
+* The mux no longer knows about the subgraph factory: instead, this
+* transformer is the single component that materializes stream
+* handles and announces them on `_discoveries`.
+*
+* Marked as a {@link NativeStreamTransformer} so the projection is
+* treated as internal wiring (not merged into `run.extensions` and
+* not auto-forwarded via {@link StreamMux.wireChannels}).
+*
+* @typeParam TStream - Concrete stream handle type produced by
+*   {@link SubgraphDiscoveryTransformerOptions.createStream}.
+*   Defaults to the base {@link StreamHandle} interface.
+* @param mux - The mux whose `_discoveries` log should receive
+*   discovery entries and whose `register` will be called for each
+*   new stream handle.
+* @param options - Factory and related wiring.
+* @returns A native transformer that populates
+*   {@link StreamMux._discoveries} and exposes a root-scoped
+*   `subgraphs` iterable via its projection.
+*/
+function createSubgraphDiscoveryTransformer(mux, options) {
+	const { createStream } = options;
+	const seen = /* @__PURE__ */ new Set();
+	return {
+		__native: true,
+		init() {
+			return {
+				_discoveries: mux._discoveries,
+				subgraphs: filterSubgraphHandles(mux._discoveries, [], 0)
+			};
+		},
+		process(event) {
+			const ns = event.params.namespace;
+			if (ns.length === 0) return true;
+			const topNs = ns.slice(0, 1);
+			const topKey = require_mux.nsKey(topNs);
+			if (seen.has(topKey)) return true;
+			seen.add(topKey);
+			const stream = createStream(topNs, mux._discoveries.size, mux._events.size);
+			mux.register(topNs, stream);
+			mux._discoveries.push({
+				ns: topNs,
+				stream
+			});
+			return true;
+		}
+	};
+}
+//#endregion
+exports.createSubgraphDiscoveryTransformer = createSubgraphDiscoveryTransformer;
+exports.filterSubgraphHandles = filterSubgraphHandles;
+
+//# sourceMappingURL=subgraphs.cjs.map

package/dist/stream/transformers/subgraphs.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"subgraphs.cjs","names":["hasPrefix","nsKey"],"sources":["../../../src/stream/transformers/subgraphs.ts"],"sourcesContent":["/**\n * SubgraphDiscoveryTransformer - materializes a {@link StreamHandle} for\n * each newly observed top-level subgraph namespace and announces it on\n * the mux's shared {@link StreamMux._discoveries} channel.\n *\n * Previously this work was inlined in {@link StreamMux.push}.  Extracting\n * it into a transformer aligns discovery with the rest of the stream\n * architecture (lifecycle, values, messages are all transformers),\n * isolates the factory wiring, and makes discovery behavior\n * independently testable.\n *\n * The transformer also owns the read-side of discovery: it exposes an\n * `AsyncIterable<TStream>` projection (`subgraphs`) scoped to the root\n * namespace, and a {@link filterSubgraphHandles} helper that callers\n * can use to scope the same channel to any descendant namespace.  This\n * lets `GraphRunStream` drop its bespoke `subscribeSubgraphs`\n * delegation and surface child streams via the standard native\n * projection pattern.\n *\n * Only first-level namespace segments are announced.  Deeper segments\n * (e.g. `[\"researcher:uuid\", \"tools:uuid\"]`) are internal Pregel\n * checkpoint namespaces for nodes inside a subgraph and should not\n * appear as user-facing `SubgraphRunStream` instances; the mux still\n * resolves their values via its own `#streamMap` when registered\n * elsewhere.\n */\n\nimport { hasPrefix, nsKey } from \"../mux.js\";\nimport type { StreamHandle, StreamMux, SubgraphDiscovery } from \"../mux.js\";\nimport type {\n  Namespace,\n  NativeStreamTransformer,\n  ProtocolEvent,\n} from \"../types.js\";\nimport type { StreamChannel } from \"../stream-channel.js\";\n\n/**\n * Projection returned by {@link createSubgraphDiscoveryTransformer}.\n *\n * @typeParam TStream - Concrete stream handle type produced by the\n *   configured factory (e.g. `SubgraphRunStream`).\n */\nexport interface SubgraphDiscoveryProjection<\n  TStream extends StreamHandle = StreamHandle,\n> {\n  /**\n   * Shared discovery channel on the mux.  The transformer writes to it so\n   * the channel's lifetime stays tied to the mux (closed on `mux.close()`\n   * / failed on `mux.fail()`).  The underscore prefix signals internal\n   * wiring: consumers should iterate {@link subgraphs} instead.\n   */\n  _discoveries: StreamChannel<SubgraphDiscovery>;\n\n  /**\n   * Async iterable of direct child stream handles of the root\n   * namespace.  Wired onto `GraphRunStream.subgraphs` during root\n   * stream construction.  For descendant namespaces, use\n   * {@link filterSubgraphHandles} to scope the same log.\n   */\n  subgraphs: AsyncIterable<TStream>;\n}\n\n/**\n * Configuration for {@link createSubgraphDiscoveryTransformer}.\n */\nexport interface SubgraphDiscoveryTransformerOptions<\n  TStream extends StreamHandle = StreamHandle,\n> {\n  /**\n   * Factory invoked once per newly observed top-level namespace.\n   *\n   * Receives the discovery-channel and event-channel offsets so the resulting\n   * stream can iterate only events arriving after the namespace was\n   * first seen (no retroactive replay).\n   *\n   * @param path - The single-segment top-level namespace.\n   * @param discoveryStart - Current size of the mux discovery log.\n   * @param eventStart - Current size of the mux event log.\n   * @returns A stream handle registered with the mux for values/error\n   *   resolution on close/fail.\n   */\n  createStream: (\n    path: Namespace,\n    discoveryStart: number,\n    eventStart: number\n  ) => TStream;\n}\n\n/**\n * Filter a {@link SubgraphDiscovery} channel to only the direct children\n * of a given namespace.\n *\n * Returns an `AsyncIterable` whose iterator yields stream handles for\n * discoveries whose namespace is exactly one segment deeper than\n * {@link path} and shares it as a prefix.  Iteration begins at\n * {@link startAt} (so each caller picks up only discoveries added\n * after its construction) and terminates when the underlying log\n * closes or fails.\n *\n * @typeParam TStream - Concrete stream type recorded in the log.\n *   Callers may cast if the log was populated by a specific factory.\n * @param log - The shared discovery channel (`mux._discoveries`).\n * @param path - Parent namespace whose direct children should be\n *   yielded.\n * @param startAt - Zero-based index into the discovery log to begin\n *   from.\n * @returns An async iterable of stream handles.\n */\nexport function filterSubgraphHandles<\n  TStream extends StreamHandle = StreamHandle,\n>(\n  log: StreamChannel<SubgraphDiscovery>,\n  path: Namespace,\n  startAt = 0\n): AsyncIterable<TStream> {\n  const targetDepth = path.length + 1;\n  return {\n    [Symbol.asyncIterator](): AsyncIterator<TStream> {\n      const base = log.iterate(startAt);\n      return {\n        async next(): Promise<IteratorResult<TStream>> {\n          // eslint-disable-next-line no-constant-condition\n          while (true) {\n            const result = await base.next();\n            if (result.done) {\n              return { value: undefined as unknown as TStream, done: true };\n            }\n            const { ns, stream } = result.value;\n            if (ns.length === targetDepth && hasPrefix(ns, path)) {\n              return { value: stream as TStream, done: false };\n            }\n          }\n        },\n      };\n    },\n  };\n}\n\n/**\n * Create the subgraph discovery transformer.\n *\n * Registering this transformer against a mux replaces the legacy\n * inline behavior that previously lived in {@link StreamMux.push}.\n * The mux no longer knows about the subgraph factory: instead, this\n * transformer is the single component that materializes stream\n * handles and announces them on `_discoveries`.\n *\n * Marked as a {@link NativeStreamTransformer} so the projection is\n * treated as internal wiring (not merged into `run.extensions` and\n * not auto-forwarded via {@link StreamMux.wireChannels}).\n *\n * @typeParam TStream - Concrete stream handle type produced by\n *   {@link SubgraphDiscoveryTransformerOptions.createStream}.\n *   Defaults to the base {@link StreamHandle} interface.\n * @param mux - The mux whose `_discoveries` log should receive\n *   discovery entries and whose `register` will be called for each\n *   new stream handle.\n * @param options - Factory and related wiring.\n * @returns A native transformer that populates\n *   {@link StreamMux._discoveries} and exposes a root-scoped\n *   `subgraphs` iterable via its projection.\n */\nexport function createSubgraphDiscoveryTransformer<\n  TStream extends StreamHandle = StreamHandle,\n>(\n  mux: StreamMux,\n  options: SubgraphDiscoveryTransformerOptions<TStream>\n): NativeStreamTransformer<SubgraphDiscoveryProjection<TStream>> {\n  const { createStream } = options;\n  const seen = new Set<string>();\n\n  return {\n    __native: true,\n\n    init() {\n      return {\n        _discoveries: mux._discoveries,\n        subgraphs: filterSubgraphHandles<TStream>(mux._discoveries, [], 0),\n      };\n    },\n\n    process(event: ProtocolEvent): boolean {\n      const ns = event.params.namespace;\n      if (ns.length === 0) return true;\n\n      const topNs = ns.slice(0, 1);\n      const topKey = nsKey(topNs);\n      if (seen.has(topKey)) return true;\n      seen.add(topKey);\n\n      const stream = createStream(\n        topNs,\n        mux._discoveries.size,\n        mux._events.size\n      );\n      mux.register(topNs, stream);\n      mux._discoveries.push({ ns: topNs, stream });\n      return true;\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4GA,SAAgB,sBAGd,KACA,MACA,UAAU,GACc;CACxB,MAAM,cAAc,KAAK,SAAS;AAClC,QAAO,EACL,CAAC,OAAO,iBAAyC;EAC/C,MAAM,OAAO,IAAI,QAAQ,QAAQ;AACjC,SAAO,EACL,MAAM,OAAyC;AAE7C,UAAO,MAAM;IACX,MAAM,SAAS,MAAM,KAAK,MAAM;AAChC,QAAI,OAAO,KACT,QAAO;KAAE,OAAO,KAAA;KAAiC,MAAM;KAAM;IAE/D,MAAM,EAAE,IAAI,WAAW,OAAO;AAC9B,QAAI,GAAG,WAAW,eAAeA,YAAAA,UAAU,IAAI,KAAK,CAClD,QAAO;KAAE,OAAO;KAAmB,MAAM;KAAO;;KAIvD;IAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BH,SAAgB,mCAGd,KACA,SAC+D;CAC/D,MAAM,EAAE,iBAAiB;CACzB,MAAM,uBAAO,IAAI,KAAa;AAE9B,QAAO;EACL,UAAU;EAEV,OAAO;AACL,UAAO;IACL,cAAc,IAAI;IAClB,WAAW,sBAA+B,IAAI,cAAc,EAAE,EAAE,EAAE;IACnE;;EAGH,QAAQ,OAA+B;GACrC,MAAM,KAAK,MAAM,OAAO;AACxB,OAAI,GAAG,WAAW,EAAG,QAAO;GAE5B,MAAM,QAAQ,GAAG,MAAM,GAAG,EAAE;GAC5B,MAAM,SAASC,YAAAA,MAAM,MAAM;AAC3B,OAAI,KAAK,IAAI,OAAO,CAAE,QAAO;AAC7B,QAAK,IAAI,OAAO;GAEhB,MAAM,SAAS,aACb,OACA,IAAI,aAAa,MACjB,IAAI,QAAQ,KACb;AACD,OAAI,SAAS,OAAO,OAAO;AAC3B,OAAI,aAAa,KAAK;IAAE,IAAI;IAAO;IAAQ,CAAC;AAC5C,UAAO;;EAEV"}

package/dist/stream/transformers/subgraphs.d.cts

@@ -0,0 +1,95 @@
+import { Namespace, NativeStreamTransformer } from "../types.cjs";
+import { StreamChannel } from "../stream-channel.cjs";
+import { StreamHandle, StreamMux, SubgraphDiscovery } from "../mux.cjs";
+
+//#region src/stream/transformers/subgraphs.d.ts
+/**
+ * Projection returned by {@link createSubgraphDiscoveryTransformer}.
+ *
+ * @typeParam TStream - Concrete stream handle type produced by the
+ *   configured factory (e.g. `SubgraphRunStream`).
+ */
+interface SubgraphDiscoveryProjection<TStream extends StreamHandle = StreamHandle> {
+  /**
+   * Shared discovery channel on the mux.  The transformer writes to it so
+   * the channel's lifetime stays tied to the mux (closed on `mux.close()`
+   * / failed on `mux.fail()`).  The underscore prefix signals internal
+   * wiring: consumers should iterate {@link subgraphs} instead.
+   */
+  _discoveries: StreamChannel<SubgraphDiscovery>;
+  /**
+   * Async iterable of direct child stream handles of the root
+   * namespace.  Wired onto `GraphRunStream.subgraphs` during root
+   * stream construction.  For descendant namespaces, use
+   * {@link filterSubgraphHandles} to scope the same log.
+   */
+  subgraphs: AsyncIterable<TStream>;
+}
+/**
+ * Configuration for {@link createSubgraphDiscoveryTransformer}.
+ */
+interface SubgraphDiscoveryTransformerOptions<TStream extends StreamHandle = StreamHandle> {
+  /**
+   * Factory invoked once per newly observed top-level namespace.
+   *
+   * Receives the discovery-channel and event-channel offsets so the resulting
+   * stream can iterate only events arriving after the namespace was
+   * first seen (no retroactive replay).
+   *
+   * @param path - The single-segment top-level namespace.
+   * @param discoveryStart - Current size of the mux discovery log.
+   * @param eventStart - Current size of the mux event log.
+   * @returns A stream handle registered with the mux for values/error
+   *   resolution on close/fail.
+   */
+  createStream: (path: Namespace, discoveryStart: number, eventStart: number) => TStream;
+}
+/**
+ * Filter a {@link SubgraphDiscovery} channel to only the direct children
+ * of a given namespace.
+ *
+ * Returns an `AsyncIterable` whose iterator yields stream handles for
+ * discoveries whose namespace is exactly one segment deeper than
+ * {@link path} and shares it as a prefix.  Iteration begins at
+ * {@link startAt} (so each caller picks up only discoveries added
+ * after its construction) and terminates when the underlying log
+ * closes or fails.
+ *
+ * @typeParam TStream - Concrete stream type recorded in the log.
+ *   Callers may cast if the log was populated by a specific factory.
+ * @param log - The shared discovery channel (`mux._discoveries`).
+ * @param path - Parent namespace whose direct children should be
+ *   yielded.
+ * @param startAt - Zero-based index into the discovery log to begin
+ *   from.
+ * @returns An async iterable of stream handles.
+ */
+declare function filterSubgraphHandles<TStream extends StreamHandle = StreamHandle>(log: StreamChannel<SubgraphDiscovery>, path: Namespace, startAt?: number): AsyncIterable<TStream>;
+/**
+ * Create the subgraph discovery transformer.
+ *
+ * Registering this transformer against a mux replaces the legacy
+ * inline behavior that previously lived in {@link StreamMux.push}.
+ * The mux no longer knows about the subgraph factory: instead, this
+ * transformer is the single component that materializes stream
+ * handles and announces them on `_discoveries`.
+ *
+ * Marked as a {@link NativeStreamTransformer} so the projection is
+ * treated as internal wiring (not merged into `run.extensions` and
+ * not auto-forwarded via {@link StreamMux.wireChannels}).
+ *
+ * @typeParam TStream - Concrete stream handle type produced by
+ *   {@link SubgraphDiscoveryTransformerOptions.createStream}.
+ *   Defaults to the base {@link StreamHandle} interface.
+ * @param mux - The mux whose `_discoveries` log should receive
+ *   discovery entries and whose `register` will be called for each
+ *   new stream handle.
+ * @param options - Factory and related wiring.
+ * @returns A native transformer that populates
+ *   {@link StreamMux._discoveries} and exposes a root-scoped
+ *   `subgraphs` iterable via its projection.
+ */
+declare function createSubgraphDiscoveryTransformer<TStream extends StreamHandle = StreamHandle>(mux: StreamMux, options: SubgraphDiscoveryTransformerOptions<TStream>): NativeStreamTransformer<SubgraphDiscoveryProjection<TStream>>;
+//#endregion
+export { SubgraphDiscoveryProjection, SubgraphDiscoveryTransformerOptions, createSubgraphDiscoveryTransformer, filterSubgraphHandles };
+//# sourceMappingURL=subgraphs.d.cts.map

package/dist/stream/transformers/subgraphs.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subgraphs.d.cts","names":[],"sources":["../../../src/stream/transformers/subgraphs.ts"],"mappings":";;;;;;;;;;;UA0CiB,2BAAA,iBACC,YAAA,GAAe,YAAA;EAuB/B;;;;;;EAfA,YAAA,EAAc,aAAA,CAAc,iBAAA;EAiC1B;;;;AAwBJ;;EAjDE,SAAA,EAAW,aAAA,CAAc,OAAA;AAAA;;;;UAMV,mCAAA,iBACC,YAAA,GAAe,YAAA;EAgDhB;;;;;;;;;;;;;EAjCf,YAAA,GACE,IAAA,EAAM,SAAA,EACN,cAAA,UACA,UAAA,aACG,OAAA;AAAA;;;AA6EP;;;;;;;;;;;;;;;;;;iBAtDgB,qBAAA,iBACE,YAAA,GAAe,YAAA,CAAA,CAE/B,GAAA,EAAK,aAAA,CAAc,iBAAA,GACnB,IAAA,EAAM,SAAA,EACN,OAAA,YACC,aAAA,CAAc,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDD,kCAAA,iBACE,YAAA,GAAe,YAAA,CAAA,CAE/B,GAAA,EAAK,SAAA,EACL,OAAA,EAAS,mCAAA,CAAoC,OAAA,IAC5C,uBAAA,CAAwB,2BAAA,CAA4B,OAAA"}

package/dist/stream/transformers/subgraphs.d.ts

@@ -0,0 +1,95 @@
+import { Namespace, NativeStreamTransformer } from "../types.js";
+import { StreamChannel } from "../stream-channel.js";
+import { StreamHandle, StreamMux, SubgraphDiscovery } from "../mux.js";
+
+//#region src/stream/transformers/subgraphs.d.ts
+/**
+ * Projection returned by {@link createSubgraphDiscoveryTransformer}.
+ *
+ * @typeParam TStream - Concrete stream handle type produced by the
+ *   configured factory (e.g. `SubgraphRunStream`).
+ */
+interface SubgraphDiscoveryProjection<TStream extends StreamHandle = StreamHandle> {
+  /**
+   * Shared discovery channel on the mux.  The transformer writes to it so
+   * the channel's lifetime stays tied to the mux (closed on `mux.close()`
+   * / failed on `mux.fail()`).  The underscore prefix signals internal
+   * wiring: consumers should iterate {@link subgraphs} instead.
+   */
+  _discoveries: StreamChannel<SubgraphDiscovery>;
+  /**
+   * Async iterable of direct child stream handles of the root
+   * namespace.  Wired onto `GraphRunStream.subgraphs` during root
+   * stream construction.  For descendant namespaces, use
+   * {@link filterSubgraphHandles} to scope the same log.
+   */
+  subgraphs: AsyncIterable<TStream>;
+}
+/**
+ * Configuration for {@link createSubgraphDiscoveryTransformer}.
+ */
+interface SubgraphDiscoveryTransformerOptions<TStream extends StreamHandle = StreamHandle> {
+  /**
+   * Factory invoked once per newly observed top-level namespace.
+   *
+   * Receives the discovery-channel and event-channel offsets so the resulting
+   * stream can iterate only events arriving after the namespace was
+   * first seen (no retroactive replay).
+   *
+   * @param path - The single-segment top-level namespace.
+   * @param discoveryStart - Current size of the mux discovery log.
+   * @param eventStart - Current size of the mux event log.
+   * @returns A stream handle registered with the mux for values/error
+   *   resolution on close/fail.
+   */
+  createStream: (path: Namespace, discoveryStart: number, eventStart: number) => TStream;
+}
+/**
+ * Filter a {@link SubgraphDiscovery} channel to only the direct children
+ * of a given namespace.
+ *
+ * Returns an `AsyncIterable` whose iterator yields stream handles for
+ * discoveries whose namespace is exactly one segment deeper than
+ * {@link path} and shares it as a prefix.  Iteration begins at
+ * {@link startAt} (so each caller picks up only discoveries added
+ * after its construction) and terminates when the underlying log
+ * closes or fails.
+ *
+ * @typeParam TStream - Concrete stream type recorded in the log.
+ *   Callers may cast if the log was populated by a specific factory.
+ * @param log - The shared discovery channel (`mux._discoveries`).
+ * @param path - Parent namespace whose direct children should be
+ *   yielded.
+ * @param startAt - Zero-based index into the discovery log to begin
+ *   from.
+ * @returns An async iterable of stream handles.
+ */
+declare function filterSubgraphHandles<TStream extends StreamHandle = StreamHandle>(log: StreamChannel<SubgraphDiscovery>, path: Namespace, startAt?: number): AsyncIterable<TStream>;
+/**
+ * Create the subgraph discovery transformer.
+ *
+ * Registering this transformer against a mux replaces the legacy
+ * inline behavior that previously lived in {@link StreamMux.push}.
+ * The mux no longer knows about the subgraph factory: instead, this
+ * transformer is the single component that materializes stream
+ * handles and announces them on `_discoveries`.
+ *
+ * Marked as a {@link NativeStreamTransformer} so the projection is
+ * treated as internal wiring (not merged into `run.extensions` and
+ * not auto-forwarded via {@link StreamMux.wireChannels}).
+ *
+ * @typeParam TStream - Concrete stream handle type produced by
+ *   {@link SubgraphDiscoveryTransformerOptions.createStream}.
+ *   Defaults to the base {@link StreamHandle} interface.
+ * @param mux - The mux whose `_discoveries` log should receive
+ *   discovery entries and whose `register` will be called for each
+ *   new stream handle.
+ * @param options - Factory and related wiring.
+ * @returns A native transformer that populates
+ *   {@link StreamMux._discoveries} and exposes a root-scoped
+ *   `subgraphs` iterable via its projection.
+ */
+declare function createSubgraphDiscoveryTransformer<TStream extends StreamHandle = StreamHandle>(mux: StreamMux, options: SubgraphDiscoveryTransformerOptions<TStream>): NativeStreamTransformer<SubgraphDiscoveryProjection<TStream>>;
+//#endregion
+export { SubgraphDiscoveryProjection, SubgraphDiscoveryTransformerOptions, createSubgraphDiscoveryTransformer, filterSubgraphHandles };
+//# sourceMappingURL=subgraphs.d.ts.map

package/dist/stream/transformers/subgraphs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subgraphs.d.ts","names":[],"sources":["../../../src/stream/transformers/subgraphs.ts"],"mappings":";;;;;;;;;;;UA0CiB,2BAAA,iBACC,YAAA,GAAe,YAAA;EAuB/B;;;;;;EAfA,YAAA,EAAc,aAAA,CAAc,iBAAA;EAiC1B;;;;AAwBJ;;EAjDE,SAAA,EAAW,aAAA,CAAc,OAAA;AAAA;;;;UAMV,mCAAA,iBACC,YAAA,GAAe,YAAA;EAgDhB;;;;;;;;;;;;;EAjCf,YAAA,GACE,IAAA,EAAM,SAAA,EACN,cAAA,UACA,UAAA,aACG,OAAA;AAAA;;;AA6EP;;;;;;;;;;;;;;;;;;iBAtDgB,qBAAA,iBACE,YAAA,GAAe,YAAA,CAAA,CAE/B,GAAA,EAAK,aAAA,CAAc,iBAAA,GACnB,IAAA,EAAM,SAAA,EACN,OAAA,YACC,aAAA,CAAc,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDD,kCAAA,iBACE,YAAA,GAAe,YAAA,CAAA,CAE/B,GAAA,EAAK,SAAA,EACL,OAAA,EAAS,mCAAA,CAAoC,OAAA,IAC5C,uBAAA,CAAwB,2BAAA,CAA4B,OAAA"}

package/dist/stream/transformers/subgraphs.js

@@ -0,0 +1,124 @@
+import { hasPrefix, nsKey } from "../mux.js";
+//#region src/stream/transformers/subgraphs.ts
+/**
+* SubgraphDiscoveryTransformer - materializes a {@link StreamHandle} for
+* each newly observed top-level subgraph namespace and announces it on
+* the mux's shared {@link StreamMux._discoveries} channel.
+*
+* Previously this work was inlined in {@link StreamMux.push}.  Extracting
+* it into a transformer aligns discovery with the rest of the stream
+* architecture (lifecycle, values, messages are all transformers),
+* isolates the factory wiring, and makes discovery behavior
+* independently testable.
+*
+* The transformer also owns the read-side of discovery: it exposes an
+* `AsyncIterable<TStream>` projection (`subgraphs`) scoped to the root
+* namespace, and a {@link filterSubgraphHandles} helper that callers
+* can use to scope the same channel to any descendant namespace.  This
+* lets `GraphRunStream` drop its bespoke `subscribeSubgraphs`
+* delegation and surface child streams via the standard native
+* projection pattern.
+*
+* Only first-level namespace segments are announced.  Deeper segments
+* (e.g. `["researcher:uuid", "tools:uuid"]`) are internal Pregel
+* checkpoint namespaces for nodes inside a subgraph and should not
+* appear as user-facing `SubgraphRunStream` instances; the mux still
+* resolves their values via its own `#streamMap` when registered
+* elsewhere.
+*/
+/**
+* Filter a {@link SubgraphDiscovery} channel to only the direct children
+* of a given namespace.
+*
+* Returns an `AsyncIterable` whose iterator yields stream handles for
+* discoveries whose namespace is exactly one segment deeper than
+* {@link path} and shares it as a prefix.  Iteration begins at
+* {@link startAt} (so each caller picks up only discoveries added
+* after its construction) and terminates when the underlying log
+* closes or fails.
+*
+* @typeParam TStream - Concrete stream type recorded in the log.
+*   Callers may cast if the log was populated by a specific factory.
+* @param log - The shared discovery channel (`mux._discoveries`).
+* @param path - Parent namespace whose direct children should be
+*   yielded.
+* @param startAt - Zero-based index into the discovery log to begin
+*   from.
+* @returns An async iterable of stream handles.
+*/
+function filterSubgraphHandles(log, path, startAt = 0) {
+	const targetDepth = path.length + 1;
+	return { [Symbol.asyncIterator]() {
+		const base = log.iterate(startAt);
+		return { async next() {
+			while (true) {
+				const result = await base.next();
+				if (result.done) return {
+					value: void 0,
+					done: true
+				};
+				const { ns, stream } = result.value;
+				if (ns.length === targetDepth && hasPrefix(ns, path)) return {
+					value: stream,
+					done: false
+				};
+			}
+		} };
+	} };
+}
+/**
+* Create the subgraph discovery transformer.
+*
+* Registering this transformer against a mux replaces the legacy
+* inline behavior that previously lived in {@link StreamMux.push}.
+* The mux no longer knows about the subgraph factory: instead, this
+* transformer is the single component that materializes stream
+* handles and announces them on `_discoveries`.
+*
+* Marked as a {@link NativeStreamTransformer} so the projection is
+* treated as internal wiring (not merged into `run.extensions` and
+* not auto-forwarded via {@link StreamMux.wireChannels}).
+*
+* @typeParam TStream - Concrete stream handle type produced by
+*   {@link SubgraphDiscoveryTransformerOptions.createStream}.
+*   Defaults to the base {@link StreamHandle} interface.
+* @param mux - The mux whose `_discoveries` log should receive
+*   discovery entries and whose `register` will be called for each
+*   new stream handle.
+* @param options - Factory and related wiring.
+* @returns A native transformer that populates
+*   {@link StreamMux._discoveries} and exposes a root-scoped
+*   `subgraphs` iterable via its projection.
+*/
+function createSubgraphDiscoveryTransformer(mux, options) {
+	const { createStream } = options;
+	const seen = /* @__PURE__ */ new Set();
+	return {
+		__native: true,
+		init() {
+			return {
+				_discoveries: mux._discoveries,
+				subgraphs: filterSubgraphHandles(mux._discoveries, [], 0)
+			};
+		},
+		process(event) {
+			const ns = event.params.namespace;
+			if (ns.length === 0) return true;
+			const topNs = ns.slice(0, 1);
+			const topKey = nsKey(topNs);
+			if (seen.has(topKey)) return true;
+			seen.add(topKey);
+			const stream = createStream(topNs, mux._discoveries.size, mux._events.size);
+			mux.register(topNs, stream);
+			mux._discoveries.push({
+				ns: topNs,
+				stream
+			});
+			return true;
+		}
+	};
+}
+//#endregion
+export { createSubgraphDiscoveryTransformer, filterSubgraphHandles };
+
+//# sourceMappingURL=subgraphs.js.map

package/dist/stream/transformers/subgraphs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subgraphs.js","names":[],"sources":["../../../src/stream/transformers/subgraphs.ts"],"sourcesContent":["/**\n * SubgraphDiscoveryTransformer - materializes a {@link StreamHandle} for\n * each newly observed top-level subgraph namespace and announces it on\n * the mux's shared {@link StreamMux._discoveries} channel.\n *\n * Previously this work was inlined in {@link StreamMux.push}.  Extracting\n * it into a transformer aligns discovery with the rest of the stream\n * architecture (lifecycle, values, messages are all transformers),\n * isolates the factory wiring, and makes discovery behavior\n * independently testable.\n *\n * The transformer also owns the read-side of discovery: it exposes an\n * `AsyncIterable<TStream>` projection (`subgraphs`) scoped to the root\n * namespace, and a {@link filterSubgraphHandles} helper that callers\n * can use to scope the same channel to any descendant namespace.  This\n * lets `GraphRunStream` drop its bespoke `subscribeSubgraphs`\n * delegation and surface child streams via the standard native\n * projection pattern.\n *\n * Only first-level namespace segments are announced.  Deeper segments\n * (e.g. `[\"researcher:uuid\", \"tools:uuid\"]`) are internal Pregel\n * checkpoint namespaces for nodes inside a subgraph and should not\n * appear as user-facing `SubgraphRunStream` instances; the mux still\n * resolves their values via its own `#streamMap` when registered\n * elsewhere.\n */\n\nimport { hasPrefix, nsKey } from \"../mux.js\";\nimport type { StreamHandle, StreamMux, SubgraphDiscovery } from \"../mux.js\";\nimport type {\n  Namespace,\n  NativeStreamTransformer,\n  ProtocolEvent,\n} from \"../types.js\";\nimport type { StreamChannel } from \"../stream-channel.js\";\n\n/**\n * Projection returned by {@link createSubgraphDiscoveryTransformer}.\n *\n * @typeParam TStream - Concrete stream handle type produced by the\n *   configured factory (e.g. `SubgraphRunStream`).\n */\nexport interface SubgraphDiscoveryProjection<\n  TStream extends StreamHandle = StreamHandle,\n> {\n  /**\n   * Shared discovery channel on the mux.  The transformer writes to it so\n   * the channel's lifetime stays tied to the mux (closed on `mux.close()`\n   * / failed on `mux.fail()`).  The underscore prefix signals internal\n   * wiring: consumers should iterate {@link subgraphs} instead.\n   */\n  _discoveries: StreamChannel<SubgraphDiscovery>;\n\n  /**\n   * Async iterable of direct child stream handles of the root\n   * namespace.  Wired onto `GraphRunStream.subgraphs` during root\n   * stream construction.  For descendant namespaces, use\n   * {@link filterSubgraphHandles} to scope the same log.\n   */\n  subgraphs: AsyncIterable<TStream>;\n}\n\n/**\n * Configuration for {@link createSubgraphDiscoveryTransformer}.\n */\nexport interface SubgraphDiscoveryTransformerOptions<\n  TStream extends StreamHandle = StreamHandle,\n> {\n  /**\n   * Factory invoked once per newly observed top-level namespace.\n   *\n   * Receives the discovery-channel and event-channel offsets so the resulting\n   * stream can iterate only events arriving after the namespace was\n   * first seen (no retroactive replay).\n   *\n   * @param path - The single-segment top-level namespace.\n   * @param discoveryStart - Current size of the mux discovery log.\n   * @param eventStart - Current size of the mux event log.\n   * @returns A stream handle registered with the mux for values/error\n   *   resolution on close/fail.\n   */\n  createStream: (\n    path: Namespace,\n    discoveryStart: number,\n    eventStart: number\n  ) => TStream;\n}\n\n/**\n * Filter a {@link SubgraphDiscovery} channel to only the direct children\n * of a given namespace.\n *\n * Returns an `AsyncIterable` whose iterator yields stream handles for\n * discoveries whose namespace is exactly one segment deeper than\n * {@link path} and shares it as a prefix.  Iteration begins at\n * {@link startAt} (so each caller picks up only discoveries added\n * after its construction) and terminates when the underlying log\n * closes or fails.\n *\n * @typeParam TStream - Concrete stream type recorded in the log.\n *   Callers may cast if the log was populated by a specific factory.\n * @param log - The shared discovery channel (`mux._discoveries`).\n * @param path - Parent namespace whose direct children should be\n *   yielded.\n * @param startAt - Zero-based index into the discovery log to begin\n *   from.\n * @returns An async iterable of stream handles.\n */\nexport function filterSubgraphHandles<\n  TStream extends StreamHandle = StreamHandle,\n>(\n  log: StreamChannel<SubgraphDiscovery>,\n  path: Namespace,\n  startAt = 0\n): AsyncIterable<TStream> {\n  const targetDepth = path.length + 1;\n  return {\n    [Symbol.asyncIterator](): AsyncIterator<TStream> {\n      const base = log.iterate(startAt);\n      return {\n        async next(): Promise<IteratorResult<TStream>> {\n          // eslint-disable-next-line no-constant-condition\n          while (true) {\n            const result = await base.next();\n            if (result.done) {\n              return { value: undefined as unknown as TStream, done: true };\n            }\n            const { ns, stream } = result.value;\n            if (ns.length === targetDepth && hasPrefix(ns, path)) {\n              return { value: stream as TStream, done: false };\n            }\n          }\n        },\n      };\n    },\n  };\n}\n\n/**\n * Create the subgraph discovery transformer.\n *\n * Registering this transformer against a mux replaces the legacy\n * inline behavior that previously lived in {@link StreamMux.push}.\n * The mux no longer knows about the subgraph factory: instead, this\n * transformer is the single component that materializes stream\n * handles and announces them on `_discoveries`.\n *\n * Marked as a {@link NativeStreamTransformer} so the projection is\n * treated as internal wiring (not merged into `run.extensions` and\n * not auto-forwarded via {@link StreamMux.wireChannels}).\n *\n * @typeParam TStream - Concrete stream handle type produced by\n *   {@link SubgraphDiscoveryTransformerOptions.createStream}.\n *   Defaults to the base {@link StreamHandle} interface.\n * @param mux - The mux whose `_discoveries` log should receive\n *   discovery entries and whose `register` will be called for each\n *   new stream handle.\n * @param options - Factory and related wiring.\n * @returns A native transformer that populates\n *   {@link StreamMux._discoveries} and exposes a root-scoped\n *   `subgraphs` iterable via its projection.\n */\nexport function createSubgraphDiscoveryTransformer<\n  TStream extends StreamHandle = StreamHandle,\n>(\n  mux: StreamMux,\n  options: SubgraphDiscoveryTransformerOptions<TStream>\n): NativeStreamTransformer<SubgraphDiscoveryProjection<TStream>> {\n  const { createStream } = options;\n  const seen = new Set<string>();\n\n  return {\n    __native: true,\n\n    init() {\n      return {\n        _discoveries: mux._discoveries,\n        subgraphs: filterSubgraphHandles<TStream>(mux._discoveries, [], 0),\n      };\n    },\n\n    process(event: ProtocolEvent): boolean {\n      const ns = event.params.namespace;\n      if (ns.length === 0) return true;\n\n      const topNs = ns.slice(0, 1);\n      const topKey = nsKey(topNs);\n      if (seen.has(topKey)) return true;\n      seen.add(topKey);\n\n      const stream = createStream(\n        topNs,\n        mux._discoveries.size,\n        mux._events.size\n      );\n      mux.register(topNs, stream);\n      mux._discoveries.push({ ns: topNs, stream });\n      return true;\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4GA,SAAgB,sBAGd,KACA,MACA,UAAU,GACc;CACxB,MAAM,cAAc,KAAK,SAAS;AAClC,QAAO,EACL,CAAC,OAAO,iBAAyC;EAC/C,MAAM,OAAO,IAAI,QAAQ,QAAQ;AACjC,SAAO,EACL,MAAM,OAAyC;AAE7C,UAAO,MAAM;IACX,MAAM,SAAS,MAAM,KAAK,MAAM;AAChC,QAAI,OAAO,KACT,QAAO;KAAE,OAAO,KAAA;KAAiC,MAAM;KAAM;IAE/D,MAAM,EAAE,IAAI,WAAW,OAAO;AAC9B,QAAI,GAAG,WAAW,eAAe,UAAU,IAAI,KAAK,CAClD,QAAO;KAAE,OAAO;KAAmB,MAAM;KAAO;;KAIvD;IAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BH,SAAgB,mCAGd,KACA,SAC+D;CAC/D,MAAM,EAAE,iBAAiB;CACzB,MAAM,uBAAO,IAAI,KAAa;AAE9B,QAAO;EACL,UAAU;EAEV,OAAO;AACL,UAAO;IACL,cAAc,IAAI;IAClB,WAAW,sBAA+B,IAAI,cAAc,EAAE,EAAE,EAAE;IACnE;;EAGH,QAAQ,OAA+B;GACrC,MAAM,KAAK,MAAM,OAAO;AACxB,OAAI,GAAG,WAAW,EAAG,QAAO;GAE5B,MAAM,QAAQ,GAAG,MAAM,GAAG,EAAE;GAC5B,MAAM,SAAS,MAAM,MAAM;AAC3B,OAAI,KAAK,IAAI,OAAO,CAAE,QAAO;AAC7B,QAAK,IAAI,OAAO;GAEhB,MAAM,SAAS,aACb,OACA,IAAI,aAAa,MACjB,IAAI,QAAQ,KACb;AACD,OAAI,SAAS,OAAO,OAAO;AAC3B,OAAI,aAAa,KAAK;IAAE,IAAI;IAAO;IAAQ,CAAC;AAC5C,UAAO;;EAEV"}