@langchain/vue 0.4.7 → 1.0.0

package/dist/selectors.cjs

@@ -0,0 +1,170 @@
+const require_use_stream = require("./use-stream.cjs");
+const require_use_projection = require("./use-projection.cjs");
+let vue = require("vue");
+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);
+}
+/**
+* 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, mount triggers a ref-counted
+*    `messages` subscription scoped to that namespace. The
+*    subscription is released automatically when the calling scope
+*    disappears (and the registry closes the underlying server
+*    subscription when the last consumer leaves).
+*
+* Messages are always `BaseMessage` class instances from
+* `@langchain/core/messages`.
+*/
+function useMessages(stream, target) {
+	const namespace = (0, vue.computed)(() => resolveNamespace((0, vue.toValue)(target)));
+	if (isRoot(namespace.value)) return stream.messages;
+	const key = (0, vue.computed)(() => `messages|${namespaceKey(namespace.value)}`);
+	return require_use_projection.useProjection(require_use_stream.getRegistry(stream), () => (0, _langchain_langgraph_sdk_stream.messagesProjection)(namespace.value), key, EMPTY_MESSAGES);
+}
+const EMPTY_MESSAGES = [];
+/**
+* Subscribe to a scoped `tools` (tool-call) stream. Same target and
+* lifecycle rules as {@link useMessages}; at the root this returns
+* `stream.toolCalls` directly.
+*/
+function useToolCalls(stream, target) {
+	const namespace = (0, vue.computed)(() => resolveNamespace((0, vue.toValue)(target)));
+	if (isRoot(namespace.value)) return stream.toolCalls;
+	const key = (0, vue.computed)(() => `toolCalls|${namespaceKey(namespace.value)}`);
+	return require_use_projection.useProjection(require_use_stream.getRegistry(stream), () => (0, _langchain_langgraph_sdk_stream.toolCallsProjection)(namespace.value), key, EMPTY_TOOLCALLS);
+}
+const EMPTY_TOOLCALLS = [];
+function useValues(stream, target, options) {
+	const namespace = resolveNamespace(target);
+	if (isRoot(namespace)) return stream.values;
+	const messagesKey = options?.messagesKey ?? "messages";
+	const key = `values|${messagesKey}|${namespaceKey(namespace)}`;
+	return require_use_projection.useProjection(require_use_stream.getRegistry(stream), () => (0, _langchain_langgraph_sdk_stream.valuesProjection)(namespace, messagesKey), key, void 0);
+}
+/**
+* Subscribe to a `custom:<name>` stream extension — most-recent
+* payload emitted by the transformer, scoped to the target namespace.
+*/
+function useExtension(stream, name, target) {
+	const namespace = resolveNamespace(target);
+	const key = `extension|${name}|${namespaceKey(namespace)}`;
+	return require_use_projection.useProjection(require_use_stream.getRegistry(stream), () => (0, _langchain_langgraph_sdk_stream.extensionProjection)(name, namespace), key, void 0);
+}
+function useChannel(stream, channels, target, options) {
+	const namespace = resolveNamespace(target);
+	const sortedChannels = [...channels].sort().join(",");
+	const key = `channel|${options?.bufferSize ?? "default"}|${options?.replay ?? true ? "replay" : "live"}|${sortedChannels}|${namespaceKey(namespace)}`;
+	return require_use_projection.useProjection(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`.
+*/
+function useAudio(stream, target) {
+	const namespace = resolveNamespace(target);
+	const key = `audio|${namespaceKey(namespace)}`;
+	return require_use_projection.useProjection(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
+* {@link useMediaURL} for `<img src>`.
+*/
+function useImages(stream, target) {
+	const namespace = resolveNamespace(target);
+	const key = `images|${namespaceKey(namespace)}`;
+	return require_use_projection.useProjection(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
+* {@link useMediaURL} for `<video src>`.
+*/
+function useVideo(stream, target) {
+	const namespace = resolveNamespace(target);
+	const key = `video|${namespaceKey(namespace)}`;
+	return require_use_projection.useProjection(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
+* {@link useMediaURL} for an `<a download href>` target.
+*/
+function useFiles(stream, target) {
+	const namespace = resolveNamespace(target);
+	const key = `files|${namespaceKey(namespace)}`;
+	return require_use_projection.useProjection(require_use_stream.getRegistry(stream), () => (0, _langchain_langgraph_sdk_stream.filesProjection)(namespace), key, EMPTY_FILES);
+}
+const EMPTY_FILES = [];
+/**
+* Read metadata recorded for a specific message id — today exposes
+* `parentCheckpointId`, the checkpoint the message was first seen on.
+* Designed for fork / edit flows:
+*
+* ```ts
+* const meta = useMessageMetadata(stream, () => msg.id);
+* // meta.value?.parentCheckpointId
+* ```
+*
+* `messageId` accepts a raw string, a `Ref<string | undefined>`, or
+* a getter — the binding re-evaluates whenever the id changes.
+*/
+function useMessageMetadata(stream, messageId) {
+	const store = stream[require_use_stream.STREAM_CONTROLLER].messageMetadataStore;
+	const mapRef = (0, vue.shallowRef)(store.getSnapshot());
+	(0, vue.onScopeDispose)(store.subscribe(() => {
+		mapRef.value = store.getSnapshot();
+	}));
+	return (0, vue.computed)(() => {
+		const key = (0, vue.toValue)(messageId);
+		if (key == null) return void 0;
+		return mapRef.value.get(key);
+	});
+}
+function useSubmissionQueue(stream) {
+	const controller = stream[require_use_stream.STREAM_CONTROLLER];
+	const store = controller.queueStore;
+	const entries = (0, vue.shallowRef)(store.getSnapshot());
+	(0, vue.onScopeDispose)(store.subscribe(() => {
+		entries.value = store.getSnapshot();
+	}));
+	return {
+		entries: (0, vue.readonly)(entries),
+		size: (0, vue.computed)(() => entries.value.length),
+		cancel: (id) => controller.cancelQueued(id),
+		clear: () => controller.clearQueue()
+	};
+}
+//#endregion
+exports.useAudio = useAudio;
+exports.useChannel = useChannel;
+exports.useExtension = useExtension;
+exports.useFiles = useFiles;
+exports.useImages = useImages;
+exports.useMessageMetadata = useMessageMetadata;
+exports.useMessages = useMessages;
+exports.useSubmissionQueue = useSubmissionQueue;
+exports.useToolCalls = useToolCalls;
+exports.useValues = useValues;
+exports.useVideo = useVideo;
+
+//# sourceMappingURL=selectors.cjs.map

package/dist/selectors.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.cjs","names":["NAMESPACE_SEPARATOR","useProjection","getRegistry","STREAM_CONTROLLER"],"sources":["../src/selectors.ts"],"sourcesContent":["import {\n  computed,\n  onScopeDispose,\n  readonly,\n  shallowRef,\n  toValue,\n  type ComputedRef,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n} from \"vue\";\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 MessageMetadata,\n  type MessageMetadataMap,\n  type SubagentDiscoverySnapshot,\n  type SubgraphDiscoverySnapshot,\n  type SubmissionQueueEntry,\n  type SubmissionQueueSnapshot,\n  type VideoMedia,\n} from \"@langchain/langgraph-sdk/stream\";\nimport {\n  getRegistry,\n  STREAM_CONTROLLER,\n  type AnyStream,\n  type UseStreamReturn,\n} from \"./use-stream.js\";\nimport { useProjection } from \"./use-projection.js\";\n\n/**\n * Selector composables don't need to carry `InterruptType` /\n * `ConfigurableType`. Parameterising on `StateType` alone lets\n * callers with a full `useStream<S, I, C>()` handle pass it in without\n * redeclaring those generics at every call site.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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 composable 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.value.get(...)`);\n *  - a {@link SubgraphDiscoverySnapshot} (`stream.subgraphs.value.get(...)`);\n *  - an explicit `{ namespace: string[] }`;\n *  - a raw `string[]` escape hatch.\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 * 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, mount triggers a ref-counted\n *    `messages` subscription scoped to that namespace. The\n *    subscription is released automatically when the calling scope\n *    disappears (and the registry closes the underlying server\n *    subscription when the last consumer leaves).\n *\n * Messages are always `BaseMessage` class instances from\n * `@langchain/core/messages`.\n */\nexport function useMessages(\n  stream: AnyStream,\n  target?: MaybeRefOrGetter<SelectorTarget>\n): Readonly<ShallowRef<BaseMessage[]>> {\n  const namespace = computed(() => resolveNamespace(toValue(target)));\n  if (isRoot(namespace.value)) return stream.messages;\n  const key = computed(() => `messages|${namespaceKey(namespace.value)}`);\n  return useProjection<BaseMessage[]>(\n    getRegistry(stream),\n    () => messagesProjection(namespace.value),\n    key,\n    EMPTY_MESSAGES\n  );\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 useMessages}; at the root this returns\n * `stream.toolCalls` directly.\n */\nexport function useToolCalls(\n  stream: AnyStream,\n  target?: MaybeRefOrGetter<SelectorTarget>\n): Readonly<ShallowRef<AssembledToolCall[]>> {\n  const namespace = computed(() => resolveNamespace(toValue(target)));\n  if (isRoot(namespace.value)) return stream.toolCalls;\n  const key = computed(() => `toolCalls|${namespaceKey(namespace.value)}`);\n  return useProjection<AssembledToolCall[]>(\n    getRegistry(stream),\n    () => toolCallsProjection(namespace.value),\n    key,\n    EMPTY_TOOLCALLS\n  );\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** (`useValues(stream)`): returns the `StateType` declared\n *    on `useStream<State>()` — non-nullable (the root snapshot always\n *    has values, falling back to `initialValues ?? {}`).\n *  - **Scoped** (`useValues(stream, target)`): scoped payloads can\n *    differ from the root state; callers should annotate the\n *    expected shape explicitly (`useValues<SubagentState>(stream,\n *    sub)`). Defaults to `unknown` when not annotated.\n */\nexport function useValues<StateType extends object>(\n  stream: StreamHandle<StateType>\n): Readonly<ShallowRef<StateType>>;\nexport function useValues<T>(\n  stream: AnyStream\n): Readonly<ShallowRef<InferStateType<T>>>;\nexport function useValues<T = unknown>(\n  stream: AnyStream,\n  target: SelectorTarget,\n  options?: { messagesKey?: string }\n): Readonly<ShallowRef<T | undefined>>;\nexport function useValues(\n  stream: AnyStream,\n  target?: SelectorTarget,\n  options?: { messagesKey?: string }\n): Readonly<ShallowRef<unknown>> {\n  const namespace = resolveNamespace(target);\n  if (isRoot(namespace)) return stream.values as Readonly<ShallowRef<unknown>>;\n  const messagesKey = options?.messagesKey ?? \"messages\";\n  const key = `values|${messagesKey}|${namespaceKey(namespace)}`;\n  return useProjection<unknown>(\n    getRegistry(stream),\n    () => valuesProjection<unknown>(namespace, messagesKey),\n    key,\n    undefined\n  );\n}\n\n/**\n * Subscribe to a `custom:<name>` stream extension — most-recent\n * payload emitted by the transformer, scoped to the target namespace.\n */\nexport function useExtension<T = unknown>(\n  stream: AnyStream,\n  name: string,\n  target?: SelectorTarget\n): Readonly<ShallowRef<T | undefined>> {\n  const namespace = resolveNamespace(target);\n  const key = `extension|${name}|${namespaceKey(namespace)}`;\n  return useProjection<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 useMessages} / {@link useToolCalls} / {@link useValues}\n * for the common cases.\n */\nexport type UseChannelOptions = ChannelProjectionOptions;\n\nexport function useChannel(\n  stream: AnyStream,\n  channels: readonly Channel[],\n  target?: SelectorTarget,\n  options?: UseChannelOptions\n): Readonly<ShallowRef<Event[]>> {\n  const namespace = resolveNamespace(target);\n  const sortedChannels = [...channels].sort().join(\",\");\n  const key = `channel|${options?.bufferSize ?? \"default\"}|${(options?.replay ?? true) ? \"replay\" : \"live\"}|${sortedChannels}|${namespaceKey(namespace)}`;\n  return useProjection<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 */\nexport function useAudio(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<AudioMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `audio|${namespaceKey(namespace)}`;\n  return useProjection<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 * {@link useMediaURL} for `<img src>`.\n */\nexport function useImages(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<ImageMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `images|${namespaceKey(namespace)}`;\n  return useProjection<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 * {@link useMediaURL} for `<video src>`.\n */\nexport function useVideo(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<VideoMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `video|${namespaceKey(namespace)}`;\n  return useProjection<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 * {@link useMediaURL} for an `<a download href>` target.\n */\nexport function useFiles(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<FileMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `files|${namespaceKey(namespace)}`;\n  return useProjection<FileMedia[]>(\n    getRegistry(stream),\n    () => filesProjection(namespace),\n    key,\n    EMPTY_FILES\n  );\n}\n\nconst EMPTY_FILES: FileMedia[] = [];\n\n/**\n * Read metadata recorded for a specific message id — today exposes\n * `parentCheckpointId`, the checkpoint the message was first seen on.\n * Designed for fork / edit flows:\n *\n * ```ts\n * const meta = useMessageMetadata(stream, () => msg.id);\n * // meta.value?.parentCheckpointId\n * ```\n *\n * `messageId` accepts a raw string, a `Ref<string | undefined>`, or\n * a getter — the binding re-evaluates whenever the id changes.\n */\nexport function useMessageMetadata(\n  stream: AnyStream,\n  messageId: MaybeRefOrGetter<string | undefined>\n): ComputedRef<MessageMetadata | undefined> {\n  const store = stream[STREAM_CONTROLLER].messageMetadataStore;\n  const mapRef = shallowRef<MessageMetadataMap>(store.getSnapshot());\n  const unsubscribe = store.subscribe(() => {\n    mapRef.value = store.getSnapshot();\n  });\n  onScopeDispose(unsubscribe);\n\n  return computed<MessageMetadata | undefined>(() => {\n    const key = toValue(messageId);\n    if (key == null) return undefined;\n    return mapRef.value.get(key);\n  });\n}\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 refs are shared per call — safe to pass into `v-for`.\n */\nexport interface UseSubmissionQueueReturn<\n  StateType extends object = Record<string, unknown>,\n> {\n  readonly entries: Readonly<ShallowRef<SubmissionQueueSnapshot<StateType>>>;\n  readonly size: ComputedRef<number>;\n  cancel(id: string): Promise<boolean>;\n  clear(): Promise<void>;\n}\n\nexport function useSubmissionQueue<StateType extends object>(\n  stream: StreamHandle<StateType>\n): UseSubmissionQueueReturn<StateType>;\nexport function useSubmissionQueue(stream: AnyStream): UseSubmissionQueueReturn;\nexport function useSubmissionQueue(\n  stream: AnyStream\n): UseSubmissionQueueReturn {\n  const controller = stream[STREAM_CONTROLLER];\n  const store = controller.queueStore;\n  const entries = shallowRef<SubmissionQueueSnapshot>(store.getSnapshot());\n  const unsubscribe = store.subscribe(() => {\n    entries.value = store.getSnapshot();\n  });\n  onScopeDispose(unsubscribe);\n\n  return {\n    entries: readonly(entries) as Readonly<ShallowRef<SubmissionQueueSnapshot>>,\n    size: computed(() => entries.value.length),\n    cancel: (id) => controller.cancelQueued(id),\n    clear: () => controller.clearQueue(),\n  };\n}\n\nexport type { SubmissionQueueEntry, SubmissionQueueSnapshot };\n"],"mappings":"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"}

package/dist/selectors.d.cts

@@ -0,0 +1,133 @@
+import { AnyStream, UseStreamReturn } from "./use-stream.cjs";
+import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
+import { BaseMessage } from "@langchain/core/messages";
+import { AssembledToolCall, AudioMedia, Channel, ChannelProjectionOptions, Event, FileMedia, ImageMedia, InferStateType, MessageMetadata, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, SubmissionQueueEntry, SubmissionQueueSnapshot, VideoMedia } from "@langchain/langgraph-sdk/stream";
+
+//#region src/selectors.d.ts
+/**
+ * Selector composables don't need to carry `InterruptType` /
+ * `ConfigurableType`. Parameterising on `StateType` alone lets
+ * callers with a full `useStream<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 composable 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.value.get(...)`);
+ *  - a {@link SubgraphDiscoverySnapshot} (`stream.subgraphs.value.get(...)`);
+ *  - an explicit `{ namespace: string[] }`;
+ *  - a raw `string[]` escape hatch.
+ */
+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, mount triggers a ref-counted
+ *    `messages` subscription scoped to that namespace. The
+ *    subscription is released automatically when the calling scope
+ *    disappears (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 useMessages(stream: AnyStream, target?: MaybeRefOrGetter<SelectorTarget>): Readonly<ShallowRef<BaseMessage[]>>;
+/**
+ * Subscribe to a scoped `tools` (tool-call) stream. Same target and
+ * lifecycle rules as {@link useMessages}; at the root this returns
+ * `stream.toolCalls` directly.
+ */
+declare function useToolCalls(stream: AnyStream, target?: MaybeRefOrGetter<SelectorTarget>): Readonly<ShallowRef<AssembledToolCall[]>>;
+/**
+ * Subscribe to a scoped `values` stream — the most recent state
+ * payload for a namespace. At the root returns `stream.values`.
+ *
+ * Typing:
+ *  - **Root** (`useValues(stream)`): returns the `StateType` declared
+ *    on `useStream<State>()` — non-nullable (the root snapshot always
+ *    has values, falling back to `initialValues ?? {}`).
+ *  - **Scoped** (`useValues(stream, target)`): scoped payloads can
+ *    differ from the root state; callers should annotate the
+ *    expected shape explicitly (`useValues<SubagentState>(stream,
+ *    sub)`). Defaults to `unknown` when not annotated.
+ */
+declare function useValues<StateType extends object>(stream: StreamHandle<StateType>): Readonly<ShallowRef<StateType>>;
+declare function useValues<T>(stream: AnyStream): Readonly<ShallowRef<InferStateType<T>>>;
+declare function useValues<T = unknown>(stream: AnyStream, target: SelectorTarget, options?: {
+  messagesKey?: string;
+}): Readonly<ShallowRef<T | undefined>>;
+/**
+ * Subscribe to a `custom:<name>` stream extension — most-recent
+ * payload emitted by the transformer, scoped to the target namespace.
+ */
+declare function useExtension<T = unknown>(stream: AnyStream, name: string, target?: SelectorTarget): Readonly<ShallowRef<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 useMessages} / {@link useToolCalls} / {@link useValues}
+ * for the common cases.
+ */
+type UseChannelOptions = ChannelProjectionOptions;
+declare function useChannel(stream: AnyStream, channels: readonly Channel[], target?: SelectorTarget, options?: UseChannelOptions): Readonly<ShallowRef<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`.
+ */
+declare function useAudio(stream: AnyStream, target?: SelectorTarget): Readonly<ShallowRef<AudioMedia[]>>;
+/**
+ * Subscribe to a scoped image-media stream. Pair with
+ * {@link useMediaURL} for `<img src>`.
+ */
+declare function useImages(stream: AnyStream, target?: SelectorTarget): Readonly<ShallowRef<ImageMedia[]>>;
+/**
+ * Subscribe to a scoped video-media stream. Pair with
+ * {@link useMediaURL} for `<video src>`.
+ */
+declare function useVideo(stream: AnyStream, target?: SelectorTarget): Readonly<ShallowRef<VideoMedia[]>>;
+/**
+ * Subscribe to a scoped file-media stream. Pair with
+ * {@link useMediaURL} for an `<a download href>` target.
+ */
+declare function useFiles(stream: AnyStream, target?: SelectorTarget): Readonly<ShallowRef<FileMedia[]>>;
+/**
+ * Read metadata recorded for a specific message id — today exposes
+ * `parentCheckpointId`, the checkpoint the message was first seen on.
+ * Designed for fork / edit flows:
+ *
+ * ```ts
+ * const meta = useMessageMetadata(stream, () => msg.id);
+ * // meta.value?.parentCheckpointId
+ * ```
+ *
+ * `messageId` accepts a raw string, a `Ref<string | undefined>`, or
+ * a getter — the binding re-evaluates whenever the id changes.
+ */
+declare function useMessageMetadata(stream: AnyStream, messageId: MaybeRefOrGetter<string | undefined>): ComputedRef<MessageMetadata | undefined>;
+/**
+ * Reactive handle on the server-side submission queue.
+ *
+ * Populated when `submit()` is invoked with
+ * `multitaskStrategy: "enqueue"` while another run is in flight. The
+ * returned refs are shared per call — safe to pass into `v-for`.
+ */
+interface UseSubmissionQueueReturn<StateType extends object = Record<string, unknown>> {
+  readonly entries: Readonly<ShallowRef<SubmissionQueueSnapshot<StateType>>>;
+  readonly size: ComputedRef<number>;
+  cancel(id: string): Promise<boolean>;
+  clear(): Promise<void>;
+}
+declare function useSubmissionQueue<StateType extends object>(stream: StreamHandle<StateType>): UseSubmissionQueueReturn<StateType>;
+declare function useSubmissionQueue(stream: AnyStream): UseSubmissionQueueReturn;
+//#endregion
+export { SelectorTarget, type SubmissionQueueEntry, type SubmissionQueueSnapshot, UseSubmissionQueueReturn, useAudio, useChannel, useExtension, useFiles, useImages, useMessageMetadata, useMessages, useSubmissionQueue, useToolCalls, useValues, useVideo };
+//# 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":";;;;;;;;AA2CyB;;;;KAUpB,YAAA,6BAAyC,eAAA,CAC5C,SAAA;;;;;AAgBF;;;;;KAAY,cAAA;EAIN,SAAA;AAAA,IACF,yBAAA,GACA,yBAAA;;AAkCJ;;;;;;;;;;;;;;iBAAgB,WAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,gBAAA,CAAiB,cAAA,IACzB,QAAA,CAAS,UAAA,CAAW,WAAA;;;;;;iBAmBP,YAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,gBAAA,CAAiB,cAAA,IACzB,QAAA,CAAS,UAAA,CAAW,iBAAA;AAHvB;;;;;;;;;;;;;AAAA,iBA8BgB,SAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,QAAA,CAAS,UAAA,CAAW,SAAA;AAAA,iBACP,SAAA,GAAA,CACd,MAAA,EAAQ,SAAA,GACP,QAAA,CAAS,UAAA,CAAW,cAAA,CAAe,CAAA;AAAA,iBACtB,SAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,EAAQ,cAAA,EACR,OAAA;EAAY,WAAA;AAAA,IACX,QAAA,CAAS,UAAA,CAAW,CAAA;;;;AAVvB;iBAgCgB,YAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,IAAA,UACA,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,CAAA;;;;;;;KAiBX,iBAAA,GAAoB,wBAAA;AAAA,iBAEhB,UAAA,CACd,MAAA,EAAQ,SAAA,EACR,QAAA,WAAmB,OAAA,IACnB,MAAA,GAAS,cAAA,EACT,OAAA,GAAU,iBAAA,GACT,QAAA,CAAS,UAAA,CAAW,KAAA;;;;;;;;iBAqBP,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;;AAjFvB;;;iBAkGgB,SAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;;;;;iBAiBP,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;;;;;iBAiBP,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,SAAA;;;;;;AA1IvB;;;;;;;;iBAoKgB,kBAAA,CACd,MAAA,EAAQ,SAAA,EACR,SAAA,EAAW,gBAAA,uBACV,WAAA,CAAY,eAAA;;;;;;;;UAsBE,wBAAA,4BACY,MAAA;EAAA,SAElB,OAAA,EAAS,QAAA,CAAS,UAAA,CAAW,uBAAA,CAAwB,SAAA;EAAA,SACrD,IAAA,EAAM,WAAA;EACf,MAAA,CAAO,EAAA,WAAa,OAAA;EACpB,KAAA,IAAS,OAAA;AAAA;AAAA,iBAGK,kBAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,wBAAA,CAAyB,SAAA;AAAA,iBACZ,kBAAA,CAAmB,MAAA,EAAQ,SAAA,GAAY,wBAAA"}

package/dist/selectors.d.ts

@@ -0,0 +1,133 @@
+import { AnyStream, UseStreamReturn } from "./use-stream.js";
+import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
+import { AssembledToolCall, AudioMedia, Channel, ChannelProjectionOptions, Event, FileMedia, ImageMedia, InferStateType, MessageMetadata, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, SubmissionQueueEntry, SubmissionQueueSnapshot, VideoMedia } from "@langchain/langgraph-sdk/stream";
+import { BaseMessage } from "@langchain/core/messages";
+
+//#region src/selectors.d.ts
+/**
+ * Selector composables don't need to carry `InterruptType` /
+ * `ConfigurableType`. Parameterising on `StateType` alone lets
+ * callers with a full `useStream<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 composable 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.value.get(...)`);
+ *  - a {@link SubgraphDiscoverySnapshot} (`stream.subgraphs.value.get(...)`);
+ *  - an explicit `{ namespace: string[] }`;
+ *  - a raw `string[]` escape hatch.
+ */
+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, mount triggers a ref-counted
+ *    `messages` subscription scoped to that namespace. The
+ *    subscription is released automatically when the calling scope
+ *    disappears (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 useMessages(stream: AnyStream, target?: MaybeRefOrGetter<SelectorTarget>): Readonly<ShallowRef<BaseMessage[]>>;
+/**
+ * Subscribe to a scoped `tools` (tool-call) stream. Same target and
+ * lifecycle rules as {@link useMessages}; at the root this returns
+ * `stream.toolCalls` directly.
+ */
+declare function useToolCalls(stream: AnyStream, target?: MaybeRefOrGetter<SelectorTarget>): Readonly<ShallowRef<AssembledToolCall[]>>;
+/**
+ * Subscribe to a scoped `values` stream — the most recent state
+ * payload for a namespace. At the root returns `stream.values`.
+ *
+ * Typing:
+ *  - **Root** (`useValues(stream)`): returns the `StateType` declared
+ *    on `useStream<State>()` — non-nullable (the root snapshot always
+ *    has values, falling back to `initialValues ?? {}`).
+ *  - **Scoped** (`useValues(stream, target)`): scoped payloads can
+ *    differ from the root state; callers should annotate the
+ *    expected shape explicitly (`useValues<SubagentState>(stream,
+ *    sub)`). Defaults to `unknown` when not annotated.
+ */
+declare function useValues<StateType extends object>(stream: StreamHandle<StateType>): Readonly<ShallowRef<StateType>>;
+declare function useValues<T>(stream: AnyStream): Readonly<ShallowRef<InferStateType<T>>>;
+declare function useValues<T = unknown>(stream: AnyStream, target: SelectorTarget, options?: {
+  messagesKey?: string;
+}): Readonly<ShallowRef<T | undefined>>;
+/**
+ * Subscribe to a `custom:<name>` stream extension — most-recent
+ * payload emitted by the transformer, scoped to the target namespace.
+ */
+declare function useExtension<T = unknown>(stream: AnyStream, name: string, target?: SelectorTarget): Readonly<ShallowRef<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 useMessages} / {@link useToolCalls} / {@link useValues}
+ * for the common cases.
+ */
+type UseChannelOptions = ChannelProjectionOptions;
+declare function useChannel(stream: AnyStream, channels: readonly Channel[], target?: SelectorTarget, options?: UseChannelOptions): Readonly<ShallowRef<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`.
+ */
+declare function useAudio(stream: AnyStream, target?: SelectorTarget): Readonly<ShallowRef<AudioMedia[]>>;
+/**
+ * Subscribe to a scoped image-media stream. Pair with
+ * {@link useMediaURL} for `<img src>`.
+ */
+declare function useImages(stream: AnyStream, target?: SelectorTarget): Readonly<ShallowRef<ImageMedia[]>>;
+/**
+ * Subscribe to a scoped video-media stream. Pair with
+ * {@link useMediaURL} for `<video src>`.
+ */
+declare function useVideo(stream: AnyStream, target?: SelectorTarget): Readonly<ShallowRef<VideoMedia[]>>;
+/**
+ * Subscribe to a scoped file-media stream. Pair with
+ * {@link useMediaURL} for an `<a download href>` target.
+ */
+declare function useFiles(stream: AnyStream, target?: SelectorTarget): Readonly<ShallowRef<FileMedia[]>>;
+/**
+ * Read metadata recorded for a specific message id — today exposes
+ * `parentCheckpointId`, the checkpoint the message was first seen on.
+ * Designed for fork / edit flows:
+ *
+ * ```ts
+ * const meta = useMessageMetadata(stream, () => msg.id);
+ * // meta.value?.parentCheckpointId
+ * ```
+ *
+ * `messageId` accepts a raw string, a `Ref<string | undefined>`, or
+ * a getter — the binding re-evaluates whenever the id changes.
+ */
+declare function useMessageMetadata(stream: AnyStream, messageId: MaybeRefOrGetter<string | undefined>): ComputedRef<MessageMetadata | undefined>;
+/**
+ * Reactive handle on the server-side submission queue.
+ *
+ * Populated when `submit()` is invoked with
+ * `multitaskStrategy: "enqueue"` while another run is in flight. The
+ * returned refs are shared per call — safe to pass into `v-for`.
+ */
+interface UseSubmissionQueueReturn<StateType extends object = Record<string, unknown>> {
+  readonly entries: Readonly<ShallowRef<SubmissionQueueSnapshot<StateType>>>;
+  readonly size: ComputedRef<number>;
+  cancel(id: string): Promise<boolean>;
+  clear(): Promise<void>;
+}
+declare function useSubmissionQueue<StateType extends object>(stream: StreamHandle<StateType>): UseSubmissionQueueReturn<StateType>;
+declare function useSubmissionQueue(stream: AnyStream): UseSubmissionQueueReturn;
+//#endregion
+export { SelectorTarget, type SubmissionQueueEntry, type SubmissionQueueSnapshot, UseSubmissionQueueReturn, useAudio, useChannel, useExtension, useFiles, useImages, useMessageMetadata, useMessages, useSubmissionQueue, useToolCalls, useValues, useVideo };
+//# 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":";;;;;;;;AA2CyB;;;;KAUpB,YAAA,6BAAyC,eAAA,CAC5C,SAAA;;;;;AAgBF;;;;;KAAY,cAAA;EAIN,SAAA;AAAA,IACF,yBAAA,GACA,yBAAA;;AAkCJ;;;;;;;;;;;;;;iBAAgB,WAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,gBAAA,CAAiB,cAAA,IACzB,QAAA,CAAS,UAAA,CAAW,WAAA;;;;;;iBAmBP,YAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,gBAAA,CAAiB,cAAA,IACzB,QAAA,CAAS,UAAA,CAAW,iBAAA;AAHvB;;;;;;;;;;;;;AAAA,iBA8BgB,SAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,QAAA,CAAS,UAAA,CAAW,SAAA;AAAA,iBACP,SAAA,GAAA,CACd,MAAA,EAAQ,SAAA,GACP,QAAA,CAAS,UAAA,CAAW,cAAA,CAAe,CAAA;AAAA,iBACtB,SAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,EAAQ,cAAA,EACR,OAAA;EAAY,WAAA;AAAA,IACX,QAAA,CAAS,UAAA,CAAW,CAAA;;;;AAVvB;iBAgCgB,YAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,IAAA,UACA,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,CAAA;;;;;;;KAiBX,iBAAA,GAAoB,wBAAA;AAAA,iBAEhB,UAAA,CACd,MAAA,EAAQ,SAAA,EACR,QAAA,WAAmB,OAAA,IACnB,MAAA,GAAS,cAAA,EACT,OAAA,GAAU,iBAAA,GACT,QAAA,CAAS,UAAA,CAAW,KAAA;;;;;;;;iBAqBP,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;;AAjFvB;;;iBAkGgB,SAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;;;;;iBAiBP,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;;;;;iBAiBP,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,SAAA;;;;;;AA1IvB;;;;;;;;iBAoKgB,kBAAA,CACd,MAAA,EAAQ,SAAA,EACR,SAAA,EAAW,gBAAA,uBACV,WAAA,CAAY,eAAA;;;;;;;;UAsBE,wBAAA,4BACY,MAAA;EAAA,SAElB,OAAA,EAAS,QAAA,CAAS,UAAA,CAAW,uBAAA,CAAwB,SAAA;EAAA,SACrD,IAAA,EAAM,WAAA;EACf,MAAA,CAAO,EAAA,WAAa,OAAA;EACpB,KAAA,IAAS,OAAA;AAAA;AAAA,iBAGK,kBAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,wBAAA,CAAyB,SAAA;AAAA,iBACZ,kBAAA,CAAmB,MAAA,EAAQ,SAAA,GAAY,wBAAA"}

package/dist/selectors.js

@@ -0,0 +1,160 @@
+import { STREAM_CONTROLLER, getRegistry } from "./use-stream.js";
+import { useProjection } from "./use-projection.js";
+import { computed, onScopeDispose, readonly, shallowRef, toValue } from "vue";
+import { NAMESPACE_SEPARATOR, audioProjection, channelProjection, extensionProjection, filesProjection, imagesProjection, messagesProjection, toolCallsProjection, valuesProjection, videoProjection } from "@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(NAMESPACE_SEPARATOR);
+}
+/**
+* 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, mount triggers a ref-counted
+*    `messages` subscription scoped to that namespace. The
+*    subscription is released automatically when the calling scope
+*    disappears (and the registry closes the underlying server
+*    subscription when the last consumer leaves).
+*
+* Messages are always `BaseMessage` class instances from
+* `@langchain/core/messages`.
+*/
+function useMessages(stream, target) {
+	const namespace = computed(() => resolveNamespace(toValue(target)));
+	if (isRoot(namespace.value)) return stream.messages;
+	const key = computed(() => `messages|${namespaceKey(namespace.value)}`);
+	return useProjection(getRegistry(stream), () => messagesProjection(namespace.value), key, EMPTY_MESSAGES);
+}
+const EMPTY_MESSAGES = [];
+/**
+* Subscribe to a scoped `tools` (tool-call) stream. Same target and
+* lifecycle rules as {@link useMessages}; at the root this returns
+* `stream.toolCalls` directly.
+*/
+function useToolCalls(stream, target) {
+	const namespace = computed(() => resolveNamespace(toValue(target)));
+	if (isRoot(namespace.value)) return stream.toolCalls;
+	const key = computed(() => `toolCalls|${namespaceKey(namespace.value)}`);
+	return useProjection(getRegistry(stream), () => toolCallsProjection(namespace.value), key, EMPTY_TOOLCALLS);
+}
+const EMPTY_TOOLCALLS = [];
+function useValues(stream, target, options) {
+	const namespace = resolveNamespace(target);
+	if (isRoot(namespace)) return stream.values;
+	const messagesKey = options?.messagesKey ?? "messages";
+	const key = `values|${messagesKey}|${namespaceKey(namespace)}`;
+	return useProjection(getRegistry(stream), () => valuesProjection(namespace, messagesKey), key, void 0);
+}
+/**
+* Subscribe to a `custom:<name>` stream extension — most-recent
+* payload emitted by the transformer, scoped to the target namespace.
+*/
+function useExtension(stream, name, target) {
+	const namespace = resolveNamespace(target);
+	const key = `extension|${name}|${namespaceKey(namespace)}`;
+	return useProjection(getRegistry(stream), () => extensionProjection(name, namespace), key, void 0);
+}
+function useChannel(stream, channels, target, options) {
+	const namespace = resolveNamespace(target);
+	const sortedChannels = [...channels].sort().join(",");
+	const key = `channel|${options?.bufferSize ?? "default"}|${options?.replay ?? true ? "replay" : "live"}|${sortedChannels}|${namespaceKey(namespace)}`;
+	return useProjection(getRegistry(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`.
+*/
+function useAudio(stream, target) {
+	const namespace = resolveNamespace(target);
+	const key = `audio|${namespaceKey(namespace)}`;
+	return useProjection(getRegistry(stream), () => audioProjection(namespace), key, EMPTY_AUDIO);
+}
+const EMPTY_AUDIO = [];
+/**
+* Subscribe to a scoped image-media stream. Pair with
+* {@link useMediaURL} for `<img src>`.
+*/
+function useImages(stream, target) {
+	const namespace = resolveNamespace(target);
+	const key = `images|${namespaceKey(namespace)}`;
+	return useProjection(getRegistry(stream), () => imagesProjection(namespace), key, EMPTY_IMAGES);
+}
+const EMPTY_IMAGES = [];
+/**
+* Subscribe to a scoped video-media stream. Pair with
+* {@link useMediaURL} for `<video src>`.
+*/
+function useVideo(stream, target) {
+	const namespace = resolveNamespace(target);
+	const key = `video|${namespaceKey(namespace)}`;
+	return useProjection(getRegistry(stream), () => videoProjection(namespace), key, EMPTY_VIDEO);
+}
+const EMPTY_VIDEO = [];
+/**
+* Subscribe to a scoped file-media stream. Pair with
+* {@link useMediaURL} for an `<a download href>` target.
+*/
+function useFiles(stream, target) {
+	const namespace = resolveNamespace(target);
+	const key = `files|${namespaceKey(namespace)}`;
+	return useProjection(getRegistry(stream), () => filesProjection(namespace), key, EMPTY_FILES);
+}
+const EMPTY_FILES = [];
+/**
+* Read metadata recorded for a specific message id — today exposes
+* `parentCheckpointId`, the checkpoint the message was first seen on.
+* Designed for fork / edit flows:
+*
+* ```ts
+* const meta = useMessageMetadata(stream, () => msg.id);
+* // meta.value?.parentCheckpointId
+* ```
+*
+* `messageId` accepts a raw string, a `Ref<string | undefined>`, or
+* a getter — the binding re-evaluates whenever the id changes.
+*/
+function useMessageMetadata(stream, messageId) {
+	const store = stream[STREAM_CONTROLLER].messageMetadataStore;
+	const mapRef = shallowRef(store.getSnapshot());
+	onScopeDispose(store.subscribe(() => {
+		mapRef.value = store.getSnapshot();
+	}));
+	return computed(() => {
+		const key = toValue(messageId);
+		if (key == null) return void 0;
+		return mapRef.value.get(key);
+	});
+}
+function useSubmissionQueue(stream) {
+	const controller = stream[STREAM_CONTROLLER];
+	const store = controller.queueStore;
+	const entries = shallowRef(store.getSnapshot());
+	onScopeDispose(store.subscribe(() => {
+		entries.value = store.getSnapshot();
+	}));
+	return {
+		entries: readonly(entries),
+		size: computed(() => entries.value.length),
+		cancel: (id) => controller.cancelQueued(id),
+		clear: () => controller.clearQueue()
+	};
+}
+//#endregion
+export { useAudio, useChannel, useExtension, useFiles, useImages, useMessageMetadata, useMessages, useSubmissionQueue, useToolCalls, useValues, useVideo };
+
+//# sourceMappingURL=selectors.js.map