@langchain/angular 0.4.7 → 1.0.0

package/dist/selectors-queue.cjs

@@ -0,0 +1,21 @@
+const require_use_stream = require("./use-stream.cjs");
+let _angular_core = require("@angular/core");
+//#region src/selectors-queue.ts
+function injectSubmissionQueue(stream) {
+	const destroyRef = (0, _angular_core.inject)(_angular_core.DestroyRef);
+	const controller = stream[require_use_stream.STREAM_CONTROLLER];
+	const store = controller.queueStore;
+	const entriesSignal = (0, _angular_core.signal)(store.getSnapshot());
+	const unsubscribe = store.subscribe(() => entriesSignal.set(store.getSnapshot()));
+	destroyRef.onDestroy(unsubscribe);
+	return {
+		entries: (0, _angular_core.computed)(() => entriesSignal()),
+		size: (0, _angular_core.computed)(() => entriesSignal().length),
+		cancel: (id) => controller.cancelQueued(id),
+		clear: () => controller.clearQueue()
+	};
+}
+//#endregion
+exports.injectSubmissionQueue = injectSubmissionQueue;
+
+//# sourceMappingURL=selectors-queue.cjs.map

package/dist/selectors-queue.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors-queue.cjs","names":["DestroyRef","STREAM_CONTROLLER"],"sources":["../src/selectors-queue.ts"],"sourcesContent":["import {\n  DestroyRef,\n  computed,\n  inject,\n  signal,\n  type Signal,\n} from \"@angular/core\";\nimport type {\n  SubmissionQueueEntry,\n  SubmissionQueueSnapshot,\n} from \"@langchain/langgraph-sdk/stream\";\nimport {\n  STREAM_CONTROLLER,\n  type AnyStream,\n  type UseStreamReturn,\n} from \"./use-stream.js\";\n\n/**\n * Reactive handle on the server-side submission queue.\n *\n * Populated when `submit()` is invoked with\n * `multitaskStrategy: \"enqueue\"` while another run is in flight. The\n * returned `entries` signal is stable per snapshot so consumers can\n * feed it straight into Angular `@for` loops:\n *\n * ```html\n * @for (entry of queue.entries(); track entry.id) {\n *   <div>{{ entry.values | json }}</div>\n * }\n * ```\n *\n * Today the queue is maintained client-side; once the server starts\n * emitting a dedicated queue channel (roadmap A0.3) the controller\n * will mirror that state directly — the selector surface will not\n * change.\n */\nexport interface InjectSubmissionQueueReturn<\n  StateType extends object = Record<string, unknown>,\n> {\n  readonly entries: Signal<SubmissionQueueSnapshot<StateType>>;\n  readonly size: Signal<number>;\n  cancel(id: string): Promise<boolean>;\n  clear(): Promise<void>;\n}\n\ntype StreamHandle<StateType extends object> = UseStreamReturn<\n  StateType,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any\n>;\n\nexport function injectSubmissionQueue<StateType extends object>(\n  stream: StreamHandle<StateType>\n): InjectSubmissionQueueReturn<StateType>;\nexport function injectSubmissionQueue(\n  stream: AnyStream\n): InjectSubmissionQueueReturn;\nexport function injectSubmissionQueue(\n  stream: AnyStream\n): InjectSubmissionQueueReturn {\n  const destroyRef = inject(DestroyRef);\n  const controller = stream[STREAM_CONTROLLER];\n  const store = controller.queueStore;\n\n  const entriesSignal = signal<SubmissionQueueSnapshot>(store.getSnapshot());\n  const unsubscribe = store.subscribe(() =>\n    entriesSignal.set(store.getSnapshot())\n  );\n  destroyRef.onDestroy(unsubscribe);\n\n  const entries = computed(() => entriesSignal());\n  const size = computed(() => entriesSignal().length);\n\n  return {\n    entries,\n    size,\n    cancel: (id) => controller.cancelQueued(id),\n    clear: () => controller.clearQueue(),\n  };\n}\n\nexport type { SubmissionQueueEntry, SubmissionQueueSnapshot };\n"],"mappings":";;;AA2DA,SAAgB,sBACd,QAC6B;CAC7B,MAAM,cAAA,GAAA,cAAA,QAAoBA,cAAAA,WAAW;CACrC,MAAM,aAAa,OAAOC,mBAAAA;CAC1B,MAAM,QAAQ,WAAW;CAEzB,MAAM,iBAAA,GAAA,cAAA,QAAgD,MAAM,aAAa,CAAC;CAC1E,MAAM,cAAc,MAAM,gBACxB,cAAc,IAAI,MAAM,aAAa,CAAC,CACvC;AACD,YAAW,UAAU,YAAY;AAKjC,QAAO;EACL,UAAA,GAAA,cAAA,gBAJ6B,eAAe,CAAC;EAK7C,OAAA,GAAA,cAAA,gBAJ0B,eAAe,CAAC,OAAO;EAKjD,SAAS,OAAO,WAAW,aAAa,GAAG;EAC3C,aAAa,WAAW,YAAY;EACrC"}

package/dist/selectors-queue.d.cts

@@ -0,0 +1,36 @@
+import { AnyStream, UseStreamReturn } from "./use-stream.cjs";
+import { SubmissionQueueEntry, SubmissionQueueSnapshot } from "@langchain/langgraph-sdk/stream";
+import { Signal } from "@angular/core";
+
+//#region src/selectors-queue.d.ts
+/**
+ * Reactive handle on the server-side submission queue.
+ *
+ * Populated when `submit()` is invoked with
+ * `multitaskStrategy: "enqueue"` while another run is in flight. The
+ * returned `entries` signal is stable per snapshot so consumers can
+ * feed it straight into Angular `@for` loops:
+ *
+ * ```html
+ * @for (entry of queue.entries(); track entry.id) {
+ *   <div>{{ entry.values | json }}</div>
+ * }
+ * ```
+ *
+ * Today the queue is maintained client-side; once the server starts
+ * emitting a dedicated queue channel (roadmap A0.3) the controller
+ * will mirror that state directly — the selector surface will not
+ * change.
+ */
+interface InjectSubmissionQueueReturn<StateType extends object = Record<string, unknown>> {
+  readonly entries: Signal<SubmissionQueueSnapshot<StateType>>;
+  readonly size: Signal<number>;
+  cancel(id: string): Promise<boolean>;
+  clear(): Promise<void>;
+}
+type StreamHandle<StateType extends object> = UseStreamReturn<StateType, any, any>;
+declare function injectSubmissionQueue<StateType extends object>(stream: StreamHandle<StateType>): InjectSubmissionQueueReturn<StateType>;
+declare function injectSubmissionQueue(stream: AnyStream): InjectSubmissionQueueReturn;
+//#endregion
+export { InjectSubmissionQueueReturn, type SubmissionQueueEntry, type SubmissionQueueSnapshot, injectSubmissionQueue };
+//# sourceMappingURL=selectors-queue.d.cts.map

package/dist/selectors-queue.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors-queue.d.cts","names":[],"sources":["../src/selectors-queue.ts"],"mappings":";;;;;;;AAoCA;;;;;;;;;;;;;;;;;UAAiB,2BAAA,4BACY,MAAA;EAAA,SAElB,OAAA,EAAS,MAAA,CAAO,uBAAA,CAAwB,SAAA;EAAA,SACxC,IAAA,EAAM,MAAA;EACf,MAAA,CAAO,EAAA,WAAa,OAAA;EACpB,KAAA,IAAS,OAAA;AAAA;AAAA,KAGN,YAAA,6BAAyC,eAAA,CAC5C,SAAA;AAAA,iBAOc,qBAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,2BAAA,CAA4B,SAAA;AAAA,iBACf,qBAAA,CACd,MAAA,EAAQ,SAAA,GACP,2BAAA"}

package/dist/selectors-queue.d.ts

@@ -0,0 +1,36 @@
+import { AnyStream, UseStreamReturn } from "./use-stream.js";
+import { Signal } from "@angular/core";
+import { SubmissionQueueEntry, SubmissionQueueSnapshot } from "@langchain/langgraph-sdk/stream";
+
+//#region src/selectors-queue.d.ts
+/**
+ * Reactive handle on the server-side submission queue.
+ *
+ * Populated when `submit()` is invoked with
+ * `multitaskStrategy: "enqueue"` while another run is in flight. The
+ * returned `entries` signal is stable per snapshot so consumers can
+ * feed it straight into Angular `@for` loops:
+ *
+ * ```html
+ * @for (entry of queue.entries(); track entry.id) {
+ *   <div>{{ entry.values | json }}</div>
+ * }
+ * ```
+ *
+ * Today the queue is maintained client-side; once the server starts
+ * emitting a dedicated queue channel (roadmap A0.3) the controller
+ * will mirror that state directly — the selector surface will not
+ * change.
+ */
+interface InjectSubmissionQueueReturn<StateType extends object = Record<string, unknown>> {
+  readonly entries: Signal<SubmissionQueueSnapshot<StateType>>;
+  readonly size: Signal<number>;
+  cancel(id: string): Promise<boolean>;
+  clear(): Promise<void>;
+}
+type StreamHandle<StateType extends object> = UseStreamReturn<StateType, any, any>;
+declare function injectSubmissionQueue<StateType extends object>(stream: StreamHandle<StateType>): InjectSubmissionQueueReturn<StateType>;
+declare function injectSubmissionQueue(stream: AnyStream): InjectSubmissionQueueReturn;
+//#endregion
+export { InjectSubmissionQueueReturn, type SubmissionQueueEntry, type SubmissionQueueSnapshot, injectSubmissionQueue };
+//# sourceMappingURL=selectors-queue.d.ts.map

package/dist/selectors-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors-queue.d.ts","names":[],"sources":["../src/selectors-queue.ts"],"mappings":";;;;;;;AAoCA;;;;;;;;;;;;;;;;;UAAiB,2BAAA,4BACY,MAAA;EAAA,SAElB,OAAA,EAAS,MAAA,CAAO,uBAAA,CAAwB,SAAA;EAAA,SACxC,IAAA,EAAM,MAAA;EACf,MAAA,CAAO,EAAA,WAAa,OAAA;EACpB,KAAA,IAAS,OAAA;AAAA;AAAA,KAGN,YAAA,6BAAyC,eAAA,CAC5C,SAAA;AAAA,iBAOc,qBAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,2BAAA,CAA4B,SAAA;AAAA,iBACf,qBAAA,CACd,MAAA,EAAQ,SAAA,GACP,2BAAA"}

package/dist/selectors-queue.js

@@ -0,0 +1,21 @@
+import { STREAM_CONTROLLER } from "./use-stream.js";
+import { DestroyRef, computed, inject, signal } from "@angular/core";
+//#region src/selectors-queue.ts
+function injectSubmissionQueue(stream) {
+	const destroyRef = inject(DestroyRef);
+	const controller = stream[STREAM_CONTROLLER];
+	const store = controller.queueStore;
+	const entriesSignal = signal(store.getSnapshot());
+	const unsubscribe = store.subscribe(() => entriesSignal.set(store.getSnapshot()));
+	destroyRef.onDestroy(unsubscribe);
+	return {
+		entries: computed(() => entriesSignal()),
+		size: computed(() => entriesSignal().length),
+		cancel: (id) => controller.cancelQueued(id),
+		clear: () => controller.clearQueue()
+	};
+}
+//#endregion
+export { injectSubmissionQueue };
+
+//# sourceMappingURL=selectors-queue.js.map

package/dist/selectors-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors-queue.js","names":[],"sources":["../src/selectors-queue.ts"],"sourcesContent":["import {\n  DestroyRef,\n  computed,\n  inject,\n  signal,\n  type Signal,\n} from \"@angular/core\";\nimport type {\n  SubmissionQueueEntry,\n  SubmissionQueueSnapshot,\n} from \"@langchain/langgraph-sdk/stream\";\nimport {\n  STREAM_CONTROLLER,\n  type AnyStream,\n  type UseStreamReturn,\n} from \"./use-stream.js\";\n\n/**\n * Reactive handle on the server-side submission queue.\n *\n * Populated when `submit()` is invoked with\n * `multitaskStrategy: \"enqueue\"` while another run is in flight. The\n * returned `entries` signal is stable per snapshot so consumers can\n * feed it straight into Angular `@for` loops:\n *\n * ```html\n * @for (entry of queue.entries(); track entry.id) {\n *   <div>{{ entry.values | json }}</div>\n * }\n * ```\n *\n * Today the queue is maintained client-side; once the server starts\n * emitting a dedicated queue channel (roadmap A0.3) the controller\n * will mirror that state directly — the selector surface will not\n * change.\n */\nexport interface InjectSubmissionQueueReturn<\n  StateType extends object = Record<string, unknown>,\n> {\n  readonly entries: Signal<SubmissionQueueSnapshot<StateType>>;\n  readonly size: Signal<number>;\n  cancel(id: string): Promise<boolean>;\n  clear(): Promise<void>;\n}\n\ntype StreamHandle<StateType extends object> = UseStreamReturn<\n  StateType,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any\n>;\n\nexport function injectSubmissionQueue<StateType extends object>(\n  stream: StreamHandle<StateType>\n): InjectSubmissionQueueReturn<StateType>;\nexport function injectSubmissionQueue(\n  stream: AnyStream\n): InjectSubmissionQueueReturn;\nexport function injectSubmissionQueue(\n  stream: AnyStream\n): InjectSubmissionQueueReturn {\n  const destroyRef = inject(DestroyRef);\n  const controller = stream[STREAM_CONTROLLER];\n  const store = controller.queueStore;\n\n  const entriesSignal = signal<SubmissionQueueSnapshot>(store.getSnapshot());\n  const unsubscribe = store.subscribe(() =>\n    entriesSignal.set(store.getSnapshot())\n  );\n  destroyRef.onDestroy(unsubscribe);\n\n  const entries = computed(() => entriesSignal());\n  const size = computed(() => entriesSignal().length);\n\n  return {\n    entries,\n    size,\n    cancel: (id) => controller.cancelQueued(id),\n    clear: () => controller.clearQueue(),\n  };\n}\n\nexport type { SubmissionQueueEntry, SubmissionQueueSnapshot };\n"],"mappings":";;;AA2DA,SAAgB,sBACd,QAC6B;CAC7B,MAAM,aAAa,OAAO,WAAW;CACrC,MAAM,aAAa,OAAO;CAC1B,MAAM,QAAQ,WAAW;CAEzB,MAAM,gBAAgB,OAAgC,MAAM,aAAa,CAAC;CAC1E,MAAM,cAAc,MAAM,gBACxB,cAAc,IAAI,MAAM,aAAa,CAAC,CACvC;AACD,YAAW,UAAU,YAAY;AAKjC,QAAO;EACL,SAJc,eAAe,eAAe,CAAC;EAK7C,MAJW,eAAe,eAAe,CAAC,OAAO;EAKjD,SAAS,OAAO,WAAW,aAAa,GAAG;EAC3C,aAAa,WAAW,YAAY;EACrC"}

package/dist/selectors.cjs

@@ -0,0 +1,144 @@
+const require_use_stream = require("./use-stream.cjs");
+const require_inject_projection = require("./inject-projection.cjs");
+let _angular_core = require("@angular/core");
+let _langchain_langgraph_sdk_stream = require("@langchain/langgraph-sdk/stream");
+//#region src/selectors.ts
+const EMPTY_NAMESPACE = [];
+function resolveNamespace(target) {
+	if (target == null) return EMPTY_NAMESPACE;
+	if (Array.isArray(target)) return target;
+	return target.namespace ?? EMPTY_NAMESPACE;
+}
+function isRoot(namespace) {
+	return namespace.length === 0;
+}
+function namespaceKey(namespace) {
+	return namespace.join(_langchain_langgraph_sdk_stream.NAMESPACE_SEPARATOR);
+}
+/**
+* Resolve a target or target-signal into a reactive
+* `[namespace, key]` pair. The helper returns plain signals so
+* `injectProjection` can track them via its internal effect.
+*/
+function normalizeTarget(target, prefix) {
+	if ((0, _angular_core.isSignal)(target)) {
+		const namespace = (0, _angular_core.computed)(() => resolveNamespace(target()));
+		return {
+			namespace,
+			key: (0, _angular_core.computed)(() => `${prefix}|${namespaceKey(namespace())}`),
+			isRootSignal: (0, _angular_core.computed)(() => isRoot(namespace()))
+		};
+	}
+	const ns = resolveNamespace(target);
+	const staticKey = `${prefix}|${namespaceKey(ns)}`;
+	return {
+		namespace: (0, _angular_core.computed)(() => ns),
+		key: (0, _angular_core.computed)(() => staticKey),
+		isRootSignal: (0, _angular_core.computed)(() => isRoot(ns))
+	};
+}
+/**
+* Subscribe to a scoped `messages` stream.
+*
+* Contract:
+*  - At the root (no `target`) this returns `stream.messages` — the
+*    always-on root projection; no extra subscription is opened.
+*  - For any non-root namespace, call-time triggers a ref-counted
+*    `messages` subscription scoped to that namespace. The
+*    subscription is released automatically when the calling
+*    component / service is destroyed (and the registry closes the
+*    underlying server subscription when the last consumer leaves).
+*
+* Messages are always `BaseMessage` class instances from
+* `@langchain/core/messages`.
+*/
+function injectMessages(stream, target) {
+	const { namespace, key, isRootSignal } = normalizeTarget(target, "messages");
+	const scoped = require_inject_projection.injectProjection((0, _angular_core.computed)(() => isRootSignal() ? null : require_use_stream.getRegistry(stream)), () => (0, _langchain_langgraph_sdk_stream.messagesProjection)(namespace()), key, EMPTY_MESSAGES);
+	return (0, _angular_core.computed)(() => isRootSignal() ? stream.messages() : scoped());
+}
+const EMPTY_MESSAGES = [];
+/**
+* Subscribe to a scoped `tools` (tool-call) stream. Same target and
+* lifecycle rules as {@link injectMessages}; at the root this returns
+* `stream.toolCalls` directly.
+*/
+function injectToolCalls(stream, target) {
+	const { namespace, key, isRootSignal } = normalizeTarget(target, "toolCalls");
+	const scoped = require_inject_projection.injectProjection((0, _angular_core.computed)(() => isRootSignal() ? null : require_use_stream.getRegistry(stream)), () => (0, _langchain_langgraph_sdk_stream.toolCallsProjection)(namespace()), key, EMPTY_TOOLCALLS);
+	return (0, _angular_core.computed)(() => isRootSignal() ? stream.toolCalls() : scoped());
+}
+const EMPTY_TOOLCALLS = [];
+function injectValues(stream, target, options) {
+	const messagesKey = options?.messagesKey ?? "messages";
+	const { namespace, key, isRootSignal } = normalizeTarget(target, `values|${messagesKey}`);
+	const scoped = require_inject_projection.injectProjection((0, _angular_core.computed)(() => isRootSignal() ? null : require_use_stream.getRegistry(stream)), () => (0, _langchain_langgraph_sdk_stream.valuesProjection)(namespace(), messagesKey), key, void 0);
+	return (0, _angular_core.computed)(() => isRootSignal() ? stream.values() : scoped());
+}
+/**
+* Subscribe to a `custom:<name>` stream extension — the most recent
+* payload emitted by the transformer, scoped to the target namespace.
+*/
+function injectExtension(stream, name, target) {
+	const { namespace, key } = normalizeTarget(target, `extension|${name}`);
+	return require_inject_projection.injectProjection(require_use_stream.getRegistry(stream), () => (0, _langchain_langgraph_sdk_stream.extensionProjection)(name, namespace()), key, void 0);
+}
+function injectChannel(stream, channels, target, options) {
+	const sortedChannels = [...channels].sort().join(",");
+	const { namespace, key } = normalizeTarget(target, `channel|${options?.bufferSize ?? "default"}|${options?.replay ?? true ? "replay" : "live"}|${sortedChannels}`);
+	return require_inject_projection.injectProjection(require_use_stream.getRegistry(stream), () => (0, _langchain_langgraph_sdk_stream.channelProjection)(channels, namespace(), options), key, EMPTY_EVENTS);
+}
+const EMPTY_EVENTS = [];
+/**
+* Subscribe to a scoped audio-media stream. Each handle is yielded
+* on its first matching `content-block-start`, exposes
+* `.partialBytes` for live access, settles `.blob` / `.objectURL` /
+* `.transcript` on `message-finish`, and surfaces errors via
+* `.error`.
+*
+* Pair with `injectMediaUrl` to turn a handle into an `<audio src>`.
+*/
+function injectAudio(stream, target) {
+	const { namespace, key } = normalizeTarget(target, "audio");
+	return require_inject_projection.injectProjection(require_use_stream.getRegistry(stream), () => (0, _langchain_langgraph_sdk_stream.audioProjection)(namespace()), key, EMPTY_AUDIO);
+}
+const EMPTY_AUDIO = [];
+/**
+* Subscribe to a scoped image-media stream. Pair with
+* `injectMediaUrl` for `<img src>`.
+*/
+function injectImages(stream, target) {
+	const { namespace, key } = normalizeTarget(target, "images");
+	return require_inject_projection.injectProjection(require_use_stream.getRegistry(stream), () => (0, _langchain_langgraph_sdk_stream.imagesProjection)(namespace()), key, EMPTY_IMAGES);
+}
+const EMPTY_IMAGES = [];
+/**
+* Subscribe to a scoped video-media stream. Pair with
+* `injectMediaUrl` for `<video src>`.
+*/
+function injectVideo(stream, target) {
+	const { namespace, key } = normalizeTarget(target, "video");
+	return require_inject_projection.injectProjection(require_use_stream.getRegistry(stream), () => (0, _langchain_langgraph_sdk_stream.videoProjection)(namespace()), key, EMPTY_VIDEO);
+}
+const EMPTY_VIDEO = [];
+/**
+* Subscribe to a scoped file-media stream. Pair with
+* `injectMediaUrl` for an `<a download href>` target.
+*/
+function injectFiles(stream, target) {
+	const { namespace, key } = normalizeTarget(target, "files");
+	return require_inject_projection.injectProjection(require_use_stream.getRegistry(stream), () => (0, _langchain_langgraph_sdk_stream.filesProjection)(namespace()), key, EMPTY_FILES);
+}
+const EMPTY_FILES = [];
+//#endregion
+exports.injectAudio = injectAudio;
+exports.injectChannel = injectChannel;
+exports.injectExtension = injectExtension;
+exports.injectFiles = injectFiles;
+exports.injectImages = injectImages;
+exports.injectMessages = injectMessages;
+exports.injectToolCalls = injectToolCalls;
+exports.injectValues = injectValues;
+exports.injectVideo = injectVideo;
+
+//# sourceMappingURL=selectors.cjs.map

package/dist/selectors.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.cjs","names":["NAMESPACE_SEPARATOR","injectProjection","getRegistry"],"sources":["../src/selectors.ts"],"sourcesContent":["import { computed, isSignal, type Signal } from \"@angular/core\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  NAMESPACE_SEPARATOR,\n  audioProjection,\n  channelProjection,\n  extensionProjection,\n  filesProjection,\n  imagesProjection,\n  messagesProjection,\n  toolCallsProjection,\n  valuesProjection,\n  videoProjection,\n  type AssembledToolCall,\n  type AudioMedia,\n  type Channel,\n  type ChannelProjectionOptions,\n  type Event,\n  type FileMedia,\n  type ImageMedia,\n  type InferStateType,\n  type SubagentDiscoverySnapshot,\n  type SubgraphDiscoverySnapshot,\n  type VideoMedia,\n} from \"@langchain/langgraph-sdk/stream\";\nimport {\n  getRegistry,\n  type AnyStream,\n  type UseStreamReturn,\n} from \"./use-stream.js\";\nimport { injectProjection } from \"./inject-projection.js\";\n\n/**\n * Selector primitives don't need to carry `InterruptType` /\n * `ConfigurableType`. Parameterising on `StateType` alone lets\n * callers with a full `injectStream<S, I, C>()` handle pass it in\n * without redeclaring those generics at every call site.\n */\ntype StreamHandle<StateType extends object> = UseStreamReturn<\n  StateType,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any\n>;\n\n/**\n * What a selector primitive can be targeted at. Callers can pass:\n *  - `undefined` / `null` — root namespace (served by the always-on\n *    root store — no extra subscription);\n *  - a {@link SubagentDiscoverySnapshot} (`stream.subagents().get(...)`);\n *  - a {@link SubgraphDiscoverySnapshot} (`stream.subgraphs().get(...)`);\n *  - an explicit `{ namespace: string[] }`;\n *  - a raw `string[]` escape hatch.\n *\n * Selectors also accept a `Signal<SelectorTarget>` so callers can\n * feed a `computed(() => ...)` and have the projection rebind\n * automatically.\n */\nexport type SelectorTarget =\n  | undefined\n  | null\n  | readonly string[]\n  | { namespace: readonly string[] }\n  | SubagentDiscoverySnapshot\n  | SubgraphDiscoverySnapshot;\n\nconst EMPTY_NAMESPACE: readonly string[] = [];\n\nfunction resolveNamespace(target: SelectorTarget): readonly string[] {\n  if (target == null) return EMPTY_NAMESPACE;\n  if (Array.isArray(target)) return target as readonly string[];\n  const obj = target as { namespace?: readonly string[] };\n  return obj.namespace ?? EMPTY_NAMESPACE;\n}\n\nfunction isRoot(namespace: readonly string[]): boolean {\n  return namespace.length === 0;\n}\n\nfunction namespaceKey(namespace: readonly string[]): string {\n  return namespace.join(NAMESPACE_SEPARATOR);\n}\n\n/**\n * Resolve a target or target-signal into a reactive\n * `[namespace, key]` pair. The helper returns plain signals so\n * `injectProjection` can track them via its internal effect.\n */\nfunction normalizeTarget(\n  target: SelectorTarget | Signal<SelectorTarget>,\n  prefix: string\n): {\n  namespace: Signal<readonly string[]>;\n  key: Signal<string>;\n  isRootSignal: Signal<boolean>;\n} {\n  if (isSignal(target)) {\n    const namespace = computed(() =>\n      resolveNamespace((target as Signal<SelectorTarget>)())\n    );\n    const key = computed(() => `${prefix}|${namespaceKey(namespace())}`);\n    const isRootSignal = computed(() => isRoot(namespace()));\n    return { namespace, key, isRootSignal };\n  }\n  const ns = resolveNamespace(target as SelectorTarget);\n  const staticKey = `${prefix}|${namespaceKey(ns)}`;\n  return {\n    namespace: computed(() => ns),\n    key: computed(() => staticKey),\n    isRootSignal: computed(() => isRoot(ns)),\n  };\n}\n\n/**\n * Subscribe to a scoped `messages` stream.\n *\n * Contract:\n *  - At the root (no `target`) this returns `stream.messages` — the\n *    always-on root projection; no extra subscription is opened.\n *  - For any non-root namespace, call-time triggers a ref-counted\n *    `messages` subscription scoped to that namespace. The\n *    subscription is released automatically when the calling\n *    component / service is destroyed (and the registry closes the\n *    underlying server subscription when the last consumer leaves).\n *\n * Messages are always `BaseMessage` class instances from\n * `@langchain/core/messages`.\n */\nexport function injectMessages(\n  stream: AnyStream,\n  target?: SelectorTarget | Signal<SelectorTarget>\n): Signal<BaseMessage[]> {\n  const { namespace, key, isRootSignal } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    \"messages\"\n  );\n  const registry = computed(() =>\n    isRootSignal() ? null : getRegistry(stream)\n  );\n  const scoped = injectProjection<BaseMessage[]>(\n    registry,\n    () => messagesProjection(namespace()),\n    key,\n    EMPTY_MESSAGES\n  );\n  return computed(() => (isRootSignal() ? stream.messages() : scoped()));\n}\n\nconst EMPTY_MESSAGES: BaseMessage[] = [];\n\n/**\n * Subscribe to a scoped `tools` (tool-call) stream. Same target and\n * lifecycle rules as {@link injectMessages}; at the root this returns\n * `stream.toolCalls` directly.\n */\nexport function injectToolCalls(\n  stream: AnyStream,\n  target?: SelectorTarget | Signal<SelectorTarget>\n): Signal<AssembledToolCall[]> {\n  const { namespace, key, isRootSignal } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    \"toolCalls\"\n  );\n  const registry = computed(() =>\n    isRootSignal() ? null : getRegistry(stream)\n  );\n  const scoped = injectProjection<AssembledToolCall[]>(\n    registry,\n    () => toolCallsProjection(namespace()),\n    key,\n    EMPTY_TOOLCALLS\n  );\n  return computed(() => (isRootSignal() ? stream.toolCalls() : scoped()));\n}\n\nconst EMPTY_TOOLCALLS: AssembledToolCall[] = [];\n\n/**\n * Subscribe to a scoped `values` stream — the most recent state\n * payload for a namespace. At the root returns `stream.values`.\n *\n * Typing:\n *  - **Root** (`injectValues(stream)`): returns the `StateType`\n *    declared on `injectStream<State>()` — non-nullable (the root\n *    snapshot always has values, falling back to `initialValues ??\n *    {}`).\n *  - **Scoped** (`injectValues(stream, target)`): scoped payloads can\n *    differ from the root state; callers should annotate the expected\n *    shape explicitly (`injectValues<SubagentState>(stream, sub)`).\n *    Defaults to `unknown` when not annotated.\n */\nexport function injectValues<StateType extends object>(\n  stream: StreamHandle<StateType>\n): Signal<StateType>;\nexport function injectValues<T>(stream: AnyStream): Signal<InferStateType<T>>;\nexport function injectValues<T = unknown>(\n  stream: AnyStream,\n  target: SelectorTarget | Signal<SelectorTarget>,\n  options?: { messagesKey?: string }\n): Signal<T | undefined>;\nexport function injectValues(\n  stream: AnyStream,\n  target?: SelectorTarget | Signal<SelectorTarget>,\n  options?: { messagesKey?: string }\n): Signal<unknown> {\n  const messagesKey = options?.messagesKey ?? \"messages\";\n  const { namespace, key, isRootSignal } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    `values|${messagesKey}`\n  );\n  const registry = computed(() =>\n    isRootSignal() ? null : getRegistry(stream)\n  );\n  const scoped = injectProjection<unknown>(\n    registry,\n    () => valuesProjection<unknown>(namespace(), messagesKey),\n    key,\n    undefined\n  );\n  return computed(() => (isRootSignal() ? stream.values() : scoped()));\n}\n\n/**\n * Subscribe to a `custom:<name>` stream extension — the most recent\n * payload emitted by the transformer, scoped to the target namespace.\n */\nexport function injectExtension<T = unknown>(\n  stream: AnyStream,\n  name: string,\n  target?: SelectorTarget | Signal<SelectorTarget>\n): Signal<T | undefined> {\n  const { namespace, key } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    `extension|${name}`\n  );\n  return injectProjection<T | undefined>(\n    getRegistry(stream),\n    () => extensionProjection<T>(name, namespace()),\n    key,\n    undefined\n  );\n}\n\n/**\n * Raw-events escape hatch. Subscribes to one or more channels at a\n * namespace and returns a bounded buffer of raw protocol events.\n * Prefer {@link injectMessages} / {@link injectToolCalls} /\n * {@link injectValues} for the common cases.\n */\nexport type InjectChannelOptions = ChannelProjectionOptions;\n\nexport function injectChannel(\n  stream: AnyStream,\n  channels: readonly Channel[],\n  target?: SelectorTarget | Signal<SelectorTarget>,\n  options?: InjectChannelOptions\n): Signal<Event[]> {\n  const sortedChannels = [...channels].sort().join(\",\");\n  const prefix = `channel|${options?.bufferSize ?? \"default\"}|${(options?.replay ?? true) ? \"replay\" : \"live\"}|${sortedChannels}`;\n  const { namespace, key } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    prefix\n  );\n  return injectProjection<Event[]>(\n    getRegistry(stream),\n    () => channelProjection(channels, namespace(), options),\n    key,\n    EMPTY_EVENTS\n  );\n}\n\nconst EMPTY_EVENTS: Event[] = [];\n\n/**\n * Subscribe to a scoped audio-media stream. Each handle is yielded\n * on its first matching `content-block-start`, exposes\n * `.partialBytes` for live access, settles `.blob` / `.objectURL` /\n * `.transcript` on `message-finish`, and surfaces errors via\n * `.error`.\n *\n * Pair with `injectMediaUrl` to turn a handle into an `<audio src>`.\n */\nexport function injectAudio(\n  stream: AnyStream,\n  target?: SelectorTarget | Signal<SelectorTarget>\n): Signal<AudioMedia[]> {\n  const { namespace, key } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    \"audio\"\n  );\n  return injectProjection<AudioMedia[]>(\n    getRegistry(stream),\n    () => audioProjection(namespace()),\n    key,\n    EMPTY_AUDIO\n  );\n}\n\nconst EMPTY_AUDIO: AudioMedia[] = [];\n\n/**\n * Subscribe to a scoped image-media stream. Pair with\n * `injectMediaUrl` for `<img src>`.\n */\nexport function injectImages(\n  stream: AnyStream,\n  target?: SelectorTarget | Signal<SelectorTarget>\n): Signal<ImageMedia[]> {\n  const { namespace, key } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    \"images\"\n  );\n  return injectProjection<ImageMedia[]>(\n    getRegistry(stream),\n    () => imagesProjection(namespace()),\n    key,\n    EMPTY_IMAGES\n  );\n}\n\nconst EMPTY_IMAGES: ImageMedia[] = [];\n\n/**\n * Subscribe to a scoped video-media stream. Pair with\n * `injectMediaUrl` for `<video src>`.\n */\nexport function injectVideo(\n  stream: AnyStream,\n  target?: SelectorTarget | Signal<SelectorTarget>\n): Signal<VideoMedia[]> {\n  const { namespace, key } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    \"video\"\n  );\n  return injectProjection<VideoMedia[]>(\n    getRegistry(stream),\n    () => videoProjection(namespace()),\n    key,\n    EMPTY_VIDEO\n  );\n}\n\nconst EMPTY_VIDEO: VideoMedia[] = [];\n\n/**\n * Subscribe to a scoped file-media stream. Pair with\n * `injectMediaUrl` for an `<a download href>` target.\n */\nexport function injectFiles(\n  stream: AnyStream,\n  target?: SelectorTarget | Signal<SelectorTarget>\n): Signal<FileMedia[]> {\n  const { namespace, key } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    \"files\"\n  );\n  return injectProjection<FileMedia[]>(\n    getRegistry(stream),\n    () => filesProjection(namespace()),\n    key,\n    EMPTY_FILES\n  );\n}\n\nconst EMPTY_FILES: FileMedia[] = [];\n"],"mappings":"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"}

package/dist/selectors.d.cts

@@ -0,0 +1,111 @@
+import { AnyStream, UseStreamReturn } from "./use-stream.cjs";
+import { AssembledToolCall, AudioMedia, Channel, ChannelProjectionOptions, Event, FileMedia, ImageMedia, InferStateType, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, VideoMedia } from "@langchain/langgraph-sdk/stream";
+import { Signal } from "@angular/core";
+import { BaseMessage } from "@langchain/core/messages";
+
+//#region src/selectors.d.ts
+/**
+ * Selector primitives don't need to carry `InterruptType` /
+ * `ConfigurableType`. Parameterising on `StateType` alone lets
+ * callers with a full `injectStream<S, I, C>()` handle pass it in
+ * without redeclaring those generics at every call site.
+ */
+type StreamHandle<StateType extends object> = UseStreamReturn<StateType, any, any>;
+/**
+ * What a selector primitive can be targeted at. Callers can pass:
+ *  - `undefined` / `null` — root namespace (served by the always-on
+ *    root store — no extra subscription);
+ *  - a {@link SubagentDiscoverySnapshot} (`stream.subagents().get(...)`);
+ *  - a {@link SubgraphDiscoverySnapshot} (`stream.subgraphs().get(...)`);
+ *  - an explicit `{ namespace: string[] }`;
+ *  - a raw `string[]` escape hatch.
+ *
+ * Selectors also accept a `Signal<SelectorTarget>` so callers can
+ * feed a `computed(() => ...)` and have the projection rebind
+ * automatically.
+ */
+type SelectorTarget = undefined | null | readonly string[] | {
+  namespace: readonly string[];
+} | SubagentDiscoverySnapshot | SubgraphDiscoverySnapshot;
+/**
+ * Subscribe to a scoped `messages` stream.
+ *
+ * Contract:
+ *  - At the root (no `target`) this returns `stream.messages` — the
+ *    always-on root projection; no extra subscription is opened.
+ *  - For any non-root namespace, call-time triggers a ref-counted
+ *    `messages` subscription scoped to that namespace. The
+ *    subscription is released automatically when the calling
+ *    component / service is destroyed (and the registry closes the
+ *    underlying server subscription when the last consumer leaves).
+ *
+ * Messages are always `BaseMessage` class instances from
+ * `@langchain/core/messages`.
+ */
+declare function injectMessages(stream: AnyStream, target?: SelectorTarget | Signal<SelectorTarget>): Signal<BaseMessage[]>;
+/**
+ * Subscribe to a scoped `tools` (tool-call) stream. Same target and
+ * lifecycle rules as {@link injectMessages}; at the root this returns
+ * `stream.toolCalls` directly.
+ */
+declare function injectToolCalls(stream: AnyStream, target?: SelectorTarget | Signal<SelectorTarget>): Signal<AssembledToolCall[]>;
+/**
+ * Subscribe to a scoped `values` stream — the most recent state
+ * payload for a namespace. At the root returns `stream.values`.
+ *
+ * Typing:
+ *  - **Root** (`injectValues(stream)`): returns the `StateType`
+ *    declared on `injectStream<State>()` — non-nullable (the root
+ *    snapshot always has values, falling back to `initialValues ??
+ *    {}`).
+ *  - **Scoped** (`injectValues(stream, target)`): scoped payloads can
+ *    differ from the root state; callers should annotate the expected
+ *    shape explicitly (`injectValues<SubagentState>(stream, sub)`).
+ *    Defaults to `unknown` when not annotated.
+ */
+declare function injectValues<StateType extends object>(stream: StreamHandle<StateType>): Signal<StateType>;
+declare function injectValues<T>(stream: AnyStream): Signal<InferStateType<T>>;
+declare function injectValues<T = unknown>(stream: AnyStream, target: SelectorTarget | Signal<SelectorTarget>, options?: {
+  messagesKey?: string;
+}): Signal<T | undefined>;
+/**
+ * Subscribe to a `custom:<name>` stream extension — the most recent
+ * payload emitted by the transformer, scoped to the target namespace.
+ */
+declare function injectExtension<T = unknown>(stream: AnyStream, name: string, target?: SelectorTarget | Signal<SelectorTarget>): Signal<T | undefined>;
+/**
+ * Raw-events escape hatch. Subscribes to one or more channels at a
+ * namespace and returns a bounded buffer of raw protocol events.
+ * Prefer {@link injectMessages} / {@link injectToolCalls} /
+ * {@link injectValues} for the common cases.
+ */
+type InjectChannelOptions = ChannelProjectionOptions;
+declare function injectChannel(stream: AnyStream, channels: readonly Channel[], target?: SelectorTarget | Signal<SelectorTarget>, options?: InjectChannelOptions): Signal<Event[]>;
+/**
+ * Subscribe to a scoped audio-media stream. Each handle is yielded
+ * on its first matching `content-block-start`, exposes
+ * `.partialBytes` for live access, settles `.blob` / `.objectURL` /
+ * `.transcript` on `message-finish`, and surfaces errors via
+ * `.error`.
+ *
+ * Pair with `injectMediaUrl` to turn a handle into an `<audio src>`.
+ */
+declare function injectAudio(stream: AnyStream, target?: SelectorTarget | Signal<SelectorTarget>): Signal<AudioMedia[]>;
+/**
+ * Subscribe to a scoped image-media stream. Pair with
+ * `injectMediaUrl` for `<img src>`.
+ */
+declare function injectImages(stream: AnyStream, target?: SelectorTarget | Signal<SelectorTarget>): Signal<ImageMedia[]>;
+/**
+ * Subscribe to a scoped video-media stream. Pair with
+ * `injectMediaUrl` for `<video src>`.
+ */
+declare function injectVideo(stream: AnyStream, target?: SelectorTarget | Signal<SelectorTarget>): Signal<VideoMedia[]>;
+/**
+ * Subscribe to a scoped file-media stream. Pair with
+ * `injectMediaUrl` for an `<a download href>` target.
+ */
+declare function injectFiles(stream: AnyStream, target?: SelectorTarget | Signal<SelectorTarget>): Signal<FileMedia[]>;
+//#endregion
+export { SelectorTarget, injectAudio, injectChannel, injectExtension, injectFiles, injectImages, injectMessages, injectToolCalls, injectValues, injectVideo };
+//# sourceMappingURL=selectors.d.cts.map

package/dist/selectors.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.cts","names":[],"sources":["../src/selectors.ts"],"mappings":";;;;;;;;AA6ByB;;;;KASpB,YAAA,6BAAyC,eAAA,CAC5C,SAAA;;;;;AAoBF;;;;;;;;;KAAY,cAAA;EAIN,SAAA;AAAA,IACF,yBAAA,GACA,yBAAA;;;;;;;;;;;;;;;;iBAgEY,cAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GAAiB,MAAA,CAAO,cAAA,IAChC,MAAA,CAAO,WAAA;;;AAwBV;;;iBAAgB,eAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GAAiB,MAAA,CAAO,cAAA,IAChC,MAAA,CAAO,iBAAA;;;;;;;;;;;;;;;iBAiCM,YAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,MAAA,CAAO,SAAA;AAAA,iBACM,YAAA,GAAA,CAAgB,MAAA,EAAQ,SAAA,GAAY,MAAA,CAAO,cAAA,CAAe,CAAA;AAAA,iBAC1D,YAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,EAAQ,cAAA,GAAiB,MAAA,CAAO,cAAA,GAChC,OAAA;EAAY,WAAA;AAAA,IACX,MAAA,CAAO,CAAA;;;;;iBA2BM,eAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,IAAA,UACA,MAAA,GAAS,cAAA,GAAiB,MAAA,CAAO,cAAA,IAChC,MAAA,CAAO,CAAA;;;;;;;KAmBE,oBAAA,GAAuB,wBAAA;AAAA,iBAEnB,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,QAAA,WAAmB,OAAA,IACnB,MAAA,GAAS,cAAA,GAAiB,MAAA,CAAO,cAAA,GACjC,OAAA,GAAU,oBAAA,GACT,MAAA,CAAO,KAAA;;;AA9DV;;;;;;;iBAwFgB,WAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GAAiB,MAAA,CAAO,cAAA,IAChC,MAAA,CAAO,UAAA;;;;;iBAmBM,YAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GAAiB,MAAA,CAAO,cAAA,IAChC,MAAA,CAAO,UAAA;;;;;iBAmBM,WAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GAAiB,MAAA,CAAO,cAAA,IAChC,MAAA,CAAO,UAAA;;;;;iBAmBM,WAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GAAiB,MAAA,CAAO,cAAA,IAChC,MAAA,CAAO,SAAA"}

package/dist/selectors.d.ts

@@ -0,0 +1,111 @@
+import { AnyStream, UseStreamReturn } from "./use-stream.js";
+import { Signal } from "@angular/core";
+import { AssembledToolCall, AudioMedia, Channel, ChannelProjectionOptions, Event, FileMedia, ImageMedia, InferStateType, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, VideoMedia } from "@langchain/langgraph-sdk/stream";
+import { BaseMessage } from "@langchain/core/messages";
+
+//#region src/selectors.d.ts
+/**
+ * Selector primitives don't need to carry `InterruptType` /
+ * `ConfigurableType`. Parameterising on `StateType` alone lets
+ * callers with a full `injectStream<S, I, C>()` handle pass it in
+ * without redeclaring those generics at every call site.
+ */
+type StreamHandle<StateType extends object> = UseStreamReturn<StateType, any, any>;
+/**
+ * What a selector primitive can be targeted at. Callers can pass:
+ *  - `undefined` / `null` — root namespace (served by the always-on
+ *    root store — no extra subscription);
+ *  - a {@link SubagentDiscoverySnapshot} (`stream.subagents().get(...)`);
+ *  - a {@link SubgraphDiscoverySnapshot} (`stream.subgraphs().get(...)`);
+ *  - an explicit `{ namespace: string[] }`;
+ *  - a raw `string[]` escape hatch.
+ *
+ * Selectors also accept a `Signal<SelectorTarget>` so callers can
+ * feed a `computed(() => ...)` and have the projection rebind
+ * automatically.
+ */
+type SelectorTarget = undefined | null | readonly string[] | {
+  namespace: readonly string[];
+} | SubagentDiscoverySnapshot | SubgraphDiscoverySnapshot;
+/**
+ * Subscribe to a scoped `messages` stream.
+ *
+ * Contract:
+ *  - At the root (no `target`) this returns `stream.messages` — the
+ *    always-on root projection; no extra subscription is opened.
+ *  - For any non-root namespace, call-time triggers a ref-counted
+ *    `messages` subscription scoped to that namespace. The
+ *    subscription is released automatically when the calling
+ *    component / service is destroyed (and the registry closes the
+ *    underlying server subscription when the last consumer leaves).
+ *
+ * Messages are always `BaseMessage` class instances from
+ * `@langchain/core/messages`.
+ */
+declare function injectMessages(stream: AnyStream, target?: SelectorTarget | Signal<SelectorTarget>): Signal<BaseMessage[]>;
+/**
+ * Subscribe to a scoped `tools` (tool-call) stream. Same target and
+ * lifecycle rules as {@link injectMessages}; at the root this returns
+ * `stream.toolCalls` directly.
+ */
+declare function injectToolCalls(stream: AnyStream, target?: SelectorTarget | Signal<SelectorTarget>): Signal<AssembledToolCall[]>;
+/**
+ * Subscribe to a scoped `values` stream — the most recent state
+ * payload for a namespace. At the root returns `stream.values`.
+ *
+ * Typing:
+ *  - **Root** (`injectValues(stream)`): returns the `StateType`
+ *    declared on `injectStream<State>()` — non-nullable (the root
+ *    snapshot always has values, falling back to `initialValues ??
+ *    {}`).
+ *  - **Scoped** (`injectValues(stream, target)`): scoped payloads can
+ *    differ from the root state; callers should annotate the expected
+ *    shape explicitly (`injectValues<SubagentState>(stream, sub)`).
+ *    Defaults to `unknown` when not annotated.
+ */
+declare function injectValues<StateType extends object>(stream: StreamHandle<StateType>): Signal<StateType>;
+declare function injectValues<T>(stream: AnyStream): Signal<InferStateType<T>>;
+declare function injectValues<T = unknown>(stream: AnyStream, target: SelectorTarget | Signal<SelectorTarget>, options?: {
+  messagesKey?: string;
+}): Signal<T | undefined>;
+/**
+ * Subscribe to a `custom:<name>` stream extension — the most recent
+ * payload emitted by the transformer, scoped to the target namespace.
+ */
+declare function injectExtension<T = unknown>(stream: AnyStream, name: string, target?: SelectorTarget | Signal<SelectorTarget>): Signal<T | undefined>;
+/**
+ * Raw-events escape hatch. Subscribes to one or more channels at a
+ * namespace and returns a bounded buffer of raw protocol events.
+ * Prefer {@link injectMessages} / {@link injectToolCalls} /
+ * {@link injectValues} for the common cases.
+ */
+type InjectChannelOptions = ChannelProjectionOptions;
+declare function injectChannel(stream: AnyStream, channels: readonly Channel[], target?: SelectorTarget | Signal<SelectorTarget>, options?: InjectChannelOptions): Signal<Event[]>;
+/**
+ * Subscribe to a scoped audio-media stream. Each handle is yielded
+ * on its first matching `content-block-start`, exposes
+ * `.partialBytes` for live access, settles `.blob` / `.objectURL` /
+ * `.transcript` on `message-finish`, and surfaces errors via
+ * `.error`.
+ *
+ * Pair with `injectMediaUrl` to turn a handle into an `<audio src>`.
+ */
+declare function injectAudio(stream: AnyStream, target?: SelectorTarget | Signal<SelectorTarget>): Signal<AudioMedia[]>;
+/**
+ * Subscribe to a scoped image-media stream. Pair with
+ * `injectMediaUrl` for `<img src>`.
+ */
+declare function injectImages(stream: AnyStream, target?: SelectorTarget | Signal<SelectorTarget>): Signal<ImageMedia[]>;
+/**
+ * Subscribe to a scoped video-media stream. Pair with
+ * `injectMediaUrl` for `<video src>`.
+ */
+declare function injectVideo(stream: AnyStream, target?: SelectorTarget | Signal<SelectorTarget>): Signal<VideoMedia[]>;
+/**
+ * Subscribe to a scoped file-media stream. Pair with
+ * `injectMediaUrl` for an `<a download href>` target.
+ */
+declare function injectFiles(stream: AnyStream, target?: SelectorTarget | Signal<SelectorTarget>): Signal<FileMedia[]>;
+//#endregion
+export { SelectorTarget, injectAudio, injectChannel, injectExtension, injectFiles, injectImages, injectMessages, injectToolCalls, injectValues, injectVideo };
+//# sourceMappingURL=selectors.d.ts.map

package/dist/selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.ts","names":[],"sources":["../src/selectors.ts"],"mappings":";;;;;;;;AA6ByB;;;;KASpB,YAAA,6BAAyC,eAAA,CAC5C,SAAA;;;;;AAoBF;;;;;;;;;KAAY,cAAA;EAIN,SAAA;AAAA,IACF,yBAAA,GACA,yBAAA;;;;;;;;;;;;;;;;iBAgEY,cAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GAAiB,MAAA,CAAO,cAAA,IAChC,MAAA,CAAO,WAAA;;;AAwBV;;;iBAAgB,eAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GAAiB,MAAA,CAAO,cAAA,IAChC,MAAA,CAAO,iBAAA;;;;;;;;;;;;;;;iBAiCM,YAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,MAAA,CAAO,SAAA;AAAA,iBACM,YAAA,GAAA,CAAgB,MAAA,EAAQ,SAAA,GAAY,MAAA,CAAO,cAAA,CAAe,CAAA;AAAA,iBAC1D,YAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,EAAQ,cAAA,GAAiB,MAAA,CAAO,cAAA,GAChC,OAAA;EAAY,WAAA;AAAA,IACX,MAAA,CAAO,CAAA;;;;;iBA2BM,eAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,IAAA,UACA,MAAA,GAAS,cAAA,GAAiB,MAAA,CAAO,cAAA,IAChC,MAAA,CAAO,CAAA;;;;;;;KAmBE,oBAAA,GAAuB,wBAAA;AAAA,iBAEnB,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,QAAA,WAAmB,OAAA,IACnB,MAAA,GAAS,cAAA,GAAiB,MAAA,CAAO,cAAA,GACjC,OAAA,GAAU,oBAAA,GACT,MAAA,CAAO,KAAA;;;AA9DV;;;;;;;iBAwFgB,WAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GAAiB,MAAA,CAAO,cAAA,IAChC,MAAA,CAAO,UAAA;;;;;iBAmBM,YAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GAAiB,MAAA,CAAO,cAAA,IAChC,MAAA,CAAO,UAAA;;;;;iBAmBM,WAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GAAiB,MAAA,CAAO,cAAA,IAChC,MAAA,CAAO,UAAA;;;;;iBAmBM,WAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GAAiB,MAAA,CAAO,cAAA,IAChC,MAAA,CAAO,SAAA"}