@langchain/langgraph-sdk 1.8.10 → 1.9.1

package/dist/stream/discovery/subagents.js

@@ -0,0 +1,235 @@
+import { StreamStore } from "../store.js";
+import { isConcreteToolNamespace, isRootNamespace, isToolNamespaceSegment, namespaceKey } from "../namespace.js";
+//#region src/stream/discovery/subagents.ts
+var SubagentDiscovery = class {
+	store = new StreamStore(/* @__PURE__ */ new Map());
+	#map = /* @__PURE__ */ new Map();
+	#taskIdByObservedNamespace = /* @__PURE__ */ new Map();
+	#observedOwnNamespaces = /* @__PURE__ */ new Set();
+	/** Feed a single root event. Non-discovery events are ignored. */
+	push(event) {
+		if (event.method === "tools") this.#onToolEvent(event);
+		else if (event.method === "values") this.#onValuesEvent(event);
+	}
+	/** Current snapshot map. */
+	get snapshot() {
+		return this.store.getSnapshot();
+	}
+	discoverFromMessage(message, namespace) {
+		let changed = false;
+		for (const toolCall of getTaskToolCalls(message)) changed = this.#upsertTaskToolCall(toolCall.id, toolCall.input, namespace) || changed;
+		if (changed) this.#commit();
+	}
+	#commit() {
+		this.store.setValue(new Map([...this.#map.values()].map((entry) => [entry.id, toSnapshot(entry)])));
+	}
+	#onToolEvent(event) {
+		const data = event.params.data;
+		const toolCallId = data.tool_call_id;
+		const toolName = data.tool_name;
+		if (data.event === "tool-started" && toolName === "task") {
+			const input = parseTaskInput(data.input);
+			if (toolCallId == null) return;
+			this.#upsertTaskToolCall(toolCallId, input, event.params.namespace);
+			this.#commit();
+			return;
+		}
+		if (toolCallId == null) return;
+		const entry = this.#map.get(toolCallId);
+		if (entry == null) return;
+		if (data.event === "tool-finished") {
+			entry.status = "complete";
+			entry.output = data.output;
+			entry.completedAt = /* @__PURE__ */ new Date();
+			this.#commit();
+			return;
+		}
+		if (data.event === "tool-error") {
+			entry.status = "error";
+			entry.error = data.message ?? "Subagent failed";
+			entry.completedAt = /* @__PURE__ */ new Date();
+			this.#commit();
+		}
+	}
+	#onValuesEvent(event) {
+		const data = event.params.data;
+		if (data == null || typeof data !== "object" || Array.isArray(data)) return;
+		const messages = data.messages;
+		if (!Array.isArray(messages)) return;
+		let changed = this.#recordObservedWorkNamespace(event.params.namespace);
+		for (const message of messages) {
+			for (const toolCall of getTaskToolCalls(message)) changed = this.#upsertTaskToolCall(toolCall.id, toolCall.input, event.params.namespace) || changed;
+			const toolCallId = getToolMessageCallId(message);
+			if (toolCallId == null) continue;
+			const existing = this.#map.get(toolCallId);
+			if (existing == null) continue;
+			existing.status = "complete";
+			existing.output = message;
+			existing.completedAt = /* @__PURE__ */ new Date();
+			changed = true;
+		}
+		if (changed) this.#commit();
+	}
+	#upsertTaskToolCall(toolCallId, input, eventNamespace) {
+		const namespace = taskWorkNamespace(toolCallId, eventNamespace);
+		const existing = this.#map.get(toolCallId);
+		if (existing != null) {
+			let changed = false;
+			this.#recordTaskNamespaceCandidate(toolCallId, eventNamespace);
+			const nextName = input.subagent_type ?? existing.name;
+			const nextTaskInput = input.description ?? existing.taskInput;
+			if (existing.name !== nextName) {
+				existing.name = nextName;
+				changed = true;
+			}
+			if (existing.taskInput !== nextTaskInput) {
+				existing.taskInput = nextTaskInput;
+				changed = true;
+			}
+			const namespaceKeyed = namespaceKey(existing.namespace);
+			const ownNamespaceKey = `tools:${toolCallId}`;
+			const nextNamespaceKey = namespaceKey(namespace);
+			if (isConcreteToolNamespace(eventNamespace) || namespaceKeyed === ownNamespaceKey) {
+				if (namespaceKeyed === ownNamespaceKey && nextNamespaceKey !== ownNamespaceKey && this.#observedOwnNamespaces.has(toolCallId)) return changed;
+				if (namespaceKeyed !== nextNamespaceKey) {
+					existing.namespace = namespace;
+					changed = true;
+				}
+			}
+			if (existing.status !== "complete" && existing.status !== "error") {
+				if (existing.status !== "running") {
+					existing.status = "running";
+					changed = true;
+				}
+			}
+			return changed;
+		}
+		const { parentId, depth } = lineageFromNamespace(eventNamespace);
+		this.#recordTaskNamespaceCandidate(toolCallId, eventNamespace);
+		this.#map.set(toolCallId, {
+			id: toolCallId,
+			name: input.subagent_type ?? "unknown",
+			namespace,
+			parentId,
+			depth,
+			status: "running",
+			taskInput: input.description,
+			output: void 0,
+			error: void 0,
+			startedAt: /* @__PURE__ */ new Date(),
+			completedAt: null
+		});
+		return true;
+	}
+	#recordObservedWorkNamespace(namespace) {
+		if (!isConcreteToolNamespace(namespace)) return false;
+		const last = namespace.at(-1);
+		if (last == null) return false;
+		const namespaceKeyed = namespaceKey(namespace);
+		const toolCallId = this.#taskIdByObservedNamespace.get(namespaceKeyed) ?? last.slice(6);
+		const existing = this.#map.get(toolCallId);
+		if (existing == null) return false;
+		if (namespaceKeyed === `tools:${toolCallId}`) this.#observedOwnNamespaces.add(toolCallId);
+		else if (this.#observedOwnNamespaces.has(toolCallId) || !this.#taskIdByObservedNamespace.has(namespaceKeyed) && !shouldPromoteToObservedNamespace(existing)) return false;
+		if (namespaceKey(existing.namespace) === namespaceKeyed) return false;
+		existing.namespace = [...namespace];
+		return true;
+	}
+	#recordTaskNamespaceCandidate(toolCallId, namespace) {
+		if (!isConcreteToolNamespace(namespace)) return;
+		this.#taskIdByObservedNamespace.set(namespaceKey(namespace), toolCallId);
+	}
+};
+function shouldPromoteToObservedNamespace(entry) {
+	return entry.name === "fanout-worker" || /^Worker worker-\d+/i.test(entry.taskInput ?? "");
+}
+function taskWorkNamespace(toolCallId, eventNamespace) {
+	const last = eventNamespace.at(-1);
+	if (last != null && isToolNamespaceSegment(last)) return [...eventNamespace];
+	return [`tools:${toolCallId}`];
+}
+function toSnapshot(entry) {
+	return {
+		id: entry.id,
+		name: entry.name,
+		namespace: entry.namespace,
+		parentId: entry.parentId,
+		depth: entry.depth,
+		status: entry.status,
+		taskInput: entry.taskInput,
+		output: entry.output,
+		error: entry.error,
+		startedAt: entry.startedAt,
+		completedAt: entry.completedAt
+	};
+}
+function parseTaskInput(raw) {
+	if (raw == null) return {};
+	if (typeof raw === "string") try {
+		const parsed = JSON.parse(raw);
+		return {
+			description: typeof parsed.description === "string" ? parsed.description : void 0,
+			subagent_type: typeof parsed.subagent_type === "string" ? parsed.subagent_type : void 0
+		};
+	} catch {
+		return {};
+	}
+	if (typeof raw === "object" && !Array.isArray(raw)) {
+		const obj = raw;
+		return {
+			description: typeof obj.description === "string" ? obj.description : void 0,
+			subagent_type: typeof obj.subagent_type === "string" ? obj.subagent_type : void 0
+		};
+	}
+	return {};
+}
+function getTaskToolCalls(message) {
+	if (message == null || typeof message !== "object" || Array.isArray(message)) return [];
+	const record = message;
+	const toolCalls = record.tool_calls ?? record.kwargs?.tool_calls ?? record.lc_kwargs?.tool_calls;
+	if (!Array.isArray(toolCalls)) return [];
+	const result = [];
+	for (const toolCall of toolCalls) {
+		if (toolCall == null || typeof toolCall !== "object" || Array.isArray(toolCall)) continue;
+		const record = toolCall;
+		if (typeof record.id !== "string" || record.name !== "task") continue;
+		result.push({
+			id: record.id,
+			input: parseTaskInput(record.args)
+		});
+	}
+	return result;
+}
+function getToolMessageCallId(message) {
+	if (message == null || typeof message !== "object" || Array.isArray(message)) return;
+	const record = message;
+	const id = record.tool_call_id ?? record.kwargs?.tool_call_id ?? record.lc_kwargs?.tool_call_id;
+	return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+/**
+* Derive (parentId, depth) from a namespace like
+* `["subagents:abc:def"]`. Namespaces form a rooted tree; the last
+* `:` segment of the deepest namespace element is the current node's
+* call-id and the one before it is the parent.
+*/
+function lineageFromNamespace(namespace) {
+	if (isRootNamespace(namespace)) return {
+		parentId: null,
+		depth: 1
+	};
+	const last = namespace[namespace.length - 1];
+	if (last == null) return {
+		parentId: null,
+		depth: 1
+	};
+	const trimmed = last.split(":").filter((part) => part.length > 0).slice(1);
+	const depth = Math.max(1, trimmed.length);
+	return {
+		parentId: (trimmed.length >= 2 ? trimmed[trimmed.length - 2] : null) ?? null,
+		depth
+	};
+}
+//#endregion
+export { SubagentDiscovery };
+
+//# sourceMappingURL=subagents.js.map

package/dist/stream/discovery/subagents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagents.js","names":["#onToolEvent","#onValuesEvent","#upsertTaskToolCall","#commit","#map","#recordObservedWorkNamespace","#recordTaskNamespaceCandidate","#observedOwnNamespaces","#taskIdByObservedNamespace"],"sources":["../../../src/stream/discovery/subagents.ts"],"sourcesContent":["/**\n * Root-scoped subagent discovery.\n *\n * Populates a `Map<callId, SubagentDiscoverySnapshot>` by watching\n * `task` tool calls on the root subscription. No content channels\n * (subagent messages, tool calls, extensions) are opened here — that\n * layer is driven by selector hooks via the\n * {@link ChannelRegistry}, keyed on `SubagentDiscoverySnapshot.namespace`.\n *\n * Discovery data this runner populates per subagent:\n *   - id, name, namespace, parentId, depth\n *   - status (`running` | `complete` | `error`)\n *   - taskInput / output / error / startedAt / completedAt\n *\n * The runner is fed events by the {@link StreamController}'s root\n * subscription; it does not open subscriptions of its own.\n */\nimport type { Event, ToolsEvent, ValuesEvent } from \"@langchain/protocol\";\nimport { StreamStore } from \"../store.js\";\nimport type { SubagentDiscoverySnapshot } from \"../types.js\";\nimport {\n  isConcreteToolNamespace,\n  isRootNamespace,\n  isToolNamespaceSegment,\n  namespaceKey,\n} from \"../namespace.js\";\n\nexport type SubagentMap = ReadonlyMap<string, SubagentDiscoverySnapshot>;\n\ninterface MutableSubagent {\n  id: string;\n  name: string;\n  namespace: readonly string[];\n  parentId: string | null;\n  depth: number;\n  status: \"running\" | \"complete\" | \"error\";\n  taskInput: string | undefined;\n  output: unknown;\n  error: string | undefined;\n  startedAt: Date;\n  completedAt: Date | null;\n}\n\nexport class SubagentDiscovery {\n  readonly store = new StreamStore<SubagentMap>(new Map());\n  #map = new Map<string, MutableSubagent>();\n  #taskIdByObservedNamespace = new Map<string, string>();\n  #observedOwnNamespaces = new Set<string>();\n\n  /** Feed a single root event. Non-discovery events are ignored. */\n  push(event: Event): void {\n    if (event.method === \"tools\") {\n      this.#onToolEvent(event as ToolsEvent);\n    } else if (event.method === \"values\") {\n      this.#onValuesEvent(event as ValuesEvent);\n    }\n  }\n\n  /** Current snapshot map. */\n  get snapshot(): SubagentMap {\n    return this.store.getSnapshot();\n  }\n\n  discoverFromMessage(message: unknown, namespace: readonly string[]): void {\n    let changed = false;\n    for (const toolCall of getTaskToolCalls(message)) {\n      changed =\n        this.#upsertTaskToolCall(toolCall.id, toolCall.input, namespace) ||\n        changed;\n    }\n    if (changed) this.#commit();\n  }\n\n  #commit(): void {\n    // Rebuild as a fresh Map so React / useSyncExternalStore sees a\n    // new reference on every change.\n    this.store.setValue(\n      new Map(\n        [...this.#map.values()].map((entry) => [entry.id, toSnapshot(entry)])\n      )\n    );\n  }\n\n  #onToolEvent(event: ToolsEvent): void {\n    const data = event.params.data;\n    const toolCallId = (data as { tool_call_id?: string }).tool_call_id;\n    const toolName = (data as { tool_name?: string }).tool_name;\n\n    if (data.event === \"tool-started\" && toolName === \"task\") {\n      const input = parseTaskInput((data as { input?: unknown }).input);\n      if (toolCallId == null) return;\n      this.#upsertTaskToolCall(toolCallId, input, event.params.namespace);\n      this.#commit();\n      return;\n    }\n\n    if (toolCallId == null) return;\n    const entry = this.#map.get(toolCallId);\n    if (entry == null) return;\n\n    if (data.event === \"tool-finished\") {\n      entry.status = \"complete\";\n      entry.output = (data as { output?: unknown }).output;\n      entry.completedAt = new Date();\n      this.#commit();\n      return;\n    }\n\n    if (data.event === \"tool-error\") {\n      entry.status = \"error\";\n      entry.error = (data as { message?: string }).message ?? \"Subagent failed\";\n      entry.completedAt = new Date();\n      this.#commit();\n    }\n  }\n\n  #onValuesEvent(event: ValuesEvent): void {\n    const data = event.params.data;\n    if (data == null || typeof data !== \"object\" || Array.isArray(data)) return;\n    const messages = (data as { messages?: unknown }).messages;\n    if (!Array.isArray(messages)) return;\n\n    let changed = this.#recordObservedWorkNamespace(event.params.namespace);\n    for (const message of messages) {\n      for (const toolCall of getTaskToolCalls(message)) {\n        changed =\n          this.#upsertTaskToolCall(\n            toolCall.id,\n            toolCall.input,\n            event.params.namespace\n          ) || changed;\n      }\n\n      const toolCallId = getToolMessageCallId(message);\n      if (toolCallId == null) continue;\n      const existing = this.#map.get(toolCallId);\n      if (existing == null) continue;\n      existing.status = \"complete\";\n      existing.output = message;\n      existing.completedAt = new Date();\n      changed = true;\n    }\n    if (changed) this.#commit();\n  }\n\n  #upsertTaskToolCall(\n    toolCallId: string,\n    input: { description?: string; subagent_type?: string },\n    eventNamespace: readonly string[]\n  ): boolean {\n    const namespace = taskWorkNamespace(toolCallId, eventNamespace);\n    const existing = this.#map.get(toolCallId);\n    if (existing != null) {\n      let changed = false;\n      this.#recordTaskNamespaceCandidate(toolCallId, eventNamespace);\n      const nextName = input.subagent_type ?? existing.name;\n      const nextTaskInput = input.description ?? existing.taskInput;\n      if (existing.name !== nextName) {\n        existing.name = nextName;\n        changed = true;\n      }\n      if (existing.taskInput !== nextTaskInput) {\n        existing.taskInput = nextTaskInput;\n        changed = true;\n      }\n      const namespaceKeyed = namespaceKey(existing.namespace);\n      const ownNamespaceKey = `tools:${toolCallId}`;\n      const nextNamespaceKey = namespaceKey(namespace);\n      if (\n        isConcreteToolNamespace(eventNamespace) ||\n        namespaceKeyed === ownNamespaceKey\n      ) {\n        // A wrapper task tool event can arrive under an execution namespace\n        // like `tools:<uuid>`, while the subagent's actual message state is\n        // under `tools:<tool_call_id>`. Once discovery has observed the own\n        // namespace carrying state, do not demote it back to the wrapper\n        // namespace.\n        if (\n          namespaceKeyed === ownNamespaceKey &&\n          nextNamespaceKey !== ownNamespaceKey &&\n          this.#observedOwnNamespaces.has(toolCallId)\n        ) {\n          return changed;\n        }\n        if (namespaceKeyed !== nextNamespaceKey) {\n          existing.namespace = namespace;\n          changed = true;\n        }\n      }\n      if (existing.status !== \"complete\" && existing.status !== \"error\") {\n        if (existing.status !== \"running\") {\n          existing.status = \"running\";\n          changed = true;\n        }\n      }\n      return changed;\n    }\n\n    // Prefer the namespace where the task is first observed. Later\n    // observations may move it between wrapper execution namespaces\n    // and `[\"tools:<toolCallId>\"]`, depending on where the stream proves\n    // the worker's scoped message/tool state exists.\n    const { parentId, depth } = lineageFromNamespace(eventNamespace);\n    this.#recordTaskNamespaceCandidate(toolCallId, eventNamespace);\n    this.#map.set(toolCallId, {\n      id: toolCallId,\n      name: input.subagent_type ?? \"unknown\",\n      namespace,\n      parentId,\n      depth,\n      status: \"running\",\n      taskInput: input.description,\n      output: undefined,\n      error: undefined,\n      startedAt: new Date(),\n      completedAt: null,\n    });\n    return true;\n  }\n\n  #recordObservedWorkNamespace(namespace: readonly string[]): boolean {\n    if (!isConcreteToolNamespace(namespace)) return false;\n    const last = namespace.at(-1);\n    if (last == null) return false;\n    const namespaceKeyed = namespaceKey(namespace);\n    const toolCallId =\n      this.#taskIdByObservedNamespace.get(namespaceKeyed) ??\n      last.slice(\"tools:\".length);\n    const existing = this.#map.get(toolCallId);\n    if (existing == null) return false;\n\n    const ownNamespaceKey = `tools:${toolCallId}`;\n    if (namespaceKeyed === ownNamespaceKey) {\n      this.#observedOwnNamespaces.add(toolCallId);\n    } else if (\n      this.#observedOwnNamespaces.has(toolCallId) ||\n      (!this.#taskIdByObservedNamespace.has(namespaceKeyed) &&\n        !shouldPromoteToObservedNamespace(existing))\n    ) {\n      return false;\n    }\n\n    if (namespaceKey(existing.namespace) === namespaceKeyed) return false;\n    existing.namespace = [...namespace];\n    return true;\n  }\n\n  #recordTaskNamespaceCandidate(\n    toolCallId: string,\n    namespace: readonly string[]\n  ): void {\n    if (!isConcreteToolNamespace(namespace)) return;\n    this.#taskIdByObservedNamespace.set(namespaceKey(namespace), toolCallId);\n  }\n}\n\nfunction shouldPromoteToObservedNamespace(entry: MutableSubagent): boolean {\n  return (\n    entry.name === \"fanout-worker\" ||\n    /^Worker worker-\\d+/i.test(entry.taskInput ?? \"\")\n  );\n}\n\nfunction taskWorkNamespace(\n  toolCallId: string,\n  eventNamespace: readonly string[]\n): readonly string[] {\n  const last = eventNamespace.at(-1);\n  if (last != null && isToolNamespaceSegment(last)) return [...eventNamespace];\n  return [`tools:${toolCallId}`];\n}\n\nfunction toSnapshot(entry: MutableSubagent): SubagentDiscoverySnapshot {\n  return {\n    id: entry.id,\n    name: entry.name,\n    namespace: entry.namespace,\n    parentId: entry.parentId,\n    depth: entry.depth,\n    status: entry.status,\n    taskInput: entry.taskInput,\n    output: entry.output,\n    error: entry.error,\n    startedAt: entry.startedAt,\n    completedAt: entry.completedAt,\n  };\n}\n\nfunction parseTaskInput(raw: unknown): {\n  description?: string;\n  subagent_type?: string;\n} {\n  if (raw == null) return {};\n  if (typeof raw === \"string\") {\n    try {\n      const parsed = JSON.parse(raw) as Record<string, unknown>;\n      return {\n        description:\n          typeof parsed.description === \"string\"\n            ? parsed.description\n            : undefined,\n        subagent_type:\n          typeof parsed.subagent_type === \"string\"\n            ? parsed.subagent_type\n            : undefined,\n      };\n    } catch {\n      return {};\n    }\n  }\n  if (typeof raw === \"object\" && !Array.isArray(raw)) {\n    const obj = raw as Record<string, unknown>;\n    return {\n      description:\n        typeof obj.description === \"string\" ? obj.description : undefined,\n      subagent_type:\n        typeof obj.subagent_type === \"string\" ? obj.subagent_type : undefined,\n    };\n  }\n  return {};\n}\n\nfunction getTaskToolCalls(message: unknown): Array<{\n  id: string;\n  input: { description?: string; subagent_type?: string };\n}> {\n  if (\n    message == null ||\n    typeof message !== \"object\" ||\n    Array.isArray(message)\n  ) {\n    return [];\n  }\n  const record = message as {\n    tool_calls?: unknown;\n    kwargs?: { tool_calls?: unknown };\n    lc_kwargs?: { tool_calls?: unknown };\n  };\n  const toolCalls =\n    record.tool_calls ??\n    record.kwargs?.tool_calls ??\n    record.lc_kwargs?.tool_calls;\n  if (!Array.isArray(toolCalls)) return [];\n\n  const result: Array<{\n    id: string;\n    input: { description?: string; subagent_type?: string };\n  }> = [];\n  for (const toolCall of toolCalls) {\n    if (\n      toolCall == null ||\n      typeof toolCall !== \"object\" ||\n      Array.isArray(toolCall)\n    ) {\n      continue;\n    }\n    const record = toolCall as {\n      id?: unknown;\n      name?: unknown;\n      args?: unknown;\n    };\n    if (typeof record.id !== \"string\" || record.name !== \"task\") continue;\n    result.push({ id: record.id, input: parseTaskInput(record.args) });\n  }\n  return result;\n}\n\nfunction getToolMessageCallId(message: unknown): string | undefined {\n  if (\n    message == null ||\n    typeof message !== \"object\" ||\n    Array.isArray(message)\n  ) {\n    return undefined;\n  }\n  const record = message as {\n    tool_call_id?: unknown;\n    kwargs?: { tool_call_id?: unknown };\n    lc_kwargs?: { tool_call_id?: unknown };\n  };\n  const id =\n    record.tool_call_id ??\n    record.kwargs?.tool_call_id ??\n    record.lc_kwargs?.tool_call_id;\n  return typeof id === \"string\" && id.length > 0 ? id : undefined;\n}\n\n/**\n * Derive (parentId, depth) from a namespace like\n * `[\"subagents:abc:def\"]`. Namespaces form a rooted tree; the last\n * `:` segment of the deepest namespace element is the current node's\n * call-id and the one before it is the parent.\n */\nfunction lineageFromNamespace(namespace: readonly string[]): {\n  parentId: string | null;\n  depth: number;\n} {\n  if (isRootNamespace(namespace)) return { parentId: null, depth: 1 };\n  const last = namespace[namespace.length - 1];\n  if (last == null) return { parentId: null, depth: 1 };\n  // Namespace segments typically look like\n  //   subagents:<parentCallId>:<thisCallId>\n  // but the protocol doesn't mandate that shape; we best-effort.\n  const parts = last.split(\":\").filter((part) => part.length > 0);\n  const trimmed = parts.slice(1); // drop the leading \"subagents\" prefix\n  const depth = Math.max(1, trimmed.length);\n  const parentId = trimmed.length >= 2 ? trimmed[trimmed.length - 2] : null;\n  return { parentId: parentId ?? null, depth };\n}\n"],"mappings":"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"}

package/dist/stream/discovery/subgraphs.cjs

@@ -0,0 +1,153 @@
+const require_store = require("../store.cjs");
+const require_namespace = require("../namespace.cjs");
+//#region src/stream/discovery/subgraphs.ts
+/**
+* LangGraph namespaces a node invocation as `<node_name>:<uuid>`
+* (parallel fan-outs share `<node_name>` as a prefix but each get a
+* fresh uuid). Extract the node-name half so callers can key
+* discovery lookups on names they wrote in `addNode(...)`.
+*/
+function parseNodeName(segment) {
+	const colon = segment.indexOf(":");
+	return colon === -1 ? segment : segment.slice(0, colon);
+}
+var SubgraphDiscovery = class {
+	store = new require_store.StreamStore(/* @__PURE__ */ new Map());
+	byNodeStore = new require_store.StreamStore(/* @__PURE__ */ new Map());
+	/**
+	* Latest known status for every namespaced lifecycle event we have
+	* ever observed. A shadow entry is NOT necessarily a subgraph —
+	* it is only projected into the committed stores once the same
+	* namespace also appears in {@link #promoted}.
+	*/
+	#shadow = /* @__PURE__ */ new Map();
+	/**
+	* Namespaces that have been observed as a strict prefix of a
+	* deeper namespace and are therefore confirmed subgraph hosts.
+	* Insertion order is preserved and becomes the iteration order
+	* of the committed snapshot maps.
+	*/
+	#promoted = /* @__PURE__ */ new Set();
+	/** Feed a single root event. Non-discovery events are ignored. */
+	push(event) {
+		if (event.method === "values") {
+			this.#onValuesEvent(event);
+			return;
+		}
+		if (event.method !== "lifecycle") return;
+		const lifecycle = event;
+		const namespace = lifecycle.params.namespace;
+		if (require_namespace.isRootNamespace(namespace)) return;
+		const id = require_namespace.namespaceKey(namespace);
+		const data = lifecycle.params.data;
+		const nodeName = parseNodeName(namespace[namespace.length - 1] ?? "");
+		let touched = false;
+		for (let depth = 1; depth < namespace.length; depth += 1) {
+			const ancestorId = require_namespace.namespaceKey(namespace.slice(0, depth));
+			if (!this.#promoted.has(ancestorId)) {
+				this.#promoted.add(ancestorId);
+				if (this.#shadow.has(ancestorId)) touched = true;
+			}
+		}
+		if (data.event === "started") {
+			if (!this.#shadow.has(id)) {
+				this.#shadow.set(id, {
+					id,
+					namespace: [...namespace],
+					nodeName,
+					status: "running",
+					startedAt: /* @__PURE__ */ new Date(),
+					completedAt: null
+				});
+				if (this.#promoted.has(id)) touched = true;
+			}
+		} else if (data.event === "completed" || data.event === "interrupted" || data.event === "failed") {
+			const entry = this.#ensureShadow(id, namespace, nodeName);
+			if (data.event === "failed") entry.status = "error";
+			else entry.status = "complete";
+			entry.completedAt = /* @__PURE__ */ new Date();
+			if (this.#promoted.has(id)) touched = true;
+		}
+		if (touched) this.#commit();
+	}
+	/**
+	* Promote subgraph host namespaces from namespaced `values` snapshots.
+	*
+	* Older protocol streams exposed subgraph structure primarily through
+	* nested `lifecycle` events: a host namespace such as
+	* `["research:<uuid>"]` was promoted once a deeper namespace like
+	* `["research:<uuid>", "inner:<uuid>"]` appeared. Some runtimes now
+	* emit the useful subgraph signal as `values` snapshots scoped directly
+	* to the host namespace instead, without forwarding inner lifecycle
+	* events to the client. In that shape, the namespace on the `values`
+	* event is already the selector target that `useMessages(stream,
+	* subgraph)` should subscribe to, so we create/promote the shadow
+	* subgraph entry from that namespace.
+	*
+	* Root `values` events are ignored because they represent the parent
+	* thread state, not a subgraph. Tool/subagent namespaces are also
+	* ignored because deep-agent task tools emit their own namespaced
+	* `values` snapshots under `tools:*` / `task:*`; those are discovered
+	* by `SubagentDiscovery` and must not be duplicated as subgraphs.
+	*
+	* A `values` event does not carry lifecycle terminal status, so the
+	* entry remains marked `running` until a matching lifecycle terminal
+	* event arrives. If no terminal arrives, the discovery map still
+	* contains the host namespace, which is the important invariant for
+	* scoped selectors.
+	*/
+	#onValuesEvent(event) {
+		const namespace = event.params.namespace;
+		if (require_namespace.isRootNamespace(namespace)) return;
+		if (require_namespace.isInternalWorkNamespace(namespace)) return;
+		const data = event.params.data;
+		if (data == null || typeof data !== "object" || Array.isArray(data)) return;
+		const id = require_namespace.namespaceKey(namespace);
+		const nodeName = parseNodeName(namespace[namespace.length - 1] ?? "");
+		const entry = this.#ensureShadow(id, namespace, nodeName);
+		entry.status = "running";
+		if (!this.#promoted.has(id)) this.#promoted.add(id);
+		this.#commit();
+	}
+	get snapshot() {
+		return this.store.getSnapshot();
+	}
+	get byNodeSnapshot() {
+		return this.byNodeStore.getSnapshot();
+	}
+	#ensureShadow(id, namespace, nodeName) {
+		let entry = this.#shadow.get(id);
+		if (entry == null) {
+			entry = {
+				id,
+				namespace: [...namespace],
+				nodeName,
+				status: "running",
+				startedAt: /* @__PURE__ */ new Date(),
+				completedAt: null
+			};
+			this.#shadow.set(id, entry);
+		}
+		return entry;
+	}
+	#commit() {
+		const snapshots = [];
+		for (const id of this.#promoted) {
+			const entry = this.#shadow.get(id);
+			if (entry == null) continue;
+			snapshots.push({ ...entry });
+		}
+		this.store.setValue(new Map(snapshots.map((s) => [s.id, s])));
+		const byNode = /* @__PURE__ */ new Map();
+		for (const snap of snapshots) {
+			const bucket = byNode.get(snap.nodeName);
+			if (bucket == null) byNode.set(snap.nodeName, [snap]);
+			else bucket.push(snap);
+		}
+		this.byNodeStore.setValue(byNode);
+	}
+};
+//#endregion
+exports.SubgraphDiscovery = SubgraphDiscovery;
+
+//# sourceMappingURL=subgraphs.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subgraphs.cjs","names":["StreamStore","#onValuesEvent","isRootNamespace","namespaceKey","#promoted","#shadow","#ensureShadow","#commit","isInternalWorkNamespace"],"sources":["../../../src/stream/discovery/subgraphs.ts"],"sourcesContent":["/**\n * Root-scoped subgraph discovery.\n *\n * Watches namespaced `lifecycle` events on the root subscription and\n * assembles two views of the subgraph set:\n *\n *  - {@link SubgraphMap}: `Map<namespaceKey, SubgraphDiscoverySnapshot>`,\n *    the canonical identity-keyed view consumed by the channel\n *    registry and selector hooks.\n *  - {@link SubgraphByNodeMap}: `Map<nodeName, readonly\n *    SubgraphDiscoverySnapshot[]>`, a convenience index so callers\n *    can look up subgraphs by the graph node that produced them\n *    (`addNode(\"visualizer_0\", …)`) without parsing namespaces.\n *    Arrays preserve insertion order, which matters for parallel\n *    fan-outs that share a node name.\n *\n * # What counts as a subgraph\n *\n * The server emits a namespaced `lifecycle` event for every node\n * invocation — a plain function node (`orchestrator`) and a subgraph\n * host (`research`) look identical on the wire. We classify a\n * namespace as a subgraph iff at least one strictly-deeper namespace\n * has been observed with it as a prefix. Concretely, given a stream\n * whose lifecycle events hit the namespaces\n *\n *   `[\"orchestrator:u1\"]`\n *   `[\"research:u2\"]`\n *   `[\"research:u2\", \"researcher:u3\"]`\n *   `[\"research:u2\", \"tools:u4\"]`\n *   `[\"writer:u5\"]`\n *\n * only `[\"research:u2\"]` is promoted — it's the only namespace that\n * hosts deeper executions. `orchestrator` and `writer` are plain\n * function-node leaves; the `researcher` / `tools` entries are the\n * subgraph's internal nodes, not subgraphs in their own right.\n *\n * Promotion is monotonic (a namespace never loses subgraph status)\n * and retroactive: a namespace whose own `started` event arrived\n * before any descendant is promoted later when the first descendant\n * event lands. Latency is bounded by the gap between a parent node\n * entering and its first inner node materializing — typically tens\n * of milliseconds.\n */\nimport type { Event, LifecycleEvent, ValuesEvent } from \"@langchain/protocol\";\nimport { StreamStore } from \"../store.js\";\nimport type { SubgraphDiscoverySnapshot } from \"../types.js\";\nimport {\n  isInternalWorkNamespace,\n  isRootNamespace,\n  namespaceKey,\n} from \"../namespace.js\";\n\nexport type SubgraphMap = ReadonlyMap<string, SubgraphDiscoverySnapshot>;\nexport type SubgraphByNodeMap = ReadonlyMap<\n  string,\n  readonly SubgraphDiscoverySnapshot[]\n>;\n\ninterface MutableSubgraph {\n  id: string;\n  namespace: readonly string[];\n  nodeName: string;\n  status: \"running\" | \"complete\" | \"error\";\n  startedAt: Date;\n  completedAt: Date | null;\n}\n\n/**\n * LangGraph namespaces a node invocation as `<node_name>:<uuid>`\n * (parallel fan-outs share `<node_name>` as a prefix but each get a\n * fresh uuid). Extract the node-name half so callers can key\n * discovery lookups on names they wrote in `addNode(...)`.\n */\nfunction parseNodeName(segment: string): string {\n  const colon = segment.indexOf(\":\");\n  return colon === -1 ? segment : segment.slice(0, colon);\n}\n\nexport class SubgraphDiscovery {\n  readonly store = new StreamStore<SubgraphMap>(new Map());\n  readonly byNodeStore = new StreamStore<SubgraphByNodeMap>(new Map());\n\n  /**\n   * Latest known status for every namespaced lifecycle event we have\n   * ever observed. A shadow entry is NOT necessarily a subgraph —\n   * it is only projected into the committed stores once the same\n   * namespace also appears in {@link #promoted}.\n   */\n  #shadow = new Map<string, MutableSubgraph>();\n\n  /**\n   * Namespaces that have been observed as a strict prefix of a\n   * deeper namespace and are therefore confirmed subgraph hosts.\n   * Insertion order is preserved and becomes the iteration order\n   * of the committed snapshot maps.\n   */\n  #promoted = new Set<string>();\n\n  /** Feed a single root event. Non-discovery events are ignored. */\n  push(event: Event): void {\n    if (event.method === \"values\") {\n      this.#onValuesEvent(event as ValuesEvent);\n      return;\n    }\n    if (event.method !== \"lifecycle\") return;\n    const lifecycle = event as LifecycleEvent;\n    const namespace = lifecycle.params.namespace;\n    // Root lifecycle events describe the main run; subgraph discovery\n    // only cares about namespaced lifecycle events.\n    if (isRootNamespace(namespace)) return;\n    const id = namespaceKey(namespace);\n    const data = lifecycle.params.data as { event?: string };\n    const lastSegment = namespace[namespace.length - 1] ?? \"\";\n    const nodeName = parseNodeName(lastSegment);\n\n    let touched = false;\n\n    // Promote every strict ancestor the first time we see it as a\n    // prefix. The ancestor may or may not yet have a shadow entry;\n    // #commit() tolerates either case.\n    for (let depth = 1; depth < namespace.length; depth += 1) {\n      const ancestorId = namespaceKey(namespace.slice(0, depth));\n      if (!this.#promoted.has(ancestorId)) {\n        this.#promoted.add(ancestorId);\n        if (this.#shadow.has(ancestorId)) touched = true;\n      }\n    }\n\n    // Update shadow status for this namespace itself.\n    if (data.event === \"started\") {\n      if (!this.#shadow.has(id)) {\n        this.#shadow.set(id, {\n          id,\n          namespace: [...namespace],\n          nodeName,\n          status: \"running\",\n          startedAt: new Date(),\n          completedAt: null,\n        });\n        if (this.#promoted.has(id)) touched = true;\n      }\n    } else if (\n      data.event === \"completed\" ||\n      data.event === \"interrupted\" ||\n      data.event === \"failed\"\n    ) {\n      // Synthesize a shadow entry if we missed the `started` event\n      // (common when a late subscription attaches to a running run).\n      const entry = this.#ensureShadow(id, namespace, nodeName);\n      if (data.event === \"failed\") {\n        entry.status = \"error\";\n      } else {\n        entry.status = \"complete\";\n      }\n      entry.completedAt = new Date();\n      if (this.#promoted.has(id)) touched = true;\n    }\n\n    if (touched) this.#commit();\n  }\n\n  /**\n   * Promote subgraph host namespaces from namespaced `values` snapshots.\n   *\n   * Older protocol streams exposed subgraph structure primarily through\n   * nested `lifecycle` events: a host namespace such as\n   * `[\"research:<uuid>\"]` was promoted once a deeper namespace like\n   * `[\"research:<uuid>\", \"inner:<uuid>\"]` appeared. Some runtimes now\n   * emit the useful subgraph signal as `values` snapshots scoped directly\n   * to the host namespace instead, without forwarding inner lifecycle\n   * events to the client. In that shape, the namespace on the `values`\n   * event is already the selector target that `useMessages(stream,\n   * subgraph)` should subscribe to, so we create/promote the shadow\n   * subgraph entry from that namespace.\n   *\n   * Root `values` events are ignored because they represent the parent\n   * thread state, not a subgraph. Tool/subagent namespaces are also\n   * ignored because deep-agent task tools emit their own namespaced\n   * `values` snapshots under `tools:*` / `task:*`; those are discovered\n   * by `SubagentDiscovery` and must not be duplicated as subgraphs.\n   *\n   * A `values` event does not carry lifecycle terminal status, so the\n   * entry remains marked `running` until a matching lifecycle terminal\n   * event arrives. If no terminal arrives, the discovery map still\n   * contains the host namespace, which is the important invariant for\n   * scoped selectors.\n   */\n  #onValuesEvent(event: ValuesEvent): void {\n    const namespace = event.params.namespace;\n    if (isRootNamespace(namespace)) return;\n    if (isInternalWorkNamespace(namespace)) return;\n    const data = event.params.data;\n    if (data == null || typeof data !== \"object\" || Array.isArray(data)) return;\n\n    const id = namespaceKey(namespace);\n    const lastSegment = namespace[namespace.length - 1] ?? \"\";\n    const nodeName = parseNodeName(lastSegment);\n    const entry = this.#ensureShadow(id, namespace, nodeName);\n    entry.status = \"running\";\n\n    if (!this.#promoted.has(id)) {\n      this.#promoted.add(id);\n    }\n    this.#commit();\n  }\n\n  get snapshot(): SubgraphMap {\n    return this.store.getSnapshot();\n  }\n\n  get byNodeSnapshot(): SubgraphByNodeMap {\n    return this.byNodeStore.getSnapshot();\n  }\n\n  #ensureShadow(\n    id: string,\n    namespace: readonly string[],\n    nodeName: string\n  ): MutableSubgraph {\n    let entry = this.#shadow.get(id);\n    if (entry == null) {\n      entry = {\n        id,\n        namespace: [...namespace],\n        nodeName,\n        status: \"running\",\n        startedAt: new Date(),\n        completedAt: null,\n      };\n      this.#shadow.set(id, entry);\n    }\n    return entry;\n  }\n\n  #commit(): void {\n    const snapshots: SubgraphDiscoverySnapshot[] = [];\n    for (const id of this.#promoted) {\n      const entry = this.#shadow.get(id);\n      // A namespace can be promoted before its own lifecycle event\n      // arrives if descendant events outpace the prefix event. Skip\n      // until the shadow entry lands; the next push() promoting or\n      // updating this namespace will re-commit.\n      if (entry == null) continue;\n      snapshots.push({ ...entry });\n    }\n\n    this.store.setValue(new Map(snapshots.map((s) => [s.id, s])));\n\n    const byNode = new Map<string, SubgraphDiscoverySnapshot[]>();\n    for (const snap of snapshots) {\n      const bucket = byNode.get(snap.nodeName);\n      if (bucket == null) byNode.set(snap.nodeName, [snap]);\n      else bucket.push(snap);\n    }\n    this.byNodeStore.setValue(byNode);\n  }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,19 @@
+import { StreamStore } from "../store.cjs";
+import { SubgraphDiscoverySnapshot } from "../types.cjs";
+import { Event } from "@langchain/protocol";
+
+//#region src/stream/discovery/subgraphs.d.ts
+type SubgraphMap = ReadonlyMap<string, SubgraphDiscoverySnapshot>;
+type SubgraphByNodeMap = ReadonlyMap<string, readonly SubgraphDiscoverySnapshot[]>;
+declare class SubgraphDiscovery {
+  #private;
+  readonly store: StreamStore<SubgraphMap>;
+  readonly byNodeStore: StreamStore<SubgraphByNodeMap>;
+  /** Feed a single root event. Non-discovery events are ignored. */
+  push(event: Event): void;
+  get snapshot(): SubgraphMap;
+  get byNodeSnapshot(): SubgraphByNodeMap;
+}
+//#endregion
+export { SubgraphByNodeMap, SubgraphDiscovery, SubgraphMap };
+//# sourceMappingURL=subgraphs.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subgraphs.d.cts","names":[],"sources":["../../../src/stream/discovery/subgraphs.ts"],"mappings":";;;;;KAoDY,WAAA,GAAc,WAAA,SAAoB,yBAAA;AAAA,KAClC,iBAAA,GAAoB,WAAA,kBAErB,yBAAA;AAAA,cAuBE,iBAAA;EAAA;WACF,KAAA,EAAK,WAAA,CAAA,WAAA;EAAA,SACL,WAAA,EAAW,WAAA,CAAA,iBAAA;;EAmBpB,IAAA,CAAK,KAAA,EAAO,KAAA;EAAA,IA2GR,QAAA,CAAA,GAAY,WAAA;EAAA,IAIZ,cAAA,CAAA,GAAkB,iBAAA;AAAA"}

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

@@ -0,0 +1,19 @@
+import { StreamStore } from "../store.js";
+import { SubgraphDiscoverySnapshot } from "../types.js";
+import { Event } from "@langchain/protocol";
+
+//#region src/stream/discovery/subgraphs.d.ts
+type SubgraphMap = ReadonlyMap<string, SubgraphDiscoverySnapshot>;
+type SubgraphByNodeMap = ReadonlyMap<string, readonly SubgraphDiscoverySnapshot[]>;
+declare class SubgraphDiscovery {
+  #private;
+  readonly store: StreamStore<SubgraphMap>;
+  readonly byNodeStore: StreamStore<SubgraphByNodeMap>;
+  /** Feed a single root event. Non-discovery events are ignored. */
+  push(event: Event): void;
+  get snapshot(): SubgraphMap;
+  get byNodeSnapshot(): SubgraphByNodeMap;
+}
+//#endregion
+export { SubgraphByNodeMap, SubgraphDiscovery, SubgraphMap };
+//# sourceMappingURL=subgraphs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subgraphs.d.ts","names":[],"sources":["../../../src/stream/discovery/subgraphs.ts"],"mappings":";;;;;KAoDY,WAAA,GAAc,WAAA,SAAoB,yBAAA;AAAA,KAClC,iBAAA,GAAoB,WAAA,kBAErB,yBAAA;AAAA,cAuBE,iBAAA;EAAA;WACF,KAAA,EAAK,WAAA,CAAA,WAAA;EAAA,SACL,WAAA,EAAW,WAAA,CAAA,iBAAA;;EAmBpB,IAAA,CAAK,KAAA,EAAO,KAAA;EAAA,IA2GR,QAAA,CAAA,GAAY,WAAA;EAAA,IAIZ,cAAA,CAAA,GAAkB,iBAAA;AAAA"}

package/dist/stream/discovery/subgraphs.js

@@ -0,0 +1,153 @@
+import { StreamStore } from "../store.js";
+import { isInternalWorkNamespace, isRootNamespace, namespaceKey } from "../namespace.js";
+//#region src/stream/discovery/subgraphs.ts
+/**
+* LangGraph namespaces a node invocation as `<node_name>:<uuid>`
+* (parallel fan-outs share `<node_name>` as a prefix but each get a
+* fresh uuid). Extract the node-name half so callers can key
+* discovery lookups on names they wrote in `addNode(...)`.
+*/
+function parseNodeName(segment) {
+	const colon = segment.indexOf(":");
+	return colon === -1 ? segment : segment.slice(0, colon);
+}
+var SubgraphDiscovery = class {
+	store = new StreamStore(/* @__PURE__ */ new Map());
+	byNodeStore = new StreamStore(/* @__PURE__ */ new Map());
+	/**
+	* Latest known status for every namespaced lifecycle event we have
+	* ever observed. A shadow entry is NOT necessarily a subgraph —
+	* it is only projected into the committed stores once the same
+	* namespace also appears in {@link #promoted}.
+	*/
+	#shadow = /* @__PURE__ */ new Map();
+	/**
+	* Namespaces that have been observed as a strict prefix of a
+	* deeper namespace and are therefore confirmed subgraph hosts.
+	* Insertion order is preserved and becomes the iteration order
+	* of the committed snapshot maps.
+	*/
+	#promoted = /* @__PURE__ */ new Set();
+	/** Feed a single root event. Non-discovery events are ignored. */
+	push(event) {
+		if (event.method === "values") {
+			this.#onValuesEvent(event);
+			return;
+		}
+		if (event.method !== "lifecycle") return;
+		const lifecycle = event;
+		const namespace = lifecycle.params.namespace;
+		if (isRootNamespace(namespace)) return;
+		const id = namespaceKey(namespace);
+		const data = lifecycle.params.data;
+		const nodeName = parseNodeName(namespace[namespace.length - 1] ?? "");
+		let touched = false;
+		for (let depth = 1; depth < namespace.length; depth += 1) {
+			const ancestorId = namespaceKey(namespace.slice(0, depth));
+			if (!this.#promoted.has(ancestorId)) {
+				this.#promoted.add(ancestorId);
+				if (this.#shadow.has(ancestorId)) touched = true;
+			}
+		}
+		if (data.event === "started") {
+			if (!this.#shadow.has(id)) {
+				this.#shadow.set(id, {
+					id,
+					namespace: [...namespace],
+					nodeName,
+					status: "running",
+					startedAt: /* @__PURE__ */ new Date(),
+					completedAt: null
+				});
+				if (this.#promoted.has(id)) touched = true;
+			}
+		} else if (data.event === "completed" || data.event === "interrupted" || data.event === "failed") {
+			const entry = this.#ensureShadow(id, namespace, nodeName);
+			if (data.event === "failed") entry.status = "error";
+			else entry.status = "complete";
+			entry.completedAt = /* @__PURE__ */ new Date();
+			if (this.#promoted.has(id)) touched = true;
+		}
+		if (touched) this.#commit();
+	}
+	/**
+	* Promote subgraph host namespaces from namespaced `values` snapshots.
+	*
+	* Older protocol streams exposed subgraph structure primarily through
+	* nested `lifecycle` events: a host namespace such as
+	* `["research:<uuid>"]` was promoted once a deeper namespace like
+	* `["research:<uuid>", "inner:<uuid>"]` appeared. Some runtimes now
+	* emit the useful subgraph signal as `values` snapshots scoped directly
+	* to the host namespace instead, without forwarding inner lifecycle
+	* events to the client. In that shape, the namespace on the `values`
+	* event is already the selector target that `useMessages(stream,
+	* subgraph)` should subscribe to, so we create/promote the shadow
+	* subgraph entry from that namespace.
+	*
+	* Root `values` events are ignored because they represent the parent
+	* thread state, not a subgraph. Tool/subagent namespaces are also
+	* ignored because deep-agent task tools emit their own namespaced
+	* `values` snapshots under `tools:*` / `task:*`; those are discovered
+	* by `SubagentDiscovery` and must not be duplicated as subgraphs.
+	*
+	* A `values` event does not carry lifecycle terminal status, so the
+	* entry remains marked `running` until a matching lifecycle terminal
+	* event arrives. If no terminal arrives, the discovery map still
+	* contains the host namespace, which is the important invariant for
+	* scoped selectors.
+	*/
+	#onValuesEvent(event) {
+		const namespace = event.params.namespace;
+		if (isRootNamespace(namespace)) return;
+		if (isInternalWorkNamespace(namespace)) return;
+		const data = event.params.data;
+		if (data == null || typeof data !== "object" || Array.isArray(data)) return;
+		const id = namespaceKey(namespace);
+		const nodeName = parseNodeName(namespace[namespace.length - 1] ?? "");
+		const entry = this.#ensureShadow(id, namespace, nodeName);
+		entry.status = "running";
+		if (!this.#promoted.has(id)) this.#promoted.add(id);
+		this.#commit();
+	}
+	get snapshot() {
+		return this.store.getSnapshot();
+	}
+	get byNodeSnapshot() {
+		return this.byNodeStore.getSnapshot();
+	}
+	#ensureShadow(id, namespace, nodeName) {
+		let entry = this.#shadow.get(id);
+		if (entry == null) {
+			entry = {
+				id,
+				namespace: [...namespace],
+				nodeName,
+				status: "running",
+				startedAt: /* @__PURE__ */ new Date(),
+				completedAt: null
+			};
+			this.#shadow.set(id, entry);
+		}
+		return entry;
+	}
+	#commit() {
+		const snapshots = [];
+		for (const id of this.#promoted) {
+			const entry = this.#shadow.get(id);
+			if (entry == null) continue;
+			snapshots.push({ ...entry });
+		}
+		this.store.setValue(new Map(snapshots.map((s) => [s.id, s])));
+		const byNode = /* @__PURE__ */ new Map();
+		for (const snap of snapshots) {
+			const bucket = byNode.get(snap.nodeName);
+			if (bucket == null) byNode.set(snap.nodeName, [snap]);
+			else bucket.push(snap);
+		}
+		this.byNodeStore.setValue(byNode);
+	}
+};
+//#endregion
+export { SubgraphDiscovery };
+
+//# sourceMappingURL=subgraphs.js.map