@langchain/angular 0.1.3 → 0.3.0

package/dist/index.js

@@ -1,389 +1,127 @@
-import { useStreamCustom } from "./stream.custom.js";
-import { computed, effect, signal } from "@angular/core";
-import { FetchStreamTransport, MessageTupleManager, PendingRunsTracker, StreamError, StreamManager, SubagentManager, calculateDepthFromNamespace, ensureHistoryMessageInstances, ensureMessageInstances, extractInterrupts, extractParentIdFromNamespace, extractToolCallIdFromNamespace, filterStream, getBranchContext, getMessagesMetadataMap, isSubagentNamespace, toMessageClass } from "@langchain/langgraph-sdk/ui";
+import { injectStreamCustom, useStreamCustom } from "./stream.custom.js";
+import { STREAM_DEFAULTS, STREAM_INSTANCE, provideStream, provideStreamDefaults } from "./context.js";
+import { __decorate } from "./_virtual/_@oxc-project_runtime@0.115.0/helpers/decorate.js";
+import { Injectable, computed, effect, inject, signal } from "@angular/core";
+import { FetchStreamTransport, StreamOrchestrator, SubagentManager, calculateDepthFromNamespace, ensureMessageInstances, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace } from "@langchain/langgraph-sdk/ui";
 import { Client } from "@langchain/langgraph-sdk";
-import { getToolCallsWithResults } from "@langchain/langgraph-sdk/utils";
 //#region src/index.ts
-function fetchHistory(client, threadId, options) {
-	if (options?.limit === false) return client.threads.getState(threadId).then((state) => {
-		if (state.checkpoint == null) return [];
-		return [state];
-	});
-	const limit = typeof options?.limit === "number" ? options.limit : 10;
-	return client.threads.getHistory(threadId, { limit });
-}
-function useStream(options) {
-	if ("transport" in options) return useStreamCustom(options);
+/**
+* @internal Merges DI, LangGraph Platform, and custom transport overloads.
+*/
+function injectStream(options) {
+	if (arguments.length === 0) {
+		const instance = inject(STREAM_INSTANCE, { optional: true });
+		if (instance == null) throw new Error("injectStream() requires an ancestor component to provide a stream via provideStream(). Add provideStream({ assistantId: '...' }) to the providers array of a parent component, or use injectStream(options) directly.");
+		return instance;
+	}
+	if ("transport" in options) return injectStreamCustom(options);
 	return useStreamLGP(options);
 }
-function resolveRunMetadataStorage(reconnectOnMount) {
-	if (typeof globalThis.window === "undefined") return null;
-	if (reconnectOnMount === true) return globalThis.window.sessionStorage;
-	if (typeof reconnectOnMount === "function") return reconnectOnMount();
-	return null;
-}
+/**
+* @deprecated Use `injectStream` instead. `useStream` will be removed in a
+* future major version. `injectStream` follows Angular's `inject*` naming
+* convention for injection-based patterns.
+*/
+const useStream = injectStream;
 function useStreamLGP(options) {
-	const runMetadataStorage = resolveRunMetadataStorage(options.reconnectOnMount);
-	const getMessages = (value) => {
-		const messagesKey = options.messagesKey ?? "messages";
-		return Array.isArray(value[messagesKey]) ? value[messagesKey] : [];
-	};
-	const setMessages = (current, messages) => {
-		const messagesKey = options.messagesKey ?? "messages";
-		return {
-			...current,
-			[messagesKey]: messages
-		};
-	};
-	const historyLimit = typeof options.fetchStateHistory === "object" && options.fetchStateHistory != null ? options.fetchStateHistory.limit ?? false : options.fetchStateHistory ?? false;
-	const threadId = signal(void 0);
-	let threadIdPromise = null;
 	const client = options.client ?? new Client({ apiUrl: options.apiUrl });
-	const history = signal({
-		data: void 0,
-		error: void 0,
-		isLoading: false,
-		mutate: async () => void 0
-	});
-	async function mutate(mutateId) {
-		const tid = mutateId ?? threadId();
-		if (!tid) return void 0;
-		try {
-			const data = await fetchHistory(client, tid, { limit: historyLimit });
-			history.set({
-				data,
-				error: void 0,
-				isLoading: false,
-				mutate
-			});
-			return data;
-		} catch (err) {
-			history.update((prev) => ({
-				...prev,
-				error: err,
-				isLoading: false
-			}));
-			options.onError?.(err, void 0);
-			return;
-		}
-	}
-	history.update((prev) => ({
-		...prev,
-		mutate
-	}));
-	const branch = signal("");
-	const branchContext = computed(() => getBranchContext(branch(), history().data ?? void 0));
-	const messageManager = new MessageTupleManager();
-	const stream = new StreamManager(messageManager, {
-		throttle: options.throttle ?? false,
-		subagentToolNames: options.subagentToolNames,
-		filterSubagentMessages: options.filterSubagentMessages,
-		toMessage: toMessageClass
-	});
-	const pendingRuns = new PendingRunsTracker();
-	const queueEntries = signal(pendingRuns.entries);
-	const queueSize = signal(pendingRuns.size);
-	const historyValues = computed(() => branchContext().threadHead?.values ?? options.initialValues ?? {});
-	const historyError = computed(() => {
-		const error = branchContext().threadHead?.tasks?.at(-1)?.error;
-		if (error == null) return void 0;
-		try {
-			const parsed = JSON.parse(error);
-			if (StreamError.isStructuredError(parsed)) return new StreamError(parsed);
-			return parsed;
-		} catch {}
-		return error;
+	const orchestrator = new StreamOrchestrator(options, {
+		getClient: () => client,
+		getAssistantId: () => options.assistantId,
+		getMessagesKey: () => options.messagesKey ?? "messages"
 	});
-	const streamValues = signal(stream.values);
-	const streamError = signal(stream.error);
-	const isLoading = signal(stream.isLoading);
-	const values = computed(() => streamValues() ?? historyValues());
-	const error = computed(() => streamError() ?? historyError() ?? history().error);
-	const messageMetadata = computed(() => getMessagesMetadataMap({
-		initialValues: options.initialValues,
-		history: history().data,
-		getMessages,
-		branchContext: branchContext()
-	}));
+	orchestrator.initThreadId(options.threadId ?? void 0);
+	const version = signal(0);
 	const subagentVersion = signal(0);
 	effect((onCleanup) => {
-		const unsubscribe = stream.subscribe(() => {
-			streamValues.set(stream.values);
-			streamError.set(stream.error);
-			isLoading.set(stream.isLoading);
+		const unsubscribe = orchestrator.subscribe(() => {
+			version.update((v) => v + 1);
 			subagentVersion.update((v) => v + 1);
 		});
 		onCleanup(() => unsubscribe());
 	});
-	pendingRuns.subscribe(() => {
-		queueEntries.set(pendingRuns.entries);
-		queueSize.set(pendingRuns.size);
+	effect((onCleanup) => {
+		version();
+		const hvMessages = orchestrator.messages;
+		if (options.filterSubagentMessages && !orchestrator.isLoading && !orchestrator.historyData.isLoading && hvMessages.length > 0) {
+			const controller = orchestrator.reconstructSubagentsIfNeeded();
+			if (controller) onCleanup(() => controller.abort());
+		}
 	});
-	effect(() => {
-		const hvMessages = getMessages(historyValues());
-		if (options.filterSubagentMessages && !isLoading() && !history().isLoading && hvMessages.length > 0) stream.reconstructSubagents(hvMessages, { skipIfPopulated: true });
+	const isLoadingForDrain = computed(() => {
+		version();
+		return orchestrator.isLoading;
 	});
-	function stop() {
-		return stream.stop(historyValues(), { onStop: (args) => {
-			if (runMetadataStorage && threadId()) {
-				const tid = threadId();
-				const runId = runMetadataStorage.getItem(`lg:stream:${tid}`);
-				if (runId) client.runs.cancel(tid, runId);
-				runMetadataStorage.removeItem(`lg:stream:${tid}`);
-			}
-			options.onStop?.(args);
-		} });
-	}
-	function setBranch(value) {
-		branch.set(value);
-	}
-	function submitDirect(values, submitOptions) {
-		const currentBranchContext = branchContext();
-		const checkpointId = submitOptions?.checkpoint?.checkpoint_id;
-		branch.set(checkpointId != null ? currentBranchContext.branchByCheckpoint[checkpointId]?.branch ?? "" : "");
-		const includeImplicitBranch = historyLimit === true || typeof historyLimit === "number";
-		const shouldRefetch = options.onFinish != null || includeImplicitBranch;
-		let checkpoint = submitOptions?.checkpoint ?? (includeImplicitBranch ? currentBranchContext.threadHead?.checkpoint : void 0) ?? void 0;
-		if (submitOptions?.checkpoint === null) checkpoint = void 0;
-		if (checkpoint != null) delete checkpoint.thread_id;
-		const streamResumable = submitOptions?.streamResumable ?? !!runMetadataStorage;
-		let callbackMeta;
-		let rejoinKey;
-		let usableThreadId;
-		return stream.start(async (signal) => {
-			usableThreadId = threadId();
-			if (!usableThreadId) {
-				const threadPromise = client.threads.create({
-					threadId: submitOptions?.threadId,
-					metadata: submitOptions?.metadata
-				});
-				threadIdPromise = threadPromise.then((t) => t.thread_id);
-				usableThreadId = (await threadPromise).thread_id;
-				threadId.set(usableThreadId);
-				options.onThreadId?.(usableThreadId);
-			}
-			const streamMode = new Set([
-				...submitOptions?.streamMode ?? [],
-				"values",
-				"messages-tuple",
-				"updates"
-			]);
-			if (options.onUpdateEvent) streamMode.add("updates");
-			if (options.onCustomEvent) streamMode.add("custom");
-			if (options.onCheckpointEvent) streamMode.add("checkpoints");
-			if (options.onTaskEvent) streamMode.add("tasks");
-			if ("onDebugEvent" in options && options.onDebugEvent) streamMode.add("debug");
-			if ("onLangChainEvent" in options && options.onLangChainEvent) streamMode.add("events");
-			stream.setStreamValues(() => {
-				const prev = {
-					...historyValues(),
-					...stream.values
-				};
-				if (submitOptions?.optimisticValues != null) return {
-					...prev,
-					...typeof submitOptions.optimisticValues === "function" ? submitOptions.optimisticValues(prev) : submitOptions.optimisticValues
-				};
-				return { ...prev };
-			});
-			return client.runs.stream(usableThreadId, options.assistantId, {
-				input: values,
-				config: submitOptions?.config,
-				context: submitOptions?.context,
-				command: submitOptions?.command,
-				interruptBefore: submitOptions?.interruptBefore,
-				interruptAfter: submitOptions?.interruptAfter,
-				metadata: submitOptions?.metadata,
-				multitaskStrategy: submitOptions?.multitaskStrategy,
-				onCompletion: submitOptions?.onCompletion,
-				onDisconnect: submitOptions?.onDisconnect ?? (streamResumable ? "continue" : "cancel"),
-				signal,
-				checkpoint,
-				streamMode: [...streamMode],
-				streamSubgraphs: submitOptions?.streamSubgraphs,
-				streamResumable,
-				durability: submitOptions?.durability,
-				onRunCreated(params) {
-					callbackMeta = {
-						run_id: params.run_id,
-						thread_id: params.thread_id ?? usableThreadId
-					};
-					if (runMetadataStorage) {
-						rejoinKey = `lg:stream:${usableThreadId}`;
-						runMetadataStorage.setItem(rejoinKey, callbackMeta.run_id);
-					}
-					options.onCreated?.(callbackMeta);
-				}
-			});
-		}, {
-			getMessages,
-			setMessages,
-			initialValues: historyValues(),
-			callbacks: options,
-			async onSuccess() {
-				if (rejoinKey) runMetadataStorage?.removeItem(rejoinKey);
-				if (shouldRefetch && usableThreadId) {
-					const lastHead = (await mutate(usableThreadId))?.at(0);
-					if (lastHead) {
-						options.onFinish?.(lastHead, callbackMeta);
-						return null;
-					}
-				}
-			},
-			onError: (error) => {
-				options.onError?.(error, callbackMeta);
-				submitOptions?.onError?.(error, callbackMeta);
-			},
-			onFinish: () => {}
-		});
-	}
-	let submitting = false;
-	function drainQueue() {
-		if (!isLoading() && !submitting && pendingRuns.size > 0) {
-			const next = pendingRuns.shift();
-			if (next) {
-				submitting = true;
-				joinStream(next.id).finally(() => {
-					submitting = false;
-					drainQueue();
-				});
-			}
-		}
-	}
 	effect(() => {
-		drainQueue();
+		isLoadingForDrain();
+		orchestrator.drainQueue();
 	});
-	async function submit(values, submitOptions) {
-		if (stream.isLoading || submitting) {
-			if (submitOptions?.multitaskStrategy === "interrupt" || submitOptions?.multitaskStrategy === "rollback") {
-				submitting = true;
-				try {
-					await submitDirect(values, submitOptions);
-				} finally {
-					submitting = false;
-				}
-				return;
-			}
-			let usableThreadId = threadId();
-			if (!usableThreadId && threadIdPromise) usableThreadId = await threadIdPromise;
-			if (usableThreadId) {
-				try {
-					const run = await client.runs.create(usableThreadId, options.assistantId, {
-						input: values,
-						config: submitOptions?.config,
-						context: submitOptions?.context,
-						command: submitOptions?.command,
-						interruptBefore: submitOptions?.interruptBefore,
-						interruptAfter: submitOptions?.interruptAfter,
-						metadata: submitOptions?.metadata,
-						multitaskStrategy: "enqueue",
-						streamResumable: true,
-						streamSubgraphs: submitOptions?.streamSubgraphs,
-						durability: submitOptions?.durability
-					});
-					pendingRuns.add({
-						id: run.run_id,
-						values,
-						options: submitOptions,
-						createdAt: new Date(run.created_at)
-					});
-				} catch (error) {
-					options.onError?.(error, void 0);
-					submitOptions?.onError?.(error, void 0);
-				}
-				return;
-			}
-		}
-		submitting = true;
-		const result = submitDirect(values, submitOptions);
-		Promise.resolve(result).finally(() => {
-			submitting = false;
-			drainQueue();
-		});
-		return result;
-	}
-	async function joinStream(runId, lastEventId, joinOptions) {
-		lastEventId ??= "-1";
-		const tid = threadId();
-		if (!tid) return;
-		const callbackMeta = {
-			thread_id: tid,
-			run_id: runId
-		};
-		await stream.start(async (signal) => {
-			const rawStream = client.runs.joinStream(tid, runId, {
-				signal,
-				lastEventId,
-				streamMode: joinOptions?.streamMode
-			});
-			return joinOptions?.filter != null ? filterStream(rawStream, joinOptions.filter) : rawStream;
-		}, {
-			getMessages,
-			setMessages,
-			initialValues: historyValues(),
-			callbacks: options,
-			async onSuccess() {
-				runMetadataStorage?.removeItem(`lg:stream:${tid}`);
-				const lastHead = (await mutate(tid))?.at(0);
-				if (lastHead) options.onFinish?.(lastHead, callbackMeta);
-			},
-			onError(error) {
-				options.onError?.(error, callbackMeta);
-			},
-			onFinish() {}
-		});
-	}
-	const shouldReconnect = !!runMetadataStorage;
+	const { shouldReconnect } = orchestrator;
 	let hasReconnected = false;
 	effect(() => {
-		const tid = threadId();
-		if (!hasReconnected && shouldReconnect && runMetadataStorage && tid && !isLoading()) {
-			const runId = runMetadataStorage.getItem(`lg:stream:${tid}`);
-			if (runId) {
-				hasReconnected = true;
-				joinStream(runId);
-			}
+		version();
+		const tid = orchestrator.threadId;
+		if (!hasReconnected && shouldReconnect && tid && !orchestrator.isLoading) {
+			if (orchestrator.tryReconnect()) hasReconnected = true;
 		}
 	});
-	const messages = computed(() => ensureMessageInstances(getMessages(values())));
-	const toolCalls = computed(() => getToolCallsWithResults(getMessages(values())));
-	function getToolCalls(message) {
-		return getToolCallsWithResults(getMessages(values())).filter((tc) => tc.aiMessage.id === message.id);
-	}
-	const interrupt = computed(() => extractInterrupts(values(), {
-		isLoading: isLoading(),
-		threadState: branchContext().threadHead,
-		error: error()
-	}));
+	const values = computed(() => {
+		version();
+		orchestrator.trackStreamMode("values");
+		return orchestrator.values;
+	});
+	const error = computed(() => {
+		version();
+		return orchestrator.error;
+	});
+	const isLoading = signal(orchestrator.isLoading);
+	effect(() => {
+		version();
+		isLoading.set(orchestrator.isLoading);
+	});
+	const branch = signal("");
+	effect(() => {
+		version();
+		const b = orchestrator.branch;
+		if (branch() !== b) branch.set(b);
+	});
+	const messages = computed(() => {
+		version();
+		orchestrator.trackStreamMode("messages-tuple", "values");
+		return ensureMessageInstances(orchestrator.messages);
+	});
+	const toolCalls = computed(() => {
+		version();
+		orchestrator.trackStreamMode("messages-tuple", "values");
+		return orchestrator.toolCalls;
+	});
+	const interrupt = computed(() => {
+		version();
+		return orchestrator.interrupt;
+	});
 	const interrupts = computed(() => {
-		const vals = values();
-		if (vals != null && "__interrupt__" in vals && Array.isArray(vals.__interrupt__)) {
-			const valueInterrupts = vals.__interrupt__;
-			if (valueInterrupts.length === 0) return [{ when: "breakpoint" }];
-			return valueInterrupts;
-		}
-		if (isLoading()) return [];
-		const allInterrupts = (branchContext().threadHead?.tasks ?? []).flatMap((t) => t.interrupts ?? []);
-		if (allInterrupts.length > 0) return allInterrupts;
-		if (!(branchContext().threadHead?.next ?? []).length || error() != null) return [];
-		return [{ when: "breakpoint" }];
+		version();
+		return orchestrator.interrupts;
 	});
 	const historyList = computed(() => {
-		if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `history`");
-		return ensureHistoryMessageInstances(branchContext().flatHistory, options.messagesKey ?? "messages");
+		version();
+		return orchestrator.flatHistory;
+	});
+	const isThreadLoading = computed(() => {
+		version();
+		return orchestrator.isThreadLoading;
 	});
-	const isThreadLoading = computed(() => history().isLoading && history().data == null);
 	const experimentalBranchTree = computed(() => {
-		if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `experimental_branchTree`");
-		return branchContext().branchTree;
+		version();
+		return orchestrator.experimental_branchTree;
+	});
+	const queueEntries = signal(orchestrator.queueEntries);
+	const queueSize = signal(orchestrator.queueSize);
+	effect(() => {
+		version();
+		queueEntries.set(orchestrator.queueEntries);
+		queueSize.set(orchestrator.queueSize);
 	});
-	function getMessagesMetadata(message, index) {
-		const streamMetadata = messageManager.get(message.id)?.metadata;
-		const historyMetadata = messageMetadata().find((m) => m.messageId === (message.id ?? index));
-		if (streamMetadata != null || historyMetadata != null) return {
-			...historyMetadata,
-			streamMetadata
-		};
-	}
 	return {
 		assistantId: options.assistantId,
 		client,
@@ -391,64 +129,139 @@ function useStreamLGP(options) {
 		error,
 		isLoading,
 		branch,
-		setBranch,
+		setBranch(value) {
+			orchestrator.setBranch(value);
+		},
 		messages,
 		toolCalls,
-		getToolCalls,
+		getToolCalls(message) {
+			return orchestrator.getToolCalls(message);
+		},
 		interrupt,
 		interrupts,
 		history: historyList,
 		isThreadLoading,
 		experimental_branchTree: experimentalBranchTree,
-		getMessagesMetadata,
-		submit,
-		stop,
-		joinStream,
+		getMessagesMetadata(message, index) {
+			return orchestrator.getMessagesMetadata(message, index);
+		},
+		submit: (values, submitOptions) => orchestrator.submit(values, submitOptions),
+		stop: () => orchestrator.stop(),
+		joinStream: (...args) => orchestrator.joinStream(...args),
 		queue: {
 			entries: queueEntries,
 			size: queueSize,
-			async cancel(id) {
-				const tid = threadId();
-				const removed = pendingRuns.remove(id);
-				if (removed && tid) await client.runs.cancel(tid, id);
-				return removed;
-			},
-			async clear() {
-				const tid = threadId();
-				const removed = pendingRuns.removeAll();
-				if (tid && removed.length > 0) await Promise.all(removed.map((e) => client.runs.cancel(tid, e.id)));
-			}
+			cancel: (id) => orchestrator.cancelQueueItem(id),
+			clear: () => orchestrator.clearQueue()
 		},
 		switchThread(newThreadId) {
-			if (newThreadId !== (threadId() ?? null)) {
-				const prevThreadId = threadId();
-				threadId.set(newThreadId ?? void 0);
-				stream.clear();
-				const removed = pendingRuns.removeAll();
-				if (prevThreadId && removed.length > 0) Promise.all(removed.map((e) => client.runs.cancel(prevThreadId, e.id)));
-				if (newThreadId != null) options.onThreadId?.(newThreadId);
-			}
+			orchestrator.switchThread(newThreadId);
 		},
 		get subagents() {
 			subagentVersion();
-			return stream.getSubagents();
+			return orchestrator.subagents;
 		},
 		get activeSubagents() {
 			subagentVersion();
-			return stream.getActiveSubagents();
+			return orchestrator.activeSubagents;
 		},
 		getSubagent(toolCallId) {
-			return stream.getSubagent(toolCallId);
+			return orchestrator.getSubagent(toolCallId);
 		},
 		getSubagentsByType(type) {
-			return stream.getSubagentsByType(type);
+			return orchestrator.getSubagentsByType(type);
 		},
 		getSubagentsByMessage(messageId) {
-			return stream.getSubagentsByMessage(messageId);
+			return orchestrator.getSubagentsByMessage(messageId);
 		}
 	};
 }
+let StreamService = class StreamService {
+	_stream;
+	constructor(options) {
+		this._stream = injectStream(options);
+	}
+	get values() {
+		return this._stream.values;
+	}
+	get messages() {
+		return this._stream.messages;
+	}
+	get isLoading() {
+		return this._stream.isLoading;
+	}
+	get error() {
+		return this._stream.error;
+	}
+	get branch() {
+		return this._stream.branch;
+	}
+	get interrupt() {
+		return this._stream.interrupt;
+	}
+	get interrupts() {
+		return this._stream.interrupts;
+	}
+	get toolCalls() {
+		return this._stream.toolCalls;
+	}
+	get queue() {
+		return this._stream.queue;
+	}
+	get subagents() {
+		return this._stream.subagents;
+	}
+	get activeSubagents() {
+		return this._stream.activeSubagents;
+	}
+	get history() {
+		return this._stream.history;
+	}
+	get isThreadLoading() {
+		return this._stream.isThreadLoading;
+	}
+	get experimental_branchTree() {
+		return this._stream.experimental_branchTree;
+	}
+	get client() {
+		return this._stream.client;
+	}
+	get assistantId() {
+		return this._stream.assistantId;
+	}
+	submit(values, options) {
+		return this._stream.submit(values, options);
+	}
+	async stop() {
+		await this._stream.stop();
+	}
+	setBranch(value) {
+		this._stream.setBranch(value);
+	}
+	switchThread(newThreadId) {
+		this._stream.switchThread(newThreadId);
+	}
+	joinStream(runId, lastEventId, options) {
+		return this._stream.joinStream(runId, lastEventId, options);
+	}
+	getMessagesMetadata(message, index) {
+		return this._stream.getMessagesMetadata(message, index);
+	}
+	getToolCalls(message) {
+		return this._stream.getToolCalls(message);
+	}
+	getSubagent(toolCallId) {
+		return this._stream.getSubagent(toolCallId);
+	}
+	getSubagentsByType(type) {
+		return this._stream.getSubagentsByType(type);
+	}
+	getSubagentsByMessage(messageId) {
+		return this._stream.getSubagentsByMessage(messageId);
+	}
+};
+StreamService = __decorate([Injectable()], StreamService);
 //#endregion
-export { FetchStreamTransport, SubagentManager, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace, useStream, useStreamLGP };
+export { FetchStreamTransport, STREAM_DEFAULTS, STREAM_INSTANCE, StreamService, SubagentManager, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, injectStream, injectStreamCustom, isSubagentNamespace, provideStream, provideStreamDefaults, useStream, useStreamCustom, useStreamLGP };
 
 //# sourceMappingURL=index.js.map