@langchain/angular 0.4.7 → 1.0.1

package/dist/inject-media-url.js

@@ -0,0 +1,54 @@
+import { effect, isSignal, signal, untracked } from "@angular/core";
+//#region src/inject-media-url.ts
+/**
+* Resolve the lazy {@link MediaBase.objectURL} promise into a string
+* suitable for direct use in `<audio src>` / `<img src>` /
+* `<video src>` / `<a href download>`. Returns `undefined` until the
+* URL is available.
+*
+* Lifecycle:
+*  - On first read (or when `media` changes) the helper awaits
+*    `media.objectURL`, then commits the resolved string to the
+*    returned signal.
+*  - On destroy (or when `media` changes) the helper calls
+*    `media.revoke()` to free the object URL slot. The next consumer
+*    that accesses `media.objectURL` mints a fresh URL from the same
+*    `Blob`, so live re-renders just work.
+*  - If the underlying handle errored before settling, the promise
+*    rejects and `injectMediaUrl` stays at `undefined`. Inspect
+*    `media.error` to surface the failure.
+*
+* Pair with {@link injectAudio} / {@link injectImages} /
+* {@link injectVideo} / {@link injectFiles} to bridge SDK media
+* handles into Angular templates without manual
+* `URL.createObjectURL` bookkeeping.
+*
+* `media` accepts a plain handle or a `Signal<MediaBase | undefined>`
+* so callers can feed a `computed(() => stream.audio()[0])`.
+*/
+function injectMediaUrl(media) {
+	const url = signal(void 0);
+	const read = isSignal(media) ? media : () => media;
+	effect((onCleanup) => {
+		const next = read();
+		untracked(() => {
+			url.set(void 0);
+			if (next == null) return;
+			let cancelled = false;
+			next.objectURL.then((resolved) => {
+				if (!cancelled) url.set(resolved);
+			}, () => {});
+			onCleanup(() => {
+				cancelled = true;
+				try {
+					next.revoke();
+				} catch {}
+			});
+		});
+	});
+	return url;
+}
+//#endregion
+export { injectMediaUrl };
+
+//# sourceMappingURL=inject-media-url.js.map

package/dist/inject-media-url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-media-url.js","names":[],"sources":["../src/inject-media-url.ts"],"sourcesContent":["import {\n  effect,\n  isSignal,\n  signal,\n  untracked,\n  type Signal,\n} from \"@angular/core\";\nimport type { MediaBase } from \"@langchain/langgraph-sdk/stream\";\n\n/**\n * Resolve the lazy {@link MediaBase.objectURL} promise into a string\n * suitable for direct use in `<audio src>` / `<img src>` /\n * `<video src>` / `<a href download>`. Returns `undefined` until the\n * URL is available.\n *\n * Lifecycle:\n *  - On first read (or when `media` changes) the helper awaits\n *    `media.objectURL`, then commits the resolved string to the\n *    returned signal.\n *  - On destroy (or when `media` changes) the helper calls\n *    `media.revoke()` to free the object URL slot. The next consumer\n *    that accesses `media.objectURL` mints a fresh URL from the same\n *    `Blob`, so live re-renders just work.\n *  - If the underlying handle errored before settling, the promise\n *    rejects and `injectMediaUrl` stays at `undefined`. Inspect\n *    `media.error` to surface the failure.\n *\n * Pair with {@link injectAudio} / {@link injectImages} /\n * {@link injectVideo} / {@link injectFiles} to bridge SDK media\n * handles into Angular templates without manual\n * `URL.createObjectURL` bookkeeping.\n *\n * `media` accepts a plain handle or a `Signal<MediaBase | undefined>`\n * so callers can feed a `computed(() => stream.audio()[0])`.\n */\nexport function injectMediaUrl(\n  media: MediaBase | undefined | Signal<MediaBase | undefined>\n): Signal<string | undefined> {\n  const url = signal<string | undefined>(undefined);\n\n  const read = isSignal(media)\n    ? (media as Signal<MediaBase | undefined>)\n    : () => media as MediaBase | undefined;\n\n  effect((onCleanup) => {\n    const next = (read as () => MediaBase | undefined)();\n\n    untracked(() => {\n      url.set(undefined);\n      if (next == null) return;\n\n      let cancelled = false;\n      next.objectURL.then(\n        (resolved) => {\n          if (!cancelled) url.set(resolved);\n        },\n        () => {\n          // Errors surfaced via `media.error`; keep `url` undefined\n          // so consumers fall through to a no-src render.\n        }\n      );\n\n      onCleanup(() => {\n        cancelled = true;\n        try {\n          next.revoke();\n        } catch {\n          // best-effort\n        }\n      });\n    });\n  });\n\n  return url;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,eACd,OAC4B;CAC5B,MAAM,MAAM,OAA2B,KAAA,EAAU;CAEjD,MAAM,OAAO,SAAS,MAAM,GACvB,cACK;AAEV,SAAQ,cAAc;EACpB,MAAM,OAAQ,MAAsC;AAEpD,kBAAgB;AACd,OAAI,IAAI,KAAA,EAAU;AAClB,OAAI,QAAQ,KAAM;GAElB,IAAI,YAAY;AAChB,QAAK,UAAU,MACZ,aAAa;AACZ,QAAI,CAAC,UAAW,KAAI,IAAI,SAAS;YAE7B,GAIP;AAED,mBAAgB;AACd,gBAAY;AACZ,QAAI;AACF,UAAK,QAAQ;YACP;KAGR;IACF;GACF;AAEF,QAAO"}

package/dist/inject-projection.cjs

@@ -0,0 +1,74 @@
+let _angular_core = require("@angular/core");
+//#region src/inject-projection.ts
+/**
+* Angular-side primitive that composes {@link ChannelRegistry.acquire}
+* with Angular Signals + {@link DestroyRef}.
+*
+* Contract (mirrors the React `useProjection` hook and the Vue
+* `useProjection` composable, but adapted to Angular's injection
+* context):
+*
+*  - Must be called in an injection context (component / directive /
+*    service field initializer, or `runInInjectionContext(...)`).
+*  - On first read (or when `registry` / `key` change) acquires a
+*    ref-counted projection from the registry and subscribes to its
+*    store. A `computed` view over the snapshot signal is returned.
+*  - On destroy (or when `registry` / `key` change) the previous
+*    acquisition is released. If this was the last consumer of that
+*    spec, the registry closes the underlying server subscription.
+*  - When `registry` is `null`/`undefined` the projection stays at
+*    `initialValue`. This is the happy path for root-served
+*    projections (`injectMessages`, `injectToolCalls`,
+*    `injectValues`) which delegate to the always-on root snapshot
+*    instead of acquiring a new registry projection.
+*
+* Reactive inputs: `registry` and `key` accept either a plain value
+* or a `Signal` so selector helpers can feed a computed target (e.g.
+* a subagent snapshot tracked on a signal) and rebind automatically.
+*/
+function injectProjection(registry, specFactory, key, initialValue) {
+	const state = (0, _angular_core.signal)(initialValue);
+	const destroyRef = (0, _angular_core.inject)(_angular_core.DestroyRef);
+	const registrySignal = (0, _angular_core.isSignal)(registry) ? registry : () => registry;
+	const keySignal = (0, _angular_core.isSignal)(key) ? key : () => key;
+	let currentRegistry;
+	let currentKey;
+	let currentRelease;
+	let currentUnsubscribe;
+	const detach = () => {
+		currentUnsubscribe?.();
+		currentUnsubscribe = void 0;
+		currentRelease?.();
+		currentRelease = void 0;
+	};
+	const attach = (nextRegistry, nextKey) => {
+		if (nextRegistry === currentRegistry && nextKey === currentKey) return;
+		detach();
+		currentRegistry = nextRegistry;
+		currentKey = nextKey;
+		if (nextRegistry == null) {
+			state.set(initialValue);
+			return;
+		}
+		const acquired = nextRegistry.acquire(specFactory());
+		state.set(acquired.store.getSnapshot());
+		currentUnsubscribe = acquired.store.subscribe(() => {
+			state.set(acquired.store.getSnapshot());
+		});
+		currentRelease = acquired.release;
+	};
+	attach(registrySignal(), keySignal());
+	destroyRef.onDestroy(detach);
+	(0, _angular_core.effect)(() => {
+		const nextRegistry = registrySignal();
+		const nextKey = keySignal();
+		(0, _angular_core.untracked)(() => {
+			attach(nextRegistry, nextKey);
+		});
+	});
+	return (0, _angular_core.computed)(() => state());
+}
+//#endregion
+exports.injectProjection = injectProjection;
+
+//# sourceMappingURL=inject-projection.cjs.map

package/dist/inject-projection.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-projection.cjs","names":["DestroyRef"],"sources":["../src/inject-projection.ts"],"sourcesContent":["import {\n  DestroyRef,\n  computed,\n  effect,\n  inject,\n  isSignal,\n  signal,\n  untracked,\n  type Signal,\n} from \"@angular/core\";\nimport type {\n  ChannelRegistry,\n  ProjectionSpec,\n} from \"@langchain/langgraph-sdk/stream\";\n\n/**\n * Angular-side primitive that composes {@link ChannelRegistry.acquire}\n * with Angular Signals + {@link DestroyRef}.\n *\n * Contract (mirrors the React `useProjection` hook and the Vue\n * `useProjection` composable, but adapted to Angular's injection\n * context):\n *\n *  - Must be called in an injection context (component / directive /\n *    service field initializer, or `runInInjectionContext(...)`).\n *  - On first read (or when `registry` / `key` change) acquires a\n *    ref-counted projection from the registry and subscribes to its\n *    store. A `computed` view over the snapshot signal is returned.\n *  - On destroy (or when `registry` / `key` change) the previous\n *    acquisition is released. If this was the last consumer of that\n *    spec, the registry closes the underlying server subscription.\n *  - When `registry` is `null`/`undefined` the projection stays at\n *    `initialValue`. This is the happy path for root-served\n *    projections (`injectMessages`, `injectToolCalls`,\n *    `injectValues`) which delegate to the always-on root snapshot\n *    instead of acquiring a new registry projection.\n *\n * Reactive inputs: `registry` and `key` accept either a plain value\n * or a `Signal` so selector helpers can feed a computed target (e.g.\n * a subagent snapshot tracked on a signal) and rebind automatically.\n */\nexport function injectProjection<T>(\n  registry:\n    | ChannelRegistry\n    | null\n    | undefined\n    | Signal<ChannelRegistry | null | undefined>,\n  specFactory: () => ProjectionSpec<T>,\n  key: string | Signal<string>,\n  initialValue: T\n): Signal<T> {\n  const state = signal<T>(initialValue);\n  const destroyRef = inject(DestroyRef);\n\n  const registrySignal: () => ChannelRegistry | null | undefined = isSignal(\n    registry\n  )\n    ? (registry as Signal<ChannelRegistry | null | undefined>)\n    : () => registry as ChannelRegistry | null | undefined;\n  const keySignal: () => string = isSignal(key)\n    ? (key as Signal<string>)\n    : () => key as string;\n\n  let currentRegistry: ChannelRegistry | null | undefined;\n  let currentKey: string | undefined;\n  let currentRelease: (() => void) | undefined;\n  let currentUnsubscribe: (() => void) | undefined;\n\n  const detach = () => {\n    currentUnsubscribe?.();\n    currentUnsubscribe = undefined;\n    currentRelease?.();\n    currentRelease = undefined;\n  };\n\n  const attach = (\n    nextRegistry: ChannelRegistry | null | undefined,\n    nextKey: string\n  ) => {\n    if (nextRegistry === currentRegistry && nextKey === currentKey) return;\n    detach();\n    currentRegistry = nextRegistry;\n    currentKey = nextKey;\n\n    if (nextRegistry == null) {\n      state.set(initialValue);\n      return;\n    }\n\n    const acquired = nextRegistry.acquire(specFactory());\n    state.set(acquired.store.getSnapshot());\n    currentUnsubscribe = acquired.store.subscribe(() => {\n      state.set(acquired.store.getSnapshot());\n    });\n    currentRelease = acquired.release;\n  };\n\n  // Acquire synchronously so selectors are subscribed before a user can\n  // submit and emit short-lived custom/projection events.\n  attach(registrySignal(), keySignal());\n  destroyRef.onDestroy(detach);\n\n  effect(() => {\n    const nextRegistry = registrySignal();\n    const nextKey = keySignal();\n    untracked(() => {\n      attach(nextRegistry, nextKey);\n    });\n  });\n\n  return computed(() => state());\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,iBACd,UAKA,aACA,KACA,cACW;CACX,MAAM,SAAA,GAAA,cAAA,QAAkB,aAAa;CACrC,MAAM,cAAA,GAAA,cAAA,QAAoBA,cAAAA,WAAW;CAErC,MAAM,kBAAA,GAAA,cAAA,UACJ,SACD,GACI,iBACK;CACV,MAAM,aAAA,GAAA,cAAA,UAAmC,IAAI,GACxC,YACK;CAEV,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CAEJ,MAAM,eAAe;AACnB,wBAAsB;AACtB,uBAAqB,KAAA;AACrB,oBAAkB;AAClB,mBAAiB,KAAA;;CAGnB,MAAM,UACJ,cACA,YACG;AACH,MAAI,iBAAiB,mBAAmB,YAAY,WAAY;AAChE,UAAQ;AACR,oBAAkB;AAClB,eAAa;AAEb,MAAI,gBAAgB,MAAM;AACxB,SAAM,IAAI,aAAa;AACvB;;EAGF,MAAM,WAAW,aAAa,QAAQ,aAAa,CAAC;AACpD,QAAM,IAAI,SAAS,MAAM,aAAa,CAAC;AACvC,uBAAqB,SAAS,MAAM,gBAAgB;AAClD,SAAM,IAAI,SAAS,MAAM,aAAa,CAAC;IACvC;AACF,mBAAiB,SAAS;;AAK5B,QAAO,gBAAgB,EAAE,WAAW,CAAC;AACrC,YAAW,UAAU,OAAO;AAE5B,EAAA,GAAA,cAAA,cAAa;EACX,MAAM,eAAe,gBAAgB;EACrC,MAAM,UAAU,WAAW;AAC3B,GAAA,GAAA,cAAA,iBAAgB;AACd,UAAO,cAAc,QAAQ;IAC7B;GACF;AAEF,SAAA,GAAA,cAAA,gBAAsB,OAAO,CAAC"}

package/dist/inject-projection.d.cts

@@ -0,0 +1,34 @@
+import { ChannelRegistry, ProjectionSpec } from "@langchain/langgraph-sdk/stream";
+import { Signal } from "@angular/core";
+
+//#region src/inject-projection.d.ts
+/**
+ * Angular-side primitive that composes {@link ChannelRegistry.acquire}
+ * with Angular Signals + {@link DestroyRef}.
+ *
+ * Contract (mirrors the React `useProjection` hook and the Vue
+ * `useProjection` composable, but adapted to Angular's injection
+ * context):
+ *
+ *  - Must be called in an injection context (component / directive /
+ *    service field initializer, or `runInInjectionContext(...)`).
+ *  - On first read (or when `registry` / `key` change) acquires a
+ *    ref-counted projection from the registry and subscribes to its
+ *    store. A `computed` view over the snapshot signal is returned.
+ *  - On destroy (or when `registry` / `key` change) the previous
+ *    acquisition is released. If this was the last consumer of that
+ *    spec, the registry closes the underlying server subscription.
+ *  - When `registry` is `null`/`undefined` the projection stays at
+ *    `initialValue`. This is the happy path for root-served
+ *    projections (`injectMessages`, `injectToolCalls`,
+ *    `injectValues`) which delegate to the always-on root snapshot
+ *    instead of acquiring a new registry projection.
+ *
+ * Reactive inputs: `registry` and `key` accept either a plain value
+ * or a `Signal` so selector helpers can feed a computed target (e.g.
+ * a subagent snapshot tracked on a signal) and rebind automatically.
+ */
+declare function injectProjection<T>(registry: ChannelRegistry | null | undefined | Signal<ChannelRegistry | null | undefined>, specFactory: () => ProjectionSpec<T>, key: string | Signal<string>, initialValue: T): Signal<T>;
+//#endregion
+export { injectProjection };
+//# sourceMappingURL=inject-projection.d.cts.map

package/dist/inject-projection.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-projection.d.cts","names":[],"sources":["../src/inject-projection.ts"],"mappings":";;;;;;AAyCA;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,gBAAA,GAAA,CACd,QAAA,EACI,eAAA,sBAGA,MAAA,CAAO,eAAA,sBACX,WAAA,QAAmB,cAAA,CAAe,CAAA,GAClC,GAAA,WAAc,MAAA,UACd,YAAA,EAAc,CAAA,GACb,MAAA,CAAO,CAAA"}

package/dist/inject-projection.d.ts

@@ -0,0 +1,34 @@
+import { Signal } from "@angular/core";
+import { ChannelRegistry, ProjectionSpec } from "@langchain/langgraph-sdk/stream";
+
+//#region src/inject-projection.d.ts
+/**
+ * Angular-side primitive that composes {@link ChannelRegistry.acquire}
+ * with Angular Signals + {@link DestroyRef}.
+ *
+ * Contract (mirrors the React `useProjection` hook and the Vue
+ * `useProjection` composable, but adapted to Angular's injection
+ * context):
+ *
+ *  - Must be called in an injection context (component / directive /
+ *    service field initializer, or `runInInjectionContext(...)`).
+ *  - On first read (or when `registry` / `key` change) acquires a
+ *    ref-counted projection from the registry and subscribes to its
+ *    store. A `computed` view over the snapshot signal is returned.
+ *  - On destroy (or when `registry` / `key` change) the previous
+ *    acquisition is released. If this was the last consumer of that
+ *    spec, the registry closes the underlying server subscription.
+ *  - When `registry` is `null`/`undefined` the projection stays at
+ *    `initialValue`. This is the happy path for root-served
+ *    projections (`injectMessages`, `injectToolCalls`,
+ *    `injectValues`) which delegate to the always-on root snapshot
+ *    instead of acquiring a new registry projection.
+ *
+ * Reactive inputs: `registry` and `key` accept either a plain value
+ * or a `Signal` so selector helpers can feed a computed target (e.g.
+ * a subagent snapshot tracked on a signal) and rebind automatically.
+ */
+declare function injectProjection<T>(registry: ChannelRegistry | null | undefined | Signal<ChannelRegistry | null | undefined>, specFactory: () => ProjectionSpec<T>, key: string | Signal<string>, initialValue: T): Signal<T>;
+//#endregion
+export { injectProjection };
+//# sourceMappingURL=inject-projection.d.ts.map

package/dist/inject-projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-projection.d.ts","names":[],"sources":["../src/inject-projection.ts"],"mappings":";;;;;;AAyCA;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,gBAAA,GAAA,CACd,QAAA,EACI,eAAA,sBAGA,MAAA,CAAO,eAAA,sBACX,WAAA,QAAmB,cAAA,CAAe,CAAA,GAClC,GAAA,WAAc,MAAA,UACd,YAAA,EAAc,CAAA,GACb,MAAA,CAAO,CAAA"}

package/dist/inject-projection.js

@@ -0,0 +1,74 @@
+import { DestroyRef, computed, effect, inject, isSignal, signal, untracked } from "@angular/core";
+//#region src/inject-projection.ts
+/**
+* Angular-side primitive that composes {@link ChannelRegistry.acquire}
+* with Angular Signals + {@link DestroyRef}.
+*
+* Contract (mirrors the React `useProjection` hook and the Vue
+* `useProjection` composable, but adapted to Angular's injection
+* context):
+*
+*  - Must be called in an injection context (component / directive /
+*    service field initializer, or `runInInjectionContext(...)`).
+*  - On first read (or when `registry` / `key` change) acquires a
+*    ref-counted projection from the registry and subscribes to its
+*    store. A `computed` view over the snapshot signal is returned.
+*  - On destroy (or when `registry` / `key` change) the previous
+*    acquisition is released. If this was the last consumer of that
+*    spec, the registry closes the underlying server subscription.
+*  - When `registry` is `null`/`undefined` the projection stays at
+*    `initialValue`. This is the happy path for root-served
+*    projections (`injectMessages`, `injectToolCalls`,
+*    `injectValues`) which delegate to the always-on root snapshot
+*    instead of acquiring a new registry projection.
+*
+* Reactive inputs: `registry` and `key` accept either a plain value
+* or a `Signal` so selector helpers can feed a computed target (e.g.
+* a subagent snapshot tracked on a signal) and rebind automatically.
+*/
+function injectProjection(registry, specFactory, key, initialValue) {
+	const state = signal(initialValue);
+	const destroyRef = inject(DestroyRef);
+	const registrySignal = isSignal(registry) ? registry : () => registry;
+	const keySignal = isSignal(key) ? key : () => key;
+	let currentRegistry;
+	let currentKey;
+	let currentRelease;
+	let currentUnsubscribe;
+	const detach = () => {
+		currentUnsubscribe?.();
+		currentUnsubscribe = void 0;
+		currentRelease?.();
+		currentRelease = void 0;
+	};
+	const attach = (nextRegistry, nextKey) => {
+		if (nextRegistry === currentRegistry && nextKey === currentKey) return;
+		detach();
+		currentRegistry = nextRegistry;
+		currentKey = nextKey;
+		if (nextRegistry == null) {
+			state.set(initialValue);
+			return;
+		}
+		const acquired = nextRegistry.acquire(specFactory());
+		state.set(acquired.store.getSnapshot());
+		currentUnsubscribe = acquired.store.subscribe(() => {
+			state.set(acquired.store.getSnapshot());
+		});
+		currentRelease = acquired.release;
+	};
+	attach(registrySignal(), keySignal());
+	destroyRef.onDestroy(detach);
+	effect(() => {
+		const nextRegistry = registrySignal();
+		const nextKey = keySignal();
+		untracked(() => {
+			attach(nextRegistry, nextKey);
+		});
+	});
+	return computed(() => state());
+}
+//#endregion
+export { injectProjection };
+
+//# sourceMappingURL=inject-projection.js.map

package/dist/inject-projection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-projection.js","names":[],"sources":["../src/inject-projection.ts"],"sourcesContent":["import {\n  DestroyRef,\n  computed,\n  effect,\n  inject,\n  isSignal,\n  signal,\n  untracked,\n  type Signal,\n} from \"@angular/core\";\nimport type {\n  ChannelRegistry,\n  ProjectionSpec,\n} from \"@langchain/langgraph-sdk/stream\";\n\n/**\n * Angular-side primitive that composes {@link ChannelRegistry.acquire}\n * with Angular Signals + {@link DestroyRef}.\n *\n * Contract (mirrors the React `useProjection` hook and the Vue\n * `useProjection` composable, but adapted to Angular's injection\n * context):\n *\n *  - Must be called in an injection context (component / directive /\n *    service field initializer, or `runInInjectionContext(...)`).\n *  - On first read (or when `registry` / `key` change) acquires a\n *    ref-counted projection from the registry and subscribes to its\n *    store. A `computed` view over the snapshot signal is returned.\n *  - On destroy (or when `registry` / `key` change) the previous\n *    acquisition is released. If this was the last consumer of that\n *    spec, the registry closes the underlying server subscription.\n *  - When `registry` is `null`/`undefined` the projection stays at\n *    `initialValue`. This is the happy path for root-served\n *    projections (`injectMessages`, `injectToolCalls`,\n *    `injectValues`) which delegate to the always-on root snapshot\n *    instead of acquiring a new registry projection.\n *\n * Reactive inputs: `registry` and `key` accept either a plain value\n * or a `Signal` so selector helpers can feed a computed target (e.g.\n * a subagent snapshot tracked on a signal) and rebind automatically.\n */\nexport function injectProjection<T>(\n  registry:\n    | ChannelRegistry\n    | null\n    | undefined\n    | Signal<ChannelRegistry | null | undefined>,\n  specFactory: () => ProjectionSpec<T>,\n  key: string | Signal<string>,\n  initialValue: T\n): Signal<T> {\n  const state = signal<T>(initialValue);\n  const destroyRef = inject(DestroyRef);\n\n  const registrySignal: () => ChannelRegistry | null | undefined = isSignal(\n    registry\n  )\n    ? (registry as Signal<ChannelRegistry | null | undefined>)\n    : () => registry as ChannelRegistry | null | undefined;\n  const keySignal: () => string = isSignal(key)\n    ? (key as Signal<string>)\n    : () => key as string;\n\n  let currentRegistry: ChannelRegistry | null | undefined;\n  let currentKey: string | undefined;\n  let currentRelease: (() => void) | undefined;\n  let currentUnsubscribe: (() => void) | undefined;\n\n  const detach = () => {\n    currentUnsubscribe?.();\n    currentUnsubscribe = undefined;\n    currentRelease?.();\n    currentRelease = undefined;\n  };\n\n  const attach = (\n    nextRegistry: ChannelRegistry | null | undefined,\n    nextKey: string\n  ) => {\n    if (nextRegistry === currentRegistry && nextKey === currentKey) return;\n    detach();\n    currentRegistry = nextRegistry;\n    currentKey = nextKey;\n\n    if (nextRegistry == null) {\n      state.set(initialValue);\n      return;\n    }\n\n    const acquired = nextRegistry.acquire(specFactory());\n    state.set(acquired.store.getSnapshot());\n    currentUnsubscribe = acquired.store.subscribe(() => {\n      state.set(acquired.store.getSnapshot());\n    });\n    currentRelease = acquired.release;\n  };\n\n  // Acquire synchronously so selectors are subscribed before a user can\n  // submit and emit short-lived custom/projection events.\n  attach(registrySignal(), keySignal());\n  destroyRef.onDestroy(detach);\n\n  effect(() => {\n    const nextRegistry = registrySignal();\n    const nextKey = keySignal();\n    untracked(() => {\n      attach(nextRegistry, nextKey);\n    });\n  });\n\n  return computed(() => state());\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,iBACd,UAKA,aACA,KACA,cACW;CACX,MAAM,QAAQ,OAAU,aAAa;CACrC,MAAM,aAAa,OAAO,WAAW;CAErC,MAAM,iBAA2D,SAC/D,SACD,GACI,iBACK;CACV,MAAM,YAA0B,SAAS,IAAI,GACxC,YACK;CAEV,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CAEJ,MAAM,eAAe;AACnB,wBAAsB;AACtB,uBAAqB,KAAA;AACrB,oBAAkB;AAClB,mBAAiB,KAAA;;CAGnB,MAAM,UACJ,cACA,YACG;AACH,MAAI,iBAAiB,mBAAmB,YAAY,WAAY;AAChE,UAAQ;AACR,oBAAkB;AAClB,eAAa;AAEb,MAAI,gBAAgB,MAAM;AACxB,SAAM,IAAI,aAAa;AACvB;;EAGF,MAAM,WAAW,aAAa,QAAQ,aAAa,CAAC;AACpD,QAAM,IAAI,SAAS,MAAM,aAAa,CAAC;AACvC,uBAAqB,SAAS,MAAM,gBAAgB;AAClD,SAAM,IAAI,SAAS,MAAM,aAAa,CAAC;IACvC;AACF,mBAAiB,SAAS;;AAK5B,QAAO,gBAAgB,EAAE,WAAW,CAAC;AACrC,YAAW,UAAU,OAAO;AAE5B,cAAa;EACX,MAAM,eAAe,gBAAgB;EACrC,MAAM,UAAU,WAAW;AAC3B,kBAAgB;AACd,UAAO,cAAc,QAAQ;IAC7B;GACF;AAEF,QAAO,eAAe,OAAO,CAAC"}

package/dist/inject-stream.cjs

@@ -0,0 +1,27 @@
+const require_use_stream = require("./use-stream.cjs");
+const require_context = require("./context.cjs");
+let _angular_core = require("@angular/core");
+//#region src/inject-stream.ts
+function injectStream(options) {
+	if (options == null) {
+		const shared = (0, _angular_core.inject)(require_context.STREAM_INSTANCE, { optional: true });
+		if (shared == null) throw new Error("injectStream() requires an ancestor to call provideStream(). Add provideStream({ assistantId: '...' }) to a parent component's providers array, or call injectStream(options) directly.");
+		return shared;
+	}
+	return require_use_stream.useStream(mergeDefaults(options, (0, _angular_core.inject)(require_context.STREAM_DEFAULTS, { optional: true }) ?? void 0));
+}
+function mergeDefaults(options, defaults) {
+	if (defaults == null) return options;
+	if (options.transport != null && typeof options.transport !== "string") return options;
+	const bag = options;
+	return {
+		...bag,
+		apiUrl: bag.apiUrl ?? defaults.apiUrl,
+		apiKey: bag.apiKey ?? defaults.apiKey,
+		client: bag.client ?? defaults.client
+	};
+}
+//#endregion
+exports.injectStream = injectStream;
+
+//# sourceMappingURL=inject-stream.cjs.map

package/dist/inject-stream.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-stream.cjs","names":["STREAM_INSTANCE","useStream","STREAM_DEFAULTS"],"sources":["../src/inject-stream.ts"],"sourcesContent":["import { inject } from \"@angular/core\";\nimport type { InferStateType } from \"@langchain/langgraph-sdk/stream\";\nimport {\n  STREAM_DEFAULTS,\n  STREAM_INSTANCE,\n  type StreamDefaults,\n} from \"./context.js\";\nimport {\n  useStream,\n  type StreamApi,\n  type UseStreamOptions,\n} from \"./use-stream.js\";\n\n/**\n * Angular entry point for the v2-native stream runtime.\n *\n * Call from a component, directive, or service field initializer to\n * attach an {@link StreamApi} bound to the current {@link DestroyRef}:\n *\n * ```ts\n * @Component({ template: `<div>{{ stream.messages() | json }}</div>` })\n * export class Chat {\n *   readonly stream = injectStream({\n *     assistantId: \"agent\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n * }\n * ```\n *\n * When called with no arguments, looks up a shared `StreamApi`\n * previously registered via {@link provideStream}. Throws if no\n * ancestor provider exists.\n *\n * Must always run inside an Angular injection context.\n */\nexport function injectStream<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(): StreamApi<T, InterruptType, ConfigurableType>;\nexport function injectStream<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(\n  options: UseStreamOptions<InferStateType<T>>\n): StreamApi<T, InterruptType, ConfigurableType>;\nexport function injectStream(\n  options?: UseStreamOptions<Record<string, unknown>>\n): StreamApi {\n  if (options == null) {\n    const shared = inject(STREAM_INSTANCE, { optional: true });\n    if (shared == null) {\n      throw new Error(\n        \"injectStream() requires an ancestor to call provideStream(). \" +\n          \"Add provideStream({ assistantId: '...' }) to a parent component's \" +\n          \"providers array, or call injectStream(options) directly.\"\n      );\n    }\n    return shared as StreamApi;\n  }\n\n  const defaults = inject(STREAM_DEFAULTS, { optional: true }) ?? undefined;\n  const merged = mergeDefaults(options, defaults);\n  return useStream(merged) as StreamApi;\n}\n\nfunction mergeDefaults<S extends object>(\n  options: UseStreamOptions<S>,\n  defaults: StreamDefaults | undefined\n): UseStreamOptions<S> {\n  if (defaults == null) return options;\n  // Only merge into the agent-server branch — the custom-adapter\n  // branch owns its own wire and must not inherit `apiUrl` / `client`.\n  if (\n    (options as { transport?: unknown }).transport != null &&\n    typeof (options as { transport: unknown }).transport !== \"string\"\n  ) {\n    return options;\n  }\n  const bag = options as unknown as Record<string, unknown>;\n  return {\n    ...bag,\n    apiUrl: bag.apiUrl ?? defaults.apiUrl,\n    apiKey: bag.apiKey ?? defaults.apiKey,\n    client: bag.client ?? defaults.client,\n  } as unknown as UseStreamOptions<S>;\n}\n"],"mappings":";;;;AA+CA,SAAgB,aACd,SACW;AACX,KAAI,WAAW,MAAM;EACnB,MAAM,UAAA,GAAA,cAAA,QAAgBA,gBAAAA,iBAAiB,EAAE,UAAU,MAAM,CAAC;AAC1D,MAAI,UAAU,KACZ,OAAM,IAAI,MACR,0LAGD;AAEH,SAAO;;AAKT,QAAOC,mBAAAA,UADQ,cAAc,UAAA,GAAA,cAAA,QADLC,gBAAAA,iBAAiB,EAAE,UAAU,MAAM,CAAC,IAAI,KAAA,EACjB,CACvB;;AAG1B,SAAS,cACP,SACA,UACqB;AACrB,KAAI,YAAY,KAAM,QAAO;AAG7B,KACG,QAAoC,aAAa,QAClD,OAAQ,QAAmC,cAAc,SAEzD,QAAO;CAET,MAAM,MAAM;AACZ,QAAO;EACL,GAAG;EACH,QAAQ,IAAI,UAAU,SAAS;EAC/B,QAAQ,IAAI,UAAU,SAAS;EAC/B,QAAQ,IAAI,UAAU,SAAS;EAChC"}

package/dist/inject-stream.d.cts

@@ -0,0 +1,31 @@
+import { StreamApi, UseStreamOptions as UseStreamOptions$1 } from "./use-stream.cjs";
+import { InferStateType } from "@langchain/langgraph-sdk/stream";
+
+//#region src/inject-stream.d.ts
+/**
+ * Angular entry point for the v2-native stream runtime.
+ *
+ * Call from a component, directive, or service field initializer to
+ * attach an {@link StreamApi} bound to the current {@link DestroyRef}:
+ *
+ * ```ts
+ * @Component({ template: `<div>{{ stream.messages() | json }}</div>` })
+ * export class Chat {
+ *   readonly stream = injectStream({
+ *     assistantId: "agent",
+ *     apiUrl: "http://localhost:2024",
+ *   });
+ * }
+ * ```
+ *
+ * When called with no arguments, looks up a shared `StreamApi`
+ * previously registered via {@link provideStream}. Throws if no
+ * ancestor provider exists.
+ *
+ * Must always run inside an Angular injection context.
+ */
+declare function injectStream<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>>(): StreamApi<T, InterruptType, ConfigurableType>;
+declare function injectStream<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>>(options: UseStreamOptions$1<InferStateType<T>>): StreamApi<T, InterruptType, ConfigurableType>;
+//#endregion
+export { injectStream };
+//# sourceMappingURL=inject-stream.d.cts.map

package/dist/inject-stream.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-stream.d.cts","names":[],"sources":["../src/inject-stream.ts"],"mappings":";;;;;;AAmCA;;;;;;;;;;;;;;;;;;;;iBAAgB,YAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAAA,GAC/B,SAAA,CAAU,CAAA,EAAG,aAAA,EAAe,gBAAA;AAAA,iBACjB,YAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAElC,OAAA,EAAS,kBAAA,CAAiB,cAAA,CAAe,CAAA,KACxC,SAAA,CAAU,CAAA,EAAG,aAAA,EAAe,gBAAA"}

package/dist/inject-stream.d.ts

@@ -0,0 +1,31 @@
+import { StreamApi, UseStreamOptions as UseStreamOptions$1 } from "./use-stream.js";
+import { InferStateType } from "@langchain/langgraph-sdk/stream";
+
+//#region src/inject-stream.d.ts
+/**
+ * Angular entry point for the v2-native stream runtime.
+ *
+ * Call from a component, directive, or service field initializer to
+ * attach an {@link StreamApi} bound to the current {@link DestroyRef}:
+ *
+ * ```ts
+ * @Component({ template: `<div>{{ stream.messages() | json }}</div>` })
+ * export class Chat {
+ *   readonly stream = injectStream({
+ *     assistantId: "agent",
+ *     apiUrl: "http://localhost:2024",
+ *   });
+ * }
+ * ```
+ *
+ * When called with no arguments, looks up a shared `StreamApi`
+ * previously registered via {@link provideStream}. Throws if no
+ * ancestor provider exists.
+ *
+ * Must always run inside an Angular injection context.
+ */
+declare function injectStream<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>>(): StreamApi<T, InterruptType, ConfigurableType>;
+declare function injectStream<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>>(options: UseStreamOptions$1<InferStateType<T>>): StreamApi<T, InterruptType, ConfigurableType>;
+//#endregion
+export { injectStream };
+//# sourceMappingURL=inject-stream.d.ts.map

package/dist/inject-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-stream.d.ts","names":[],"sources":["../src/inject-stream.ts"],"mappings":";;;;;;AAmCA;;;;;;;;;;;;;;;;;;;;iBAAgB,YAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAAA,GAC/B,SAAA,CAAU,CAAA,EAAG,aAAA,EAAe,gBAAA;AAAA,iBACjB,YAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAElC,OAAA,EAAS,kBAAA,CAAiB,cAAA,CAAe,CAAA,KACxC,SAAA,CAAU,CAAA,EAAG,aAAA,EAAe,gBAAA"}

package/dist/inject-stream.js

@@ -0,0 +1,27 @@
+import { useStream } from "./use-stream.js";
+import { STREAM_DEFAULTS, STREAM_INSTANCE } from "./context.js";
+import { inject } from "@angular/core";
+//#region src/inject-stream.ts
+function injectStream(options) {
+	if (options == null) {
+		const shared = inject(STREAM_INSTANCE, { optional: true });
+		if (shared == null) throw new Error("injectStream() requires an ancestor to call provideStream(). Add provideStream({ assistantId: '...' }) to a parent component's providers array, or call injectStream(options) directly.");
+		return shared;
+	}
+	return useStream(mergeDefaults(options, inject(STREAM_DEFAULTS, { optional: true }) ?? void 0));
+}
+function mergeDefaults(options, defaults) {
+	if (defaults == null) return options;
+	if (options.transport != null && typeof options.transport !== "string") return options;
+	const bag = options;
+	return {
+		...bag,
+		apiUrl: bag.apiUrl ?? defaults.apiUrl,
+		apiKey: bag.apiKey ?? defaults.apiKey,
+		client: bag.client ?? defaults.client
+	};
+}
+//#endregion
+export { injectStream };
+
+//# sourceMappingURL=inject-stream.js.map

package/dist/inject-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-stream.js","names":[],"sources":["../src/inject-stream.ts"],"sourcesContent":["import { inject } from \"@angular/core\";\nimport type { InferStateType } from \"@langchain/langgraph-sdk/stream\";\nimport {\n  STREAM_DEFAULTS,\n  STREAM_INSTANCE,\n  type StreamDefaults,\n} from \"./context.js\";\nimport {\n  useStream,\n  type StreamApi,\n  type UseStreamOptions,\n} from \"./use-stream.js\";\n\n/**\n * Angular entry point for the v2-native stream runtime.\n *\n * Call from a component, directive, or service field initializer to\n * attach an {@link StreamApi} bound to the current {@link DestroyRef}:\n *\n * ```ts\n * @Component({ template: `<div>{{ stream.messages() | json }}</div>` })\n * export class Chat {\n *   readonly stream = injectStream({\n *     assistantId: \"agent\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n * }\n * ```\n *\n * When called with no arguments, looks up a shared `StreamApi`\n * previously registered via {@link provideStream}. Throws if no\n * ancestor provider exists.\n *\n * Must always run inside an Angular injection context.\n */\nexport function injectStream<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(): StreamApi<T, InterruptType, ConfigurableType>;\nexport function injectStream<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(\n  options: UseStreamOptions<InferStateType<T>>\n): StreamApi<T, InterruptType, ConfigurableType>;\nexport function injectStream(\n  options?: UseStreamOptions<Record<string, unknown>>\n): StreamApi {\n  if (options == null) {\n    const shared = inject(STREAM_INSTANCE, { optional: true });\n    if (shared == null) {\n      throw new Error(\n        \"injectStream() requires an ancestor to call provideStream(). \" +\n          \"Add provideStream({ assistantId: '...' }) to a parent component's \" +\n          \"providers array, or call injectStream(options) directly.\"\n      );\n    }\n    return shared as StreamApi;\n  }\n\n  const defaults = inject(STREAM_DEFAULTS, { optional: true }) ?? undefined;\n  const merged = mergeDefaults(options, defaults);\n  return useStream(merged) as StreamApi;\n}\n\nfunction mergeDefaults<S extends object>(\n  options: UseStreamOptions<S>,\n  defaults: StreamDefaults | undefined\n): UseStreamOptions<S> {\n  if (defaults == null) return options;\n  // Only merge into the agent-server branch — the custom-adapter\n  // branch owns its own wire and must not inherit `apiUrl` / `client`.\n  if (\n    (options as { transport?: unknown }).transport != null &&\n    typeof (options as { transport: unknown }).transport !== \"string\"\n  ) {\n    return options;\n  }\n  const bag = options as unknown as Record<string, unknown>;\n  return {\n    ...bag,\n    apiUrl: bag.apiUrl ?? defaults.apiUrl,\n    apiKey: bag.apiKey ?? defaults.apiKey,\n    client: bag.client ?? defaults.client,\n  } as unknown as UseStreamOptions<S>;\n}\n"],"mappings":";;;;AA+CA,SAAgB,aACd,SACW;AACX,KAAI,WAAW,MAAM;EACnB,MAAM,SAAS,OAAO,iBAAiB,EAAE,UAAU,MAAM,CAAC;AAC1D,MAAI,UAAU,KACZ,OAAM,IAAI,MACR,0LAGD;AAEH,SAAO;;AAKT,QAAO,UADQ,cAAc,SADZ,OAAO,iBAAiB,EAAE,UAAU,MAAM,CAAC,IAAI,KAAA,EACjB,CACvB;;AAG1B,SAAS,cACP,SACA,UACqB;AACrB,KAAI,YAAY,KAAM,QAAO;AAG7B,KACG,QAAoC,aAAa,QAClD,OAAQ,QAAmC,cAAc,SAEzD,QAAO;CAET,MAAM,MAAM;AACZ,QAAO;EACL,GAAG;EACH,QAAQ,IAAI,UAAU,SAAS;EAC/B,QAAQ,IAAI,UAAU,SAAS;EAC/B,QAAQ,IAAI,UAAU,SAAS;EAChC"}

package/dist/selectors-metadata.cjs

@@ -0,0 +1,39 @@
+const require_use_stream = require("./use-stream.cjs");
+let _angular_core = require("@angular/core");
+//#region src/selectors-metadata.ts
+/**
+* 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
+* readonly meta = injectMessageMetadata(this.stream, () => this.msg().id);
+* // meta()?.parentCheckpointId
+* ```
+*
+* `messageId` accepts a raw string, a `Signal<string | undefined>`,
+* or a plain getter — the binding re-evaluates whenever the id
+* changes.
+*
+* Returns `undefined` when the id isn't known yet (e.g. the server
+* hasn't emitted `parent_checkpoint` for that message, or the message
+* arrived via `messages`-channel deltas only and no `values` snapshot
+* has landed for it yet).
+*/
+function injectMessageMetadata(stream, messageId) {
+	const destroyRef = (0, _angular_core.inject)(_angular_core.DestroyRef);
+	const store = stream[require_use_stream.STREAM_CONTROLLER].messageMetadataStore;
+	const mapSignal = (0, _angular_core.signal)(store.getSnapshot());
+	const unsubscribe = store.subscribe(() => mapSignal.set(store.getSnapshot()));
+	destroyRef.onDestroy(unsubscribe);
+	const read = (0, _angular_core.isSignal)(messageId) ? messageId : typeof messageId === "function" ? messageId : () => messageId;
+	return (0, _angular_core.computed)(() => {
+		const id = read();
+		if (id == null) return void 0;
+		return mapSignal().get(id);
+	});
+}
+//#endregion
+exports.injectMessageMetadata = injectMessageMetadata;
+
+//# sourceMappingURL=selectors-metadata.cjs.map

package/dist/selectors-metadata.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors-metadata.cjs","names":["DestroyRef","STREAM_CONTROLLER"],"sources":["../src/selectors-metadata.ts"],"sourcesContent":["import {\n  DestroyRef,\n  computed,\n  inject,\n  isSignal,\n  signal,\n  type Signal,\n} from \"@angular/core\";\nimport type {\n  MessageMetadata,\n  MessageMetadataMap,\n} from \"@langchain/langgraph-sdk/stream\";\nimport { STREAM_CONTROLLER, type AnyStream } from \"./use-stream.js\";\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 * readonly meta = injectMessageMetadata(this.stream, () => this.msg().id);\n * // meta()?.parentCheckpointId\n * ```\n *\n * `messageId` accepts a raw string, a `Signal<string | undefined>`,\n * or a plain getter — the binding re-evaluates whenever the id\n * changes.\n *\n * Returns `undefined` when the id isn't known yet (e.g. the server\n * hasn't emitted `parent_checkpoint` for that message, or the message\n * arrived via `messages`-channel deltas only and no `values` snapshot\n * has landed for it yet).\n */\nexport function injectMessageMetadata(\n  stream: AnyStream,\n  messageId:\n    | string\n    | undefined\n    | Signal<string | undefined>\n    | (() => string | undefined)\n): Signal<MessageMetadata | undefined> {\n  const destroyRef = inject(DestroyRef);\n  const store = stream[STREAM_CONTROLLER].messageMetadataStore;\n\n  const mapSignal = signal<MessageMetadataMap>(store.getSnapshot());\n  const unsubscribe = store.subscribe(() => mapSignal.set(store.getSnapshot()));\n  destroyRef.onDestroy(unsubscribe);\n\n  const read: () => string | undefined = isSignal(messageId)\n    ? (messageId as Signal<string | undefined>)\n    : typeof messageId === \"function\"\n      ? (messageId as () => string | undefined)\n      : () => messageId as string | undefined;\n\n  return computed(() => {\n    const id = read();\n    if (id == null) return undefined;\n    return mapSignal().get(id);\n  });\n}\n\nexport type { MessageMetadata, MessageMetadataMap };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,sBACd,QACA,WAKqC;CACrC,MAAM,cAAA,GAAA,cAAA,QAAoBA,cAAAA,WAAW;CACrC,MAAM,QAAQ,OAAOC,mBAAAA,mBAAmB;CAExC,MAAM,aAAA,GAAA,cAAA,QAAuC,MAAM,aAAa,CAAC;CACjE,MAAM,cAAc,MAAM,gBAAgB,UAAU,IAAI,MAAM,aAAa,CAAC,CAAC;AAC7E,YAAW,UAAU,YAAY;CAEjC,MAAM,QAAA,GAAA,cAAA,UAA0C,UAAU,GACrD,YACD,OAAO,cAAc,aAClB,kBACK;AAEZ,SAAA,GAAA,cAAA,gBAAsB;EACpB,MAAM,KAAK,MAAM;AACjB,MAAI,MAAM,KAAM,QAAO,KAAA;AACvB,SAAO,WAAW,CAAC,IAAI,GAAG;GAC1B"}

package/dist/selectors-metadata.d.cts

@@ -0,0 +1,28 @@
+import { AnyStream } from "./use-stream.cjs";
+import { MessageMetadata, MessageMetadataMap } from "@langchain/langgraph-sdk/stream";
+import { Signal } from "@angular/core";
+
+//#region src/selectors-metadata.d.ts
+/**
+ * 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
+ * readonly meta = injectMessageMetadata(this.stream, () => this.msg().id);
+ * // meta()?.parentCheckpointId
+ * ```
+ *
+ * `messageId` accepts a raw string, a `Signal<string | undefined>`,
+ * or a plain getter — the binding re-evaluates whenever the id
+ * changes.
+ *
+ * Returns `undefined` when the id isn't known yet (e.g. the server
+ * hasn't emitted `parent_checkpoint` for that message, or the message
+ * arrived via `messages`-channel deltas only and no `values` snapshot
+ * has landed for it yet).
+ */
+declare function injectMessageMetadata(stream: AnyStream, messageId: string | undefined | Signal<string | undefined> | (() => string | undefined)): Signal<MessageMetadata | undefined>;
+//#endregion
+export { type MessageMetadata, type MessageMetadataMap, injectMessageMetadata };
+//# sourceMappingURL=selectors-metadata.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectors-metadata.d.cts","names":[],"sources":["../src/selectors-metadata.ts"],"mappings":";;;;;;;AAiCA;;;;;;;;;;;;;;;;;iBAAgB,qBAAA,CACd,MAAA,EAAQ,SAAA,EACR,SAAA,uBAGI,MAAA,oDAEH,MAAA,CAAO,eAAA"}

package/dist/selectors-metadata.d.ts

@@ -0,0 +1,28 @@
+import { AnyStream } from "./use-stream.js";
+import { Signal } from "@angular/core";
+import { MessageMetadata, MessageMetadataMap } from "@langchain/langgraph-sdk/stream";
+
+//#region src/selectors-metadata.d.ts
+/**
+ * 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
+ * readonly meta = injectMessageMetadata(this.stream, () => this.msg().id);
+ * // meta()?.parentCheckpointId
+ * ```
+ *
+ * `messageId` accepts a raw string, a `Signal<string | undefined>`,
+ * or a plain getter — the binding re-evaluates whenever the id
+ * changes.
+ *
+ * Returns `undefined` when the id isn't known yet (e.g. the server
+ * hasn't emitted `parent_checkpoint` for that message, or the message
+ * arrived via `messages`-channel deltas only and no `values` snapshot
+ * has landed for it yet).
+ */
+declare function injectMessageMetadata(stream: AnyStream, messageId: string | undefined | Signal<string | undefined> | (() => string | undefined)): Signal<MessageMetadata | undefined>;
+//#endregion
+export { type MessageMetadata, type MessageMetadataMap, injectMessageMetadata };
+//# sourceMappingURL=selectors-metadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectors-metadata.d.ts","names":[],"sources":["../src/selectors-metadata.ts"],"mappings":";;;;;;;AAiCA;;;;;;;;;;;;;;;;;iBAAgB,qBAAA,CACd,MAAA,EAAQ,SAAA,EACR,SAAA,uBAGI,MAAA,oDAEH,MAAA,CAAO,eAAA"}

package/dist/selectors-metadata.js

@@ -0,0 +1,39 @@
+import { STREAM_CONTROLLER } from "./use-stream.js";
+import { DestroyRef, computed, inject, isSignal, signal } from "@angular/core";
+//#region src/selectors-metadata.ts
+/**
+* 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
+* readonly meta = injectMessageMetadata(this.stream, () => this.msg().id);
+* // meta()?.parentCheckpointId
+* ```
+*
+* `messageId` accepts a raw string, a `Signal<string | undefined>`,
+* or a plain getter — the binding re-evaluates whenever the id
+* changes.
+*
+* Returns `undefined` when the id isn't known yet (e.g. the server
+* hasn't emitted `parent_checkpoint` for that message, or the message
+* arrived via `messages`-channel deltas only and no `values` snapshot
+* has landed for it yet).
+*/
+function injectMessageMetadata(stream, messageId) {
+	const destroyRef = inject(DestroyRef);
+	const store = stream[STREAM_CONTROLLER].messageMetadataStore;
+	const mapSignal = signal(store.getSnapshot());
+	const unsubscribe = store.subscribe(() => mapSignal.set(store.getSnapshot()));
+	destroyRef.onDestroy(unsubscribe);
+	const read = isSignal(messageId) ? messageId : typeof messageId === "function" ? messageId : () => messageId;
+	return computed(() => {
+		const id = read();
+		if (id == null) return void 0;
+		return mapSignal().get(id);
+	});
+}
+//#endregion
+export { injectMessageMetadata };
+
+//# sourceMappingURL=selectors-metadata.js.map

package/dist/selectors-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors-metadata.js","names":[],"sources":["../src/selectors-metadata.ts"],"sourcesContent":["import {\n  DestroyRef,\n  computed,\n  inject,\n  isSignal,\n  signal,\n  type Signal,\n} from \"@angular/core\";\nimport type {\n  MessageMetadata,\n  MessageMetadataMap,\n} from \"@langchain/langgraph-sdk/stream\";\nimport { STREAM_CONTROLLER, type AnyStream } from \"./use-stream.js\";\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 * readonly meta = injectMessageMetadata(this.stream, () => this.msg().id);\n * // meta()?.parentCheckpointId\n * ```\n *\n * `messageId` accepts a raw string, a `Signal<string | undefined>`,\n * or a plain getter — the binding re-evaluates whenever the id\n * changes.\n *\n * Returns `undefined` when the id isn't known yet (e.g. the server\n * hasn't emitted `parent_checkpoint` for that message, or the message\n * arrived via `messages`-channel deltas only and no `values` snapshot\n * has landed for it yet).\n */\nexport function injectMessageMetadata(\n  stream: AnyStream,\n  messageId:\n    | string\n    | undefined\n    | Signal<string | undefined>\n    | (() => string | undefined)\n): Signal<MessageMetadata | undefined> {\n  const destroyRef = inject(DestroyRef);\n  const store = stream[STREAM_CONTROLLER].messageMetadataStore;\n\n  const mapSignal = signal<MessageMetadataMap>(store.getSnapshot());\n  const unsubscribe = store.subscribe(() => mapSignal.set(store.getSnapshot()));\n  destroyRef.onDestroy(unsubscribe);\n\n  const read: () => string | undefined = isSignal(messageId)\n    ? (messageId as Signal<string | undefined>)\n    : typeof messageId === \"function\"\n      ? (messageId as () => string | undefined)\n      : () => messageId as string | undefined;\n\n  return computed(() => {\n    const id = read();\n    if (id == null) return undefined;\n    return mapSignal().get(id);\n  });\n}\n\nexport type { MessageMetadata, MessageMetadataMap };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,sBACd,QACA,WAKqC;CACrC,MAAM,aAAa,OAAO,WAAW;CACrC,MAAM,QAAQ,OAAO,mBAAmB;CAExC,MAAM,YAAY,OAA2B,MAAM,aAAa,CAAC;CACjE,MAAM,cAAc,MAAM,gBAAgB,UAAU,IAAI,MAAM,aAAa,CAAC,CAAC;AAC7E,YAAW,UAAU,YAAY;CAEjC,MAAM,OAAiC,SAAS,UAAU,GACrD,YACD,OAAO,cAAc,aAClB,kBACK;AAEZ,QAAO,eAAe;EACpB,MAAM,KAAK,MAAM;AACjB,MAAI,MAAM,KAAM,QAAO,KAAA;AACvB,SAAO,WAAW,CAAC,IAAI,GAAG;GAC1B"}