@hediet/linkrpc-infra 0.0.1

package/dist/inspection/index.js

@@ -0,0 +1,734 @@
+import { DEFAULT_RPC_TIMEOUT_MS, withRpcTimeout } from "@hediet/linkrpc";
+import { nodeInterface, topologyInterface, trafficInterface } from "@hediet/linkrpc/inspection";
+import { HubDirectoryExplorer } from "@hediet/linkrpc/hub/common";
+//#region src/inspection/nodeInfoClient.ts
+/** Typed convenience client for root and service-scoped node identity. */
+var NodeInfoClient = class {
+	_connection;
+	constructor(_connection) {
+		this._connection = _connection;
+	}
+	getPeer() {
+		return this._connection.get(nodeInterface).getNodeId({});
+	}
+	getForService(serviceId) {
+		return this._connection.service(serviceId).get(nodeInterface).getNodeId({});
+	}
+};
+//#endregion
+//#region src/inspection/topologyClient.ts
+/** Snapshot and invalidation-watch client for one inspected service. */
+var TopologyClient = class {
+	_connection;
+	serviceId;
+	_timeoutMs;
+	constructor(_connection, serviceId, _timeoutMs = DEFAULT_RPC_TIMEOUT_MS) {
+		this._connection = _connection;
+		this.serviceId = serviceId;
+		this._timeoutMs = _timeoutMs;
+	}
+	getGraph() {
+		const request = this._connection.service(this.serviceId).get(topologyInterface).getGraph({});
+		return withRpcTimeout(request, `topology service '${this.serviceId}'`, this._timeoutMs);
+	}
+	watch(callbacks) {
+		const client = this._connection.service(this.serviceId).get(topologyInterface);
+		let active = true;
+		let dirty = false;
+		let refreshing = false;
+		let refreshTail = Promise.resolve();
+		let readySettled = false;
+		let resolveReady;
+		let rejectReady;
+		const ready = new Promise((resolve, reject) => {
+			resolveReady = resolve;
+			rejectReady = reject;
+		});
+		const reportError = (error) => {
+			try {
+				callbacks.onError?.(error);
+			} catch {}
+		};
+		const requestRefresh = () => {
+			if (!active) return;
+			dirty = true;
+			if (refreshing) return;
+			refreshing = true;
+			refreshTail = (async () => {
+				while (active && dirty) {
+					dirty = false;
+					try {
+						const graph = await withRpcTimeout(client.getGraph({}), `topology service '${this.serviceId}'`, this._timeoutMs);
+						if (!active) break;
+						try {
+							callbacks.onGraph(graph);
+						} catch (error) {
+							reportError(error);
+						}
+						if (!readySettled) {
+							readySettled = true;
+							resolveReady(graph);
+						}
+					} catch (error) {
+						reportError(error);
+						if (!readySettled) {
+							readySettled = true;
+							rejectReady(error);
+						}
+					}
+				}
+			})().finally(() => {
+				refreshing = false;
+				if (active && dirty) requestRefresh();
+			});
+		};
+		const call = client.watchGraph({}, { onMessage: requestRefresh });
+		requestRefresh();
+		return {
+			ready,
+			done: (async () => {
+				try {
+					await call;
+				} catch (error) {
+					reportError(error);
+					throw error;
+				} finally {
+					active = false;
+				}
+				await refreshTail;
+			})(),
+			cancel: async (reason) => {
+				active = false;
+				if (!readySettled) {
+					readySettled = true;
+					rejectReady(new Error(reason ?? "Topology watch cancelled"));
+				}
+				try {
+					await call.cancel(reason);
+				} finally {
+					call.dispose?.(reason);
+				}
+			}
+		};
+	}
+};
+//#endregion
+//#region src/inspection/trafficClient.ts
+/** Traffic stream client for the endpoint node hosting one service. */
+var TrafficClient = class {
+	_connection;
+	serviceId;
+	constructor(_connection, serviceId) {
+		this._connection = _connection;
+		this.serviceId = serviceId;
+	}
+	watch(options, callbacks) {
+		const call = this._connection.service(this.serviceId).get(trafficInterface).watch(withTrafficIgnoreKey(options), { onMessage: (event) => {
+			dispatchTrafficEvent(event, callbacks);
+		} });
+		call.catch((error) => reportTrafficError(callbacks, error));
+		return {
+			done: call,
+			cancel: async (reason) => {
+				try {
+					await call.cancel(reason);
+					await call;
+				} finally {
+					call.dispose?.(reason);
+				}
+			}
+		};
+	}
+	watchWithPayloads(options, callbacks) {
+		const call = this._connection.service(this.serviceId).get(trafficInterface).watchWithPayloads(withTrafficIgnoreKey(options), { onMessage: (event) => {
+			dispatchTrafficEvent(event, callbacks);
+		} });
+		call.catch((error) => reportTrafficError(callbacks, error));
+		return {
+			done: call,
+			cancel: async (reason) => {
+				try {
+					await call.cancel(reason);
+					await call;
+				} finally {
+					call.dispose?.(reason);
+				}
+			}
+		};
+	}
+};
+function withTrafficIgnoreKey(options) {
+	return {
+		...options,
+		trafficIgnoreKey: options.trafficIgnoreKey ?? createTrafficIgnoreKey()
+	};
+}
+function createTrafficIgnoreKey() {
+	if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	globalThis.crypto.getRandomValues(bytes);
+	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function dispatchTrafficEvent(event, callbacks) {
+	try {
+		if (event.type === "transit") callbacks.onTransit(event);
+		else callbacks.onOverflow?.(event);
+	} catch (error) {
+		reportTrafficError(callbacks, error);
+	}
+}
+function reportTrafficError(callbacks, error) {
+	try {
+		callbacks.onError?.(error);
+	} catch {}
+}
+//#endregion
+//#region src/inspection/topologyGraph.ts
+function mergeTopologyGraphs(inputs) {
+	const nodes = /* @__PURE__ */ new Map();
+	const links = /* @__PURE__ */ new Map();
+	const routes = /* @__PURE__ */ new Map();
+	for (const { source, graph } of [...inputs].sort((a, b) => a.source.localeCompare(b.source))) {
+		for (const node of graph.nodes) {
+			const existing = nodes.get(node.nodeId);
+			if (existing === void 0) nodes.set(node.nodeId, {
+				value: cloneTopologyNode(node),
+				sources: /* @__PURE__ */ new Set([source])
+			});
+			else {
+				existing.sources.add(source);
+				if (node.kind === "hub") existing.value.kind = "hub";
+				existing.value.label ??= node.label;
+				for (const port of node.ports) {
+					const current = existing.value.ports.find((candidate) => candidate.portId === port.portId);
+					if (current === void 0) existing.value.ports.push({ ...port });
+					else current.label ??= port.label;
+				}
+				const descriptors = existing.value.descriptors ?? [];
+				const descriptorKeys = new Set(descriptors.map(descriptorKey));
+				for (const descriptor of node.descriptors ?? []) {
+					const key = descriptorKey(descriptor);
+					if (!descriptorKeys.has(key)) {
+						descriptors.push(cloneParticipantDescriptorSource(descriptor));
+						descriptorKeys.add(key);
+					}
+				}
+				if (descriptors.length > 0) existing.value.descriptors = descriptors;
+			}
+		}
+		for (const link of graph.links) {
+			const isReversed = endpointKey(link.from) > endpointKey(link.to);
+			const [from, to] = canonicalEndpoints(link.from, link.to);
+			const key = `${endpointKey(from)}\u0000${endpointKey(to)}`;
+			const value = {
+				...link,
+				from,
+				to,
+				...link.transport === void 0 ? {} : { transport: cloneTopologyTransport(link.transport, isReversed) }
+			};
+			const existing = links.get(key);
+			if (existing === void 0) links.set(key, {
+				value,
+				sources: /* @__PURE__ */ new Set([source])
+			});
+			else {
+				existing.sources.add(source);
+				existing.value.transport ??= value.transport;
+			}
+		}
+		for (const route of graph.routes) {
+			const key = `${route.serviceId}\u0000${route.nodeId}\u0000${route.portId}\u0000${route.match}`;
+			const existing = routes.get(key);
+			if (existing === void 0) routes.set(key, {
+				value: { ...route },
+				sources: /* @__PURE__ */ new Set([source])
+			});
+			else existing.sources.add(source);
+		}
+	}
+	const sourcedRoutes = [...routes.values()].map(({ value, sources }) => ({
+		...value,
+		sources: [...sources].sort()
+	}));
+	return {
+		nodes: [...nodes.values()].map(({ value, sources }) => ({
+			...value,
+			ports: [...value.ports].sort((a, b) => a.portId.localeCompare(b.portId)),
+			...value.descriptors === void 0 ? {} : { descriptors: [...value.descriptors].sort((a, b) => descriptorKey(a).localeCompare(descriptorKey(b))) },
+			sources: [...sources].sort()
+		})).sort((a, b) => a.nodeId.localeCompare(b.nodeId)),
+		links: [...links.values()].map(({ value, sources }) => ({
+			...value,
+			sources: [...sources].sort()
+		})).sort((a, b) => endpointKey(a.from).localeCompare(endpointKey(b.from)) || endpointKey(a.to).localeCompare(endpointKey(b.to))),
+		routes: sourcedRoutes.sort((a, b) => a.serviceId.localeCompare(b.serviceId) || a.nodeId.localeCompare(b.nodeId) || a.portId.localeCompare(b.portId) || a.match.localeCompare(b.match)),
+		sources: [...inputs].sort((a, b) => a.source.localeCompare(b.source)).map(({ source, graph }) => ({
+			serviceId: source,
+			observerServiceId: graph.observerServiceId,
+			entryNodeId: graph.entryNodeId
+		}))
+	};
+}
+function cloneTopologyNode(node) {
+	return {
+		...node,
+		ports: node.ports.map((port) => ({ ...port })),
+		...node.descriptors === void 0 ? {} : { descriptors: node.descriptors.map(cloneParticipantDescriptorSource) }
+	};
+}
+function cloneParticipantDescriptorSource(source) {
+	return {
+		...source,
+		descriptor: {
+			...source.descriptor,
+			...source.descriptor.metadata === void 0 ? {} : { metadata: { ...source.descriptor.metadata } }
+		}
+	};
+}
+function cloneTopologyTransport(transport, reverse) {
+	const { local: reportedLocal, remote: reportedRemote, metadata, ...rest } = transport;
+	const local = reverse ? reportedRemote : reportedLocal;
+	const remote = reverse ? reportedLocal : reportedRemote;
+	return {
+		...rest,
+		...local === void 0 ? {} : { local: { ...local } },
+		...remote === void 0 ? {} : { remote: { ...remote } },
+		...metadata === void 0 ? {} : { metadata: { ...metadata } }
+	};
+}
+function descriptorKey(source) {
+	const descriptor = source.descriptor;
+	const metadata = descriptor.metadata === void 0 ? void 0 : Object.fromEntries(Object.entries(descriptor.metadata).sort(([a], [b]) => a.localeCompare(b)));
+	return JSON.stringify({
+		source: source.source,
+		descriptor: {
+			...descriptor,
+			...metadata === void 0 ? {} : { metadata }
+		}
+	});
+}
+function canonicalEndpoints(a, b) {
+	return endpointKey(a) <= endpointKey(b) ? [a, b] : [b, a];
+}
+function endpointKey(endpoint) {
+	return `${endpoint.nodeId}\u0000${endpoint.portId}`;
+}
+//#endregion
+//#region src/inspection/networkInspectionClient.ts
+/**
+* Merges independently observed service graphs. Traffic is deliberately not
+* deduplicated: each source remains identified so consumers can stitch flows.
+*/
+var NetworkInspectionClient = class {
+	_connection;
+	_options;
+	_sources = /* @__PURE__ */ new Map();
+	_trafficGroups = /* @__PURE__ */ new Set();
+	constructor(_connection, _options = {}) {
+		this._connection = _connection;
+		this._options = _options;
+	}
+	async addTopologyService(serviceId) {
+		const existing = this._sources.get(serviceId);
+		if (existing !== void 0) {
+			await existing.watch.ready;
+			return;
+		}
+		const client = new TopologyClient(this._connection, serviceId);
+		let source;
+		const watch = client.watch({
+			onGraph: (graph) => {
+				source.graph = graph;
+				this._options.onGraph?.(this.getGraph());
+			},
+			onError: (error) => this._options.onError?.(error, serviceId)
+		});
+		source = {
+			client,
+			watch,
+			graph: void 0
+		};
+		this._sources.set(serviceId, source);
+		for (const group of this._trafficGroups) group.add(serviceId);
+		try {
+			await watch.ready;
+		} catch (error) {
+			if (this._sources.get(serviceId) === source) await this.removeTopologyService(serviceId);
+			else {
+				await source.watch.cancel("source-replaced").catch(() => void 0);
+				await source.watch.done.catch(() => void 0);
+			}
+			throw error;
+		}
+	}
+	async removeTopologyService(serviceId) {
+		const source = this._sources.get(serviceId);
+		if (source === void 0) return;
+		this._sources.delete(serviceId);
+		await Promise.all([...this._trafficGroups].map((group) => group.remove(serviceId)));
+		await source.watch.cancel("source-removed");
+		await source.watch.done.catch(() => void 0);
+		this._options.onGraph?.(this.getGraph());
+	}
+	getGraph() {
+		return mergeTopologyGraphs([...this._sources.entries()].flatMap(([source, value]) => value.graph === void 0 ? [] : [{
+			source,
+			graph: value.graph
+		}]));
+	}
+	watchTraffic(options, callbacks) {
+		const group = new NetworkTrafficGroup(this._connection, options, callbacks, () => this._trafficGroups.delete(group));
+		this._trafficGroups.add(group);
+		for (const serviceId of this._sources.keys()) group.add(serviceId);
+		return group;
+	}
+	async dispose() {
+		const failures = [];
+		const trafficResults = await Promise.allSettled([...this._trafficGroups].map((group) => group.cancel("disposed")));
+		failures.push(...trafficResults.flatMap((result) => result.status === "rejected" ? [result.reason] : []));
+		const sourceResults = await Promise.allSettled([...this._sources.keys()].map((serviceId) => this.removeTopologyService(serviceId)));
+		failures.push(...sourceResults.flatMap((result) => result.status === "rejected" ? [result.reason] : []));
+		if (failures.length !== 0) throw new AggregateError(failures, "Failed to dispose network inspection");
+	}
+};
+var NetworkTrafficGroup = class {
+	_connection;
+	_options;
+	_callbacks;
+	_onCancel;
+	_watches = /* @__PURE__ */ new Map();
+	_active = true;
+	_resolveDone;
+	done;
+	constructor(_connection, _options, _callbacks, _onCancel) {
+		this._connection = _connection;
+		this._options = _options;
+		this._callbacks = _callbacks;
+		this._onCancel = _onCancel;
+		let resolve;
+		this.done = new Promise((r) => resolve = r);
+		this._resolveDone = resolve;
+	}
+	add(serviceId) {
+		if (!this._active || this._watches.has(serviceId)) return;
+		const client = new TrafficClient(this._connection, serviceId);
+		const callbacks = {
+			onTransit: (transit) => this._callbacks.onTransit(transit, serviceId),
+			onOverflow: (overflow) => this._callbacks.onOverflow?.(overflow, serviceId),
+			onError: (error) => this._callbacks.onError?.(error, serviceId)
+		};
+		const watch = "maxPayloadBytes" in this._options ? client.watchWithPayloads(this._options, callbacks) : client.watch(this._options, callbacks);
+		this._watches.set(serviceId, watch);
+	}
+	async remove(serviceId) {
+		const watch = this._watches.get(serviceId);
+		if (watch === void 0) return;
+		this._watches.delete(serviceId);
+		await watch.cancel("source-removed").catch(() => void 0);
+		await watch.done.catch(() => void 0);
+	}
+	async cancel(reason) {
+		if (!this._active) return this.done;
+		this._active = false;
+		this._onCancel();
+		const watches = [...this._watches.values()];
+		this._watches.clear();
+		const failures = [];
+		try {
+			const results = await Promise.allSettled(watches.map(async (watch) => {
+				await watch.cancel(reason);
+				await watch.done;
+			}));
+			failures.push(...results.flatMap((result) => result.status === "rejected" ? [result.reason] : []));
+		} finally {
+			this._resolveDone();
+		}
+		if (failures.length !== 0) throw new AggregateError(failures, "Failed to cancel network traffic watches");
+	}
+};
+//#endregion
+//#region src/inspection/topologyNetworkClient.ts
+/**
+* Queries or watches a merged topology graph from one, many, or dynamically
+* discovered topology providers. Query mode never registers directory or
+* topology watches; progress snapshots describe its finite request fan-out.
+*/
+var TopologyNetworkClient = class {
+	_connection;
+	constructor(_connection) {
+		this._connection = _connection;
+	}
+	async query(options = {}, callbacks = {}) {
+		const store = new TopologyNetworkStore();
+		const unsubscribe = callbacks.onSnapshot === void 0 ? void 0 : store.subscribe(callbacks.onSnapshot);
+		try {
+			if (options.sourceServiceIds !== void 0) {
+				const serviceIds = uniqueSorted(options.sourceServiceIds);
+				store.reconcileSources(serviceIds);
+				await Promise.all(serviceIds.map((serviceId) => this._querySource(store, serviceId, options.timeoutMs)));
+			} else await this._queryDiscovered(store, options);
+			store.setComplete();
+			return store.snapshot;
+		} finally {
+			unsubscribe?.();
+		}
+	}
+	watch(options = {}) {
+		return new TopologyNetworkWatchImpl(this._connection, options);
+	}
+	async _queryDiscovered(store, options) {
+		const explorer = new HubDirectoryExplorer(this._connection.channel, {
+			interfaceId: topologyInterface.info.id,
+			maxDepth: options.maxDepth,
+			timeoutMs: options.timeoutMs ?? DEFAULT_RPC_TIMEOUT_MS
+		});
+		const queries = /* @__PURE__ */ new Map();
+		const reconcile = (snapshot) => {
+			store.setDirectory(snapshot);
+			const serviceIds = topologyServiceIds(snapshot);
+			store.reconcileSources(serviceIds);
+			for (const serviceId of serviceIds) if (!queries.has(serviceId)) queries.set(serviceId, this._querySource(store, serviceId, options.timeoutMs));
+		};
+		const unsubscribe = explorer.subscribe((event) => reconcile(event.snapshot));
+		try {
+			await explorer.explore();
+			reconcile(explorer.graphSnapshot);
+		} catch (error) {
+			store.setDirectoryError(error);
+		} finally {
+			unsubscribe();
+			explorer.dispose();
+		}
+		await Promise.all(queries.values());
+	}
+	async _querySource(store, serviceId, timeoutMs = DEFAULT_RPC_TIMEOUT_MS) {
+		try {
+			const graph = await new TopologyClient(this._connection, serviceId, timeoutMs).getGraph();
+			if (store.hasSource(serviceId)) store.setSourceGraph(serviceId, graph);
+		} catch (error) {
+			if (store.hasSource(serviceId)) store.setSourceError(serviceId, error);
+		}
+	}
+};
+var TopologyNetworkWatchImpl = class {
+	_connection;
+	_options;
+	_store = new TopologyNetworkStore();
+	_sourceWatches = /* @__PURE__ */ new Map();
+	_initialSourceReady = /* @__PURE__ */ new Map();
+	_explorer;
+	_stopDirectoryWatch;
+	_cancelled = false;
+	_resolveDone;
+	_resolveReady;
+	_readySettled = false;
+	ready = new Promise((resolve) => {
+		this._resolveReady = resolve;
+	});
+	done = new Promise((resolve) => {
+		this._resolveDone = resolve;
+	});
+	constructor(_connection, _options) {
+		this._connection = _connection;
+		this._options = _options;
+		this._explorer = _options.sourceServiceIds === void 0 ? new HubDirectoryExplorer(_connection.channel, {
+			interfaceId: topologyInterface.info.id,
+			maxDepth: _options.maxDepth,
+			timeoutMs: _options.timeoutMs ?? DEFAULT_RPC_TIMEOUT_MS
+		}) : void 0;
+		this._initialize();
+	}
+	get snapshot() {
+		return this._store.snapshot;
+	}
+	subscribe(listener) {
+		return this._store.subscribe(listener);
+	}
+	async cancel(reason = "topology watch cancelled") {
+		if (this._cancelled) return this.done;
+		this._cancelled = true;
+		this._stopDirectoryWatch?.();
+		this._stopDirectoryWatch = void 0;
+		this._explorer?.dispose();
+		const watches = [...this._sourceWatches.values()];
+		this._sourceWatches.clear();
+		await Promise.allSettled(watches.map((watch) => watch.cancel(reason)));
+		if (!this._readySettled) this._settleReady();
+		this._resolveDone();
+	}
+	async _initialize() {
+		try {
+			if (this._options.sourceServiceIds !== void 0) {
+				const serviceIds = uniqueSorted(this._options.sourceServiceIds);
+				this._store.reconcileSources(serviceIds);
+				for (const serviceId of serviceIds) this._startSourceWatch(serviceId);
+			} else {
+				const explorer = this._explorer;
+				explorer.subscribe((event) => this._reconcileDirectory(event.snapshot));
+				this._stopDirectoryWatch = await explorer.watch(() => {});
+				this._reconcileDirectory(explorer.graphSnapshot);
+			}
+			await Promise.allSettled(this._initialSourceReady.values());
+			if (!this._cancelled) {
+				this._store.setComplete();
+				this._settleReady();
+			}
+		} catch (error) {
+			if (!this._cancelled) {
+				this._store.setDirectoryError(error);
+				this._store.setComplete();
+				this._settleReady();
+			}
+		}
+	}
+	_reconcileDirectory(snapshot) {
+		if (this._cancelled) return;
+		this._store.setDirectory(snapshot);
+		const serviceIds = topologyServiceIds(snapshot);
+		const desired = new Set(serviceIds);
+		for (const serviceId of serviceIds) this._startSourceWatch(serviceId);
+		for (const [serviceId, watch] of this._sourceWatches) {
+			if (desired.has(serviceId)) continue;
+			this._sourceWatches.delete(serviceId);
+			this._initialSourceReady.delete(serviceId);
+			this._store.removeSource(serviceId);
+			watch.cancel("topology source removed").catch(() => void 0);
+		}
+	}
+	_startSourceWatch(serviceId) {
+		if (this._sourceWatches.has(serviceId) || this._cancelled) return;
+		this._store.ensureSource(serviceId);
+		const watch = new TopologyClient(this._connection, serviceId, this._options.timeoutMs).watch({
+			onGraph: (graph) => {
+				if (!this._cancelled && this._sourceWatches.get(serviceId) === watch) this._store.setSourceGraph(serviceId, graph);
+			},
+			onError: (error) => {
+				if (!this._cancelled && this._sourceWatches.get(serviceId) === watch) this._store.setSourceError(serviceId, error);
+			}
+		});
+		this._sourceWatches.set(serviceId, watch);
+		const initial = watch.ready.then(() => void 0, (error) => {
+			if (!this._cancelled && this._sourceWatches.get(serviceId) === watch) this._store.setSourceError(serviceId, error);
+		});
+		this._initialSourceReady.set(serviceId, initial);
+		watch.done.catch((error) => {
+			if (!this._cancelled && this._sourceWatches.get(serviceId) === watch) this._store.setSourceError(serviceId, error);
+		});
+	}
+	_settleReady() {
+		if (this._readySettled) return;
+		this._readySettled = true;
+		this._resolveReady(this._store.snapshot);
+	}
+};
+var TopologyNetworkStore = class {
+	_sources = /* @__PURE__ */ new Map();
+	_listeners = /* @__PURE__ */ new Set();
+	_revision = 0;
+	_complete = false;
+	_directory;
+	_directoryError;
+	get snapshot() {
+		const sources = [...this._sources.values()].sort((a, b) => a.serviceId.localeCompare(b.serviceId)).map((source) => ({
+			serviceId: source.serviceId,
+			state: source.state,
+			...source.graph !== void 0 ? { graph: source.graph } : {},
+			...source.error !== void 0 ? { error: source.error } : {}
+		}));
+		return {
+			revision: this._revision,
+			complete: this._complete,
+			...this._directory !== void 0 ? { directory: this._directory } : {},
+			...this._directoryError !== void 0 ? { directoryError: this._directoryError } : {},
+			sources,
+			graph: mergeTopologyGraphs(sources.flatMap((source) => source.graph === void 0 ? [] : [{
+				source: source.serviceId,
+				graph: source.graph
+			}]))
+		};
+	}
+	subscribe(listener) {
+		this._listeners.add(listener);
+		listener(this.snapshot);
+		return () => this._listeners.delete(listener);
+	}
+	hasSource(serviceId) {
+		return this._sources.has(serviceId);
+	}
+	ensureSource(serviceId) {
+		if (this._sources.has(serviceId)) return;
+		this._sources.set(serviceId, {
+			serviceId,
+			state: "loading"
+		});
+		this._emit();
+	}
+	reconcileSources(serviceIds) {
+		const desired = new Set(serviceIds);
+		let changed = false;
+		for (const serviceId of serviceIds) if (!this._sources.has(serviceId)) {
+			this._sources.set(serviceId, {
+				serviceId,
+				state: "loading"
+			});
+			changed = true;
+		}
+		for (const serviceId of this._sources.keys()) if (!desired.has(serviceId)) {
+			this._sources.delete(serviceId);
+			changed = true;
+		}
+		if (changed) this._emit();
+	}
+	removeSource(serviceId) {
+		if (this._sources.delete(serviceId)) this._emit();
+	}
+	setSourceGraph(serviceId, graph) {
+		const source = this._sources.get(serviceId);
+		if (source === void 0) return;
+		source.state = "ready";
+		source.graph = graph;
+		source.error = void 0;
+		this._emit();
+	}
+	setSourceError(serviceId, error) {
+		const source = this._sources.get(serviceId);
+		if (source === void 0) return;
+		source.state = "error";
+		source.error = errorMessage(error);
+		this._emit();
+	}
+	setDirectory(snapshot) {
+		this._directory = snapshot;
+		this._directoryError = void 0;
+		this._emit();
+	}
+	setDirectoryError(error) {
+		this._directoryError = errorMessage(error);
+		this._emit();
+	}
+	setComplete() {
+		if (this._complete) return;
+		this._complete = true;
+		this._emit();
+	}
+	_emit() {
+		this._revision++;
+		const snapshot = this.snapshot;
+		for (const listener of [...this._listeners]) try {
+			listener(snapshot);
+		} catch {}
+	}
+};
+function topologyServiceIds(snapshot) {
+	return uniqueSorted(snapshot.result.listings.filter((listing) => listing.interfaceId === topologyInterface.info.id).map((listing) => listing.serviceId));
+}
+function uniqueSorted(values) {
+	return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+export { NetworkInspectionClient, NodeInfoClient, TopologyClient, TopologyNetworkClient, TrafficClient, mergeTopologyGraphs };
+
+//# sourceMappingURL=index.js.map