@langchain/svelte 0.4.6 → 1.0.0

package/dist/use-media-url.svelte.cjs

@@ -0,0 +1,54 @@
+//#region src/use-media-url.svelte.ts
+function unwrap(input) {
+	if (typeof input === "function") return input();
+	return input;
+}
+/**
+* Resolve the lazy {@link MediaBase.objectURL} promise into a
+* reactive string suitable for `<audio src>`, `<img src>`,
+* `<video src>`, or `<a download href>`. Reads `.current` for the
+* latest URL, or `undefined` until the promise settles.
+*
+* Lifecycle:
+*  - On first `$effect` (or whenever the supplied `media` value
+*    changes), awaits `media.objectURL` and commits the resolved
+*    string to state.
+*  - On cleanup (or when `media` changes), calls `media.revoke()` to
+*    free the blob-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 URL stays
+*    `undefined`. Surface the failure via `media.error`.
+*
+* `media` accepts a raw handle or a getter so the composable rebinds
+* automatically to the latest media without a manual effect at the
+* call site.
+*/
+function useMediaURL(media) {
+	let url = $state(void 0);
+	$effect(() => {
+		const next = unwrap(media);
+		if (next == null) {
+			url = void 0;
+			return;
+		}
+		let cancelled = false;
+		next.objectURL.then((resolved) => {
+			if (!cancelled) url = resolved;
+		}, () => {});
+		return () => {
+			cancelled = true;
+			url = void 0;
+			try {
+				next.revoke();
+			} catch {}
+		};
+	});
+	return { get current() {
+		return url;
+	} };
+}
+//#endregion
+exports.useMediaURL = useMediaURL;
+
+//# sourceMappingURL=use-media-url.svelte.cjs.map

package/dist/use-media-url.svelte.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-media-url.svelte.cjs","names":[],"sources":["../src/use-media-url.svelte.ts"],"sourcesContent":["import type { MediaBase } from \"@langchain/langgraph-sdk/stream\";\nimport type { ReactiveValue, ValueOrGetter } from \"./use-projection.svelte.js\";\n\nfunction unwrap<T>(input: ValueOrGetter<T>): T {\n  if (typeof input === \"function\") return (input as () => T)();\n  return input;\n}\n\n/**\n * Resolve the lazy {@link MediaBase.objectURL} promise into a\n * reactive string suitable for `<audio src>`, `<img src>`,\n * `<video src>`, or `<a download href>`. Reads `.current` for the\n * latest URL, or `undefined` until the promise settles.\n *\n * Lifecycle:\n *  - On first `$effect` (or whenever the supplied `media` value\n *    changes), awaits `media.objectURL` and commits the resolved\n *    string to state.\n *  - On cleanup (or when `media` changes), calls `media.revoke()` to\n *    free the blob-URL slot. The next consumer that accesses\n *    `media.objectURL` mints a fresh URL from the same `Blob`, so\n *    live re-renders just work.\n *  - If the underlying handle errored before settling, the URL stays\n *    `undefined`. Surface the failure via `media.error`.\n *\n * `media` accepts a raw handle or a getter so the composable rebinds\n * automatically to the latest media without a manual effect at the\n * call site.\n */\nexport function useMediaURL(\n  media: ValueOrGetter<MediaBase | undefined>\n): ReactiveValue<string | undefined> {\n  let url = $state<string | undefined>(undefined);\n\n  $effect(() => {\n    const next = unwrap(media);\n    if (next == null) {\n      url = undefined;\n      return;\n    }\n    let cancelled = false;\n    next.objectURL.then(\n      (resolved) => {\n        if (!cancelled) url = resolved;\n      },\n      () => {\n        // Errors surface via `media.error`; keep `url` undefined so\n        // consumers fall through to a no-src render.\n      }\n    );\n    return () => {\n      cancelled = true;\n      url = undefined;\n      try {\n        next.revoke();\n      } catch {\n        // best-effort\n      }\n    };\n  });\n\n  return {\n    get current() {\n      return url;\n    },\n  };\n}\n"],"mappings":";AAGA,SAAS,OAAU,OAA4B;AAC7C,KAAI,OAAO,UAAU,WAAY,QAAQ,OAAmB;AAC5D,QAAO;;;;;;;;;;;;;;;;;;;;;;;AAwBT,SAAgB,YACd,OACmC;CACnC,IAAI,MAAM,OAA2B,KAAA,EAAU;AAE/C,eAAc;EACZ,MAAM,OAAO,OAAO,MAAM;AAC1B,MAAI,QAAQ,MAAM;AAChB,SAAM,KAAA;AACN;;EAEF,IAAI,YAAY;AAChB,OAAK,UAAU,MACZ,aAAa;AACZ,OAAI,CAAC,UAAW,OAAM;WAElB,GAIP;AACD,eAAa;AACX,eAAY;AACZ,SAAM,KAAA;AACN,OAAI;AACF,SAAK,QAAQ;WACP;;GAIV;AAEF,QAAO,EACL,IAAI,UAAU;AACZ,SAAO;IAEV"}

package/dist/use-media-url.svelte.d.cts

@@ -0,0 +1,29 @@
+import { ReactiveValue, ValueOrGetter } from "./use-projection.svelte.cjs";
+import { MediaBase } from "@langchain/langgraph-sdk/stream";
+
+//#region src/use-media-url.svelte.d.ts
+/**
+ * Resolve the lazy {@link MediaBase.objectURL} promise into a
+ * reactive string suitable for `<audio src>`, `<img src>`,
+ * `<video src>`, or `<a download href>`. Reads `.current` for the
+ * latest URL, or `undefined` until the promise settles.
+ *
+ * Lifecycle:
+ *  - On first `$effect` (or whenever the supplied `media` value
+ *    changes), awaits `media.objectURL` and commits the resolved
+ *    string to state.
+ *  - On cleanup (or when `media` changes), calls `media.revoke()` to
+ *    free the blob-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 URL stays
+ *    `undefined`. Surface the failure via `media.error`.
+ *
+ * `media` accepts a raw handle or a getter so the composable rebinds
+ * automatically to the latest media without a manual effect at the
+ * call site.
+ */
+declare function useMediaURL(media: ValueOrGetter<MediaBase | undefined>): ReactiveValue<string | undefined>;
+//#endregion
+export { useMediaURL };
+//# sourceMappingURL=use-media-url.svelte.d.cts.map

package/dist/use-media-url.svelte.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-media-url.svelte.d.cts","names":[],"sources":["../src/use-media-url.svelte.ts"],"mappings":";;;;;;AA6BA;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,CACd,KAAA,EAAO,aAAA,CAAc,SAAA,gBACpB,aAAA"}

package/dist/use-media-url.svelte.d.ts

@@ -0,0 +1,29 @@
+import { ReactiveValue, ValueOrGetter } from "./use-projection.svelte.js";
+import { MediaBase } from "@langchain/langgraph-sdk/stream";
+
+//#region src/use-media-url.svelte.d.ts
+/**
+ * Resolve the lazy {@link MediaBase.objectURL} promise into a
+ * reactive string suitable for `<audio src>`, `<img src>`,
+ * `<video src>`, or `<a download href>`. Reads `.current` for the
+ * latest URL, or `undefined` until the promise settles.
+ *
+ * Lifecycle:
+ *  - On first `$effect` (or whenever the supplied `media` value
+ *    changes), awaits `media.objectURL` and commits the resolved
+ *    string to state.
+ *  - On cleanup (or when `media` changes), calls `media.revoke()` to
+ *    free the blob-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 URL stays
+ *    `undefined`. Surface the failure via `media.error`.
+ *
+ * `media` accepts a raw handle or a getter so the composable rebinds
+ * automatically to the latest media without a manual effect at the
+ * call site.
+ */
+declare function useMediaURL(media: ValueOrGetter<MediaBase | undefined>): ReactiveValue<string | undefined>;
+//#endregion
+export { useMediaURL };
+//# sourceMappingURL=use-media-url.svelte.d.ts.map

package/dist/use-media-url.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-media-url.svelte.d.ts","names":[],"sources":["../src/use-media-url.svelte.ts"],"mappings":";;;;;;AA6BA;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,CACd,KAAA,EAAO,aAAA,CAAc,SAAA,gBACpB,aAAA"}

package/dist/use-media-url.svelte.js

@@ -0,0 +1,54 @@
+//#region src/use-media-url.svelte.ts
+function unwrap(input) {
+	if (typeof input === "function") return input();
+	return input;
+}
+/**
+* Resolve the lazy {@link MediaBase.objectURL} promise into a
+* reactive string suitable for `<audio src>`, `<img src>`,
+* `<video src>`, or `<a download href>`. Reads `.current` for the
+* latest URL, or `undefined` until the promise settles.
+*
+* Lifecycle:
+*  - On first `$effect` (or whenever the supplied `media` value
+*    changes), awaits `media.objectURL` and commits the resolved
+*    string to state.
+*  - On cleanup (or when `media` changes), calls `media.revoke()` to
+*    free the blob-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 URL stays
+*    `undefined`. Surface the failure via `media.error`.
+*
+* `media` accepts a raw handle or a getter so the composable rebinds
+* automatically to the latest media without a manual effect at the
+* call site.
+*/
+function useMediaURL(media) {
+	let url = $state(void 0);
+	$effect(() => {
+		const next = unwrap(media);
+		if (next == null) {
+			url = void 0;
+			return;
+		}
+		let cancelled = false;
+		next.objectURL.then((resolved) => {
+			if (!cancelled) url = resolved;
+		}, () => {});
+		return () => {
+			cancelled = true;
+			url = void 0;
+			try {
+				next.revoke();
+			} catch {}
+		};
+	});
+	return { get current() {
+		return url;
+	} };
+}
+//#endregion
+export { useMediaURL };
+
+//# sourceMappingURL=use-media-url.svelte.js.map

package/dist/use-media-url.svelte.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-media-url.svelte.js","names":[],"sources":["../src/use-media-url.svelte.ts"],"sourcesContent":["import type { MediaBase } from \"@langchain/langgraph-sdk/stream\";\nimport type { ReactiveValue, ValueOrGetter } from \"./use-projection.svelte.js\";\n\nfunction unwrap<T>(input: ValueOrGetter<T>): T {\n  if (typeof input === \"function\") return (input as () => T)();\n  return input;\n}\n\n/**\n * Resolve the lazy {@link MediaBase.objectURL} promise into a\n * reactive string suitable for `<audio src>`, `<img src>`,\n * `<video src>`, or `<a download href>`. Reads `.current` for the\n * latest URL, or `undefined` until the promise settles.\n *\n * Lifecycle:\n *  - On first `$effect` (or whenever the supplied `media` value\n *    changes), awaits `media.objectURL` and commits the resolved\n *    string to state.\n *  - On cleanup (or when `media` changes), calls `media.revoke()` to\n *    free the blob-URL slot. The next consumer that accesses\n *    `media.objectURL` mints a fresh URL from the same `Blob`, so\n *    live re-renders just work.\n *  - If the underlying handle errored before settling, the URL stays\n *    `undefined`. Surface the failure via `media.error`.\n *\n * `media` accepts a raw handle or a getter so the composable rebinds\n * automatically to the latest media without a manual effect at the\n * call site.\n */\nexport function useMediaURL(\n  media: ValueOrGetter<MediaBase | undefined>\n): ReactiveValue<string | undefined> {\n  let url = $state<string | undefined>(undefined);\n\n  $effect(() => {\n    const next = unwrap(media);\n    if (next == null) {\n      url = undefined;\n      return;\n    }\n    let cancelled = false;\n    next.objectURL.then(\n      (resolved) => {\n        if (!cancelled) url = resolved;\n      },\n      () => {\n        // Errors surface via `media.error`; keep `url` undefined so\n        // consumers fall through to a no-src render.\n      }\n    );\n    return () => {\n      cancelled = true;\n      url = undefined;\n      try {\n        next.revoke();\n      } catch {\n        // best-effort\n      }\n    };\n  });\n\n  return {\n    get current() {\n      return url;\n    },\n  };\n}\n"],"mappings":";AAGA,SAAS,OAAU,OAA4B;AAC7C,KAAI,OAAO,UAAU,WAAY,QAAQ,OAAmB;AAC5D,QAAO;;;;;;;;;;;;;;;;;;;;;;;AAwBT,SAAgB,YACd,OACmC;CACnC,IAAI,MAAM,OAA2B,KAAA,EAAU;AAE/C,eAAc;EACZ,MAAM,OAAO,OAAO,MAAM;AAC1B,MAAI,QAAQ,MAAM;AAChB,SAAM,KAAA;AACN;;EAEF,IAAI,YAAY;AAChB,OAAK,UAAU,MACZ,aAAa;AACZ,OAAI,CAAC,UAAW,OAAM;WAElB,GAIP;AACD,eAAa;AACX,eAAY;AACZ,SAAM,KAAA;AACN,OAAI;AACF,SAAK,QAAQ;WACP;;GAIV;AAEF,QAAO,EACL,IAAI,UAAU;AACZ,SAAO;IAEV"}

package/dist/use-projection.svelte.cjs

@@ -0,0 +1,62 @@
+//#region src/use-projection.svelte.ts
+function unwrap(input) {
+	if (typeof input === "function") return input();
+	return input;
+}
+/**
+* Svelte binding over {@link ChannelRegistry.acquire}. Mirrors the
+* React and Vue `useProjection` primitives with an idiomatic Svelte
+* shape:
+*
+*  - On the first `$effect` run the composable acquires a ref-counted
+*    projection from the registry, seeds the returned `current` with
+*    the current snapshot, and subscribes to the store so templates
+*    auto-update on subsequent snapshots.
+*  - The `$effect` cleanup returned from the effect body runs on both
+*    scope teardown and before the next run, releasing the previous
+*    acquisition (and letting the registry close the underlying
+*    server subscription once the last consumer leaves).
+*  - When the resolved `registry` is `null` / `undefined` the
+*    composable stays at `initialValue`. This is the happy path for
+*    selector composables that short-circuit the root namespace by
+*    reading `stream.messages` / `stream.values` directly — they
+*    don't call `useProjection` at all at the root. Dynamic inputs
+*    that flip from root to scoped can pass `null` for the root case
+*    and fall back to `initialValue`.
+*
+* `registry` and `key` accept plain values or getters. Reading the
+* getter inside `$effect` auto-tracks any `$state` the getter
+* references, so the effect re-runs and re-acquires whenever the
+* resolved target changes.
+*
+* Must be called from a reactive context (a `.svelte` component
+* script or inside `$effect.root`). Calls outside a reactive scope
+* will not receive store updates because `$effect` never fires.
+*/
+function useProjection(registry, specFactory, key, initialValue) {
+	let snapshot = $state(initialValue);
+	$effect(() => {
+		const reg = unwrap(registry);
+		unwrap(key);
+		if (reg == null) {
+			snapshot = initialValue;
+			return;
+		}
+		const acquired = reg.acquire(specFactory());
+		snapshot = acquired.store.getSnapshot();
+		const unsubscribe = acquired.store.subscribe(() => {
+			snapshot = acquired.store.getSnapshot();
+		});
+		return () => {
+			unsubscribe();
+			acquired.release();
+		};
+	});
+	return { get current() {
+		return snapshot;
+	} };
+}
+//#endregion
+exports.useProjection = useProjection;
+
+//# sourceMappingURL=use-projection.svelte.cjs.map

package/dist/use-projection.svelte.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-projection.svelte.cjs","names":[],"sources":["../src/use-projection.svelte.ts"],"sourcesContent":["import type {\n  ChannelRegistry,\n  ProjectionSpec,\n} from \"@langchain/langgraph-sdk/stream\";\n\n/**\n * Accepts either a plain `T` or a getter `() => T`. Selector\n * composables use this to support both static inputs (the common\n * case — `useMessages(stream, subagent)`) and reactive inputs\n * driven by component-level `$state`\n * (`useMessages(stream, () => activeSubagent)`).\n */\nexport type ValueOrGetter<T> = T | (() => T);\n\nfunction unwrap<T>(input: ValueOrGetter<T>): T {\n  if (typeof input === \"function\") return (input as () => T)();\n  return input;\n}\n\n/**\n * Svelte-side handle returned by {@link useProjection} and all\n * single-value selector composables. Consumers read the reactive\n * payload via `proj.current`.\n *\n * Why an object with a `current` getter instead of a bare reactive\n * value:\n *  - Matches Svelte 5's `fromStore(...)` shape — users already know\n *    this pattern.\n *  - Portable across `.svelte` components and `.svelte.ts` modules.\n *    Returning a bare `$state` from a module function loses\n *    reactivity at the module boundary; a stable object with a\n *    getter keeps `$derived` tracking intact.\n *  - Templates read `{messages.current}` as data, not as a function\n *    call (`{messages()}` would be ambiguous in Svelte's template\n *    grammar).\n */\nexport interface ReactiveValue<T> {\n  readonly current: T;\n}\n\n/**\n * Svelte binding over {@link ChannelRegistry.acquire}. Mirrors the\n * React and Vue `useProjection` primitives with an idiomatic Svelte\n * shape:\n *\n *  - On the first `$effect` run the composable acquires a ref-counted\n *    projection from the registry, seeds the returned `current` with\n *    the current snapshot, and subscribes to the store so templates\n *    auto-update on subsequent snapshots.\n *  - The `$effect` cleanup returned from the effect body runs on both\n *    scope teardown and before the next run, releasing the previous\n *    acquisition (and letting the registry close the underlying\n *    server subscription once the last consumer leaves).\n *  - When the resolved `registry` is `null` / `undefined` the\n *    composable stays at `initialValue`. This is the happy path for\n *    selector composables that short-circuit the root namespace by\n *    reading `stream.messages` / `stream.values` directly — they\n *    don't call `useProjection` at all at the root. Dynamic inputs\n *    that flip from root to scoped can pass `null` for the root case\n *    and fall back to `initialValue`.\n *\n * `registry` and `key` accept plain values or getters. Reading the\n * getter inside `$effect` auto-tracks any `$state` the getter\n * references, so the effect re-runs and re-acquires whenever the\n * resolved target changes.\n *\n * Must be called from a reactive context (a `.svelte` component\n * script or inside `$effect.root`). Calls outside a reactive scope\n * will not receive store updates because `$effect` never fires.\n */\nexport function useProjection<T>(\n  registry: ValueOrGetter<ChannelRegistry | null | undefined>,\n  specFactory: () => ProjectionSpec<T>,\n  key: ValueOrGetter<string>,\n  initialValue: T\n): ReactiveValue<T> {\n  let snapshot = $state<T>(initialValue);\n\n  $effect(() => {\n    const reg = unwrap(registry);\n    // Reading `key` inside the effect auto-tracks any `$state` the\n    // getter references so the effect re-runs when it changes.\n    // The resolved value itself is not used beyond this read because\n    // the registry is content-addressed by spec; the key is purely a\n    // reactivity anchor for Svelte.\n    unwrap(key);\n\n    if (reg == null) {\n      snapshot = initialValue;\n      return;\n    }\n\n    const acquired = reg.acquire(specFactory());\n    snapshot = acquired.store.getSnapshot();\n    const unsubscribe = acquired.store.subscribe(() => {\n      snapshot = acquired.store.getSnapshot();\n    });\n\n    return () => {\n      unsubscribe();\n      acquired.release();\n    };\n  });\n\n  return {\n    get current() {\n      return snapshot;\n    },\n  };\n}\n"],"mappings":";AAcA,SAAS,OAAU,OAA4B;AAC7C,KAAI,OAAO,UAAU,WAAY,QAAQ,OAAmB;AAC5D,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDT,SAAgB,cACd,UACA,aACA,KACA,cACkB;CAClB,IAAI,WAAW,OAAU,aAAa;AAEtC,eAAc;EACZ,MAAM,MAAM,OAAO,SAAS;AAM5B,SAAO,IAAI;AAEX,MAAI,OAAO,MAAM;AACf,cAAW;AACX;;EAGF,MAAM,WAAW,IAAI,QAAQ,aAAa,CAAC;AAC3C,aAAW,SAAS,MAAM,aAAa;EACvC,MAAM,cAAc,SAAS,MAAM,gBAAgB;AACjD,cAAW,SAAS,MAAM,aAAa;IACvC;AAEF,eAAa;AACX,gBAAa;AACb,YAAS,SAAS;;GAEpB;AAEF,QAAO,EACL,IAAI,UAAU;AACZ,SAAO;IAEV"}

package/dist/use-projection.svelte.d.cts

@@ -0,0 +1,65 @@
+import { ChannelRegistry, ProjectionSpec } from "@langchain/langgraph-sdk/stream";
+
+//#region src/use-projection.svelte.d.ts
+/**
+ * Accepts either a plain `T` or a getter `() => T`. Selector
+ * composables use this to support both static inputs (the common
+ * case — `useMessages(stream, subagent)`) and reactive inputs
+ * driven by component-level `$state`
+ * (`useMessages(stream, () => activeSubagent)`).
+ */
+type ValueOrGetter<T> = T | (() => T);
+/**
+ * Svelte-side handle returned by {@link useProjection} and all
+ * single-value selector composables. Consumers read the reactive
+ * payload via `proj.current`.
+ *
+ * Why an object with a `current` getter instead of a bare reactive
+ * value:
+ *  - Matches Svelte 5's `fromStore(...)` shape — users already know
+ *    this pattern.
+ *  - Portable across `.svelte` components and `.svelte.ts` modules.
+ *    Returning a bare `$state` from a module function loses
+ *    reactivity at the module boundary; a stable object with a
+ *    getter keeps `$derived` tracking intact.
+ *  - Templates read `{messages.current}` as data, not as a function
+ *    call (`{messages()}` would be ambiguous in Svelte's template
+ *    grammar).
+ */
+interface ReactiveValue<T> {
+  readonly current: T;
+}
+/**
+ * Svelte binding over {@link ChannelRegistry.acquire}. Mirrors the
+ * React and Vue `useProjection` primitives with an idiomatic Svelte
+ * shape:
+ *
+ *  - On the first `$effect` run the composable acquires a ref-counted
+ *    projection from the registry, seeds the returned `current` with
+ *    the current snapshot, and subscribes to the store so templates
+ *    auto-update on subsequent snapshots.
+ *  - The `$effect` cleanup returned from the effect body runs on both
+ *    scope teardown and before the next run, releasing the previous
+ *    acquisition (and letting the registry close the underlying
+ *    server subscription once the last consumer leaves).
+ *  - When the resolved `registry` is `null` / `undefined` the
+ *    composable stays at `initialValue`. This is the happy path for
+ *    selector composables that short-circuit the root namespace by
+ *    reading `stream.messages` / `stream.values` directly — they
+ *    don't call `useProjection` at all at the root. Dynamic inputs
+ *    that flip from root to scoped can pass `null` for the root case
+ *    and fall back to `initialValue`.
+ *
+ * `registry` and `key` accept plain values or getters. Reading the
+ * getter inside `$effect` auto-tracks any `$state` the getter
+ * references, so the effect re-runs and re-acquires whenever the
+ * resolved target changes.
+ *
+ * Must be called from a reactive context (a `.svelte` component
+ * script or inside `$effect.root`). Calls outside a reactive scope
+ * will not receive store updates because `$effect` never fires.
+ */
+declare function useProjection<T>(registry: ValueOrGetter<ChannelRegistry | null | undefined>, specFactory: () => ProjectionSpec<T>, key: ValueOrGetter<string>, initialValue: T): ReactiveValue<T>;
+//#endregion
+export { ReactiveValue, ValueOrGetter, useProjection };
+//# sourceMappingURL=use-projection.svelte.d.cts.map

package/dist/use-projection.svelte.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-projection.svelte.d.cts","names":[],"sources":["../src/use-projection.svelte.ts"],"mappings":";;;;;AAYA;;;;;KAAY,aAAA,MAAmB,CAAA,UAAW,CAAA;;;;AAwB1C;;;;;;;;;AAkCA;;;;;UAlCiB,aAAA;EAAA,SACN,OAAA,EAAS,CAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCJ,aAAA,GAAA,CACd,QAAA,EAAU,aAAA,CAAc,eAAA,sBACxB,WAAA,QAAmB,cAAA,CAAe,CAAA,GAClC,GAAA,EAAK,aAAA,UACL,YAAA,EAAc,CAAA,GACb,aAAA,CAAc,CAAA"}

package/dist/use-projection.svelte.d.ts

@@ -0,0 +1,65 @@
+import { ChannelRegistry, ProjectionSpec } from "@langchain/langgraph-sdk/stream";
+
+//#region src/use-projection.svelte.d.ts
+/**
+ * Accepts either a plain `T` or a getter `() => T`. Selector
+ * composables use this to support both static inputs (the common
+ * case — `useMessages(stream, subagent)`) and reactive inputs
+ * driven by component-level `$state`
+ * (`useMessages(stream, () => activeSubagent)`).
+ */
+type ValueOrGetter<T> = T | (() => T);
+/**
+ * Svelte-side handle returned by {@link useProjection} and all
+ * single-value selector composables. Consumers read the reactive
+ * payload via `proj.current`.
+ *
+ * Why an object with a `current` getter instead of a bare reactive
+ * value:
+ *  - Matches Svelte 5's `fromStore(...)` shape — users already know
+ *    this pattern.
+ *  - Portable across `.svelte` components and `.svelte.ts` modules.
+ *    Returning a bare `$state` from a module function loses
+ *    reactivity at the module boundary; a stable object with a
+ *    getter keeps `$derived` tracking intact.
+ *  - Templates read `{messages.current}` as data, not as a function
+ *    call (`{messages()}` would be ambiguous in Svelte's template
+ *    grammar).
+ */
+interface ReactiveValue<T> {
+  readonly current: T;
+}
+/**
+ * Svelte binding over {@link ChannelRegistry.acquire}. Mirrors the
+ * React and Vue `useProjection` primitives with an idiomatic Svelte
+ * shape:
+ *
+ *  - On the first `$effect` run the composable acquires a ref-counted
+ *    projection from the registry, seeds the returned `current` with
+ *    the current snapshot, and subscribes to the store so templates
+ *    auto-update on subsequent snapshots.
+ *  - The `$effect` cleanup returned from the effect body runs on both
+ *    scope teardown and before the next run, releasing the previous
+ *    acquisition (and letting the registry close the underlying
+ *    server subscription once the last consumer leaves).
+ *  - When the resolved `registry` is `null` / `undefined` the
+ *    composable stays at `initialValue`. This is the happy path for
+ *    selector composables that short-circuit the root namespace by
+ *    reading `stream.messages` / `stream.values` directly — they
+ *    don't call `useProjection` at all at the root. Dynamic inputs
+ *    that flip from root to scoped can pass `null` for the root case
+ *    and fall back to `initialValue`.
+ *
+ * `registry` and `key` accept plain values or getters. Reading the
+ * getter inside `$effect` auto-tracks any `$state` the getter
+ * references, so the effect re-runs and re-acquires whenever the
+ * resolved target changes.
+ *
+ * Must be called from a reactive context (a `.svelte` component
+ * script or inside `$effect.root`). Calls outside a reactive scope
+ * will not receive store updates because `$effect` never fires.
+ */
+declare function useProjection<T>(registry: ValueOrGetter<ChannelRegistry | null | undefined>, specFactory: () => ProjectionSpec<T>, key: ValueOrGetter<string>, initialValue: T): ReactiveValue<T>;
+//#endregion
+export { ReactiveValue, ValueOrGetter, useProjection };
+//# sourceMappingURL=use-projection.svelte.d.ts.map

package/dist/use-projection.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-projection.svelte.d.ts","names":[],"sources":["../src/use-projection.svelte.ts"],"mappings":";;;;;AAYA;;;;;KAAY,aAAA,MAAmB,CAAA,UAAW,CAAA;;;;AAwB1C;;;;;;;;;AAkCA;;;;;UAlCiB,aAAA;EAAA,SACN,OAAA,EAAS,CAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCJ,aAAA,GAAA,CACd,QAAA,EAAU,aAAA,CAAc,eAAA,sBACxB,WAAA,QAAmB,cAAA,CAAe,CAAA,GAClC,GAAA,EAAK,aAAA,UACL,YAAA,EAAc,CAAA,GACb,aAAA,CAAc,CAAA"}

package/dist/use-projection.svelte.js

@@ -0,0 +1,62 @@
+//#region src/use-projection.svelte.ts
+function unwrap(input) {
+	if (typeof input === "function") return input();
+	return input;
+}
+/**
+* Svelte binding over {@link ChannelRegistry.acquire}. Mirrors the
+* React and Vue `useProjection` primitives with an idiomatic Svelte
+* shape:
+*
+*  - On the first `$effect` run the composable acquires a ref-counted
+*    projection from the registry, seeds the returned `current` with
+*    the current snapshot, and subscribes to the store so templates
+*    auto-update on subsequent snapshots.
+*  - The `$effect` cleanup returned from the effect body runs on both
+*    scope teardown and before the next run, releasing the previous
+*    acquisition (and letting the registry close the underlying
+*    server subscription once the last consumer leaves).
+*  - When the resolved `registry` is `null` / `undefined` the
+*    composable stays at `initialValue`. This is the happy path for
+*    selector composables that short-circuit the root namespace by
+*    reading `stream.messages` / `stream.values` directly — they
+*    don't call `useProjection` at all at the root. Dynamic inputs
+*    that flip from root to scoped can pass `null` for the root case
+*    and fall back to `initialValue`.
+*
+* `registry` and `key` accept plain values or getters. Reading the
+* getter inside `$effect` auto-tracks any `$state` the getter
+* references, so the effect re-runs and re-acquires whenever the
+* resolved target changes.
+*
+* Must be called from a reactive context (a `.svelte` component
+* script or inside `$effect.root`). Calls outside a reactive scope
+* will not receive store updates because `$effect` never fires.
+*/
+function useProjection(registry, specFactory, key, initialValue) {
+	let snapshot = $state(initialValue);
+	$effect(() => {
+		const reg = unwrap(registry);
+		unwrap(key);
+		if (reg == null) {
+			snapshot = initialValue;
+			return;
+		}
+		const acquired = reg.acquire(specFactory());
+		snapshot = acquired.store.getSnapshot();
+		const unsubscribe = acquired.store.subscribe(() => {
+			snapshot = acquired.store.getSnapshot();
+		});
+		return () => {
+			unsubscribe();
+			acquired.release();
+		};
+	});
+	return { get current() {
+		return snapshot;
+	} };
+}
+//#endregion
+export { useProjection };
+
+//# sourceMappingURL=use-projection.svelte.js.map

package/dist/use-projection.svelte.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-projection.svelte.js","names":[],"sources":["../src/use-projection.svelte.ts"],"sourcesContent":["import type {\n  ChannelRegistry,\n  ProjectionSpec,\n} from \"@langchain/langgraph-sdk/stream\";\n\n/**\n * Accepts either a plain `T` or a getter `() => T`. Selector\n * composables use this to support both static inputs (the common\n * case — `useMessages(stream, subagent)`) and reactive inputs\n * driven by component-level `$state`\n * (`useMessages(stream, () => activeSubagent)`).\n */\nexport type ValueOrGetter<T> = T | (() => T);\n\nfunction unwrap<T>(input: ValueOrGetter<T>): T {\n  if (typeof input === \"function\") return (input as () => T)();\n  return input;\n}\n\n/**\n * Svelte-side handle returned by {@link useProjection} and all\n * single-value selector composables. Consumers read the reactive\n * payload via `proj.current`.\n *\n * Why an object with a `current` getter instead of a bare reactive\n * value:\n *  - Matches Svelte 5's `fromStore(...)` shape — users already know\n *    this pattern.\n *  - Portable across `.svelte` components and `.svelte.ts` modules.\n *    Returning a bare `$state` from a module function loses\n *    reactivity at the module boundary; a stable object with a\n *    getter keeps `$derived` tracking intact.\n *  - Templates read `{messages.current}` as data, not as a function\n *    call (`{messages()}` would be ambiguous in Svelte's template\n *    grammar).\n */\nexport interface ReactiveValue<T> {\n  readonly current: T;\n}\n\n/**\n * Svelte binding over {@link ChannelRegistry.acquire}. Mirrors the\n * React and Vue `useProjection` primitives with an idiomatic Svelte\n * shape:\n *\n *  - On the first `$effect` run the composable acquires a ref-counted\n *    projection from the registry, seeds the returned `current` with\n *    the current snapshot, and subscribes to the store so templates\n *    auto-update on subsequent snapshots.\n *  - The `$effect` cleanup returned from the effect body runs on both\n *    scope teardown and before the next run, releasing the previous\n *    acquisition (and letting the registry close the underlying\n *    server subscription once the last consumer leaves).\n *  - When the resolved `registry` is `null` / `undefined` the\n *    composable stays at `initialValue`. This is the happy path for\n *    selector composables that short-circuit the root namespace by\n *    reading `stream.messages` / `stream.values` directly — they\n *    don't call `useProjection` at all at the root. Dynamic inputs\n *    that flip from root to scoped can pass `null` for the root case\n *    and fall back to `initialValue`.\n *\n * `registry` and `key` accept plain values or getters. Reading the\n * getter inside `$effect` auto-tracks any `$state` the getter\n * references, so the effect re-runs and re-acquires whenever the\n * resolved target changes.\n *\n * Must be called from a reactive context (a `.svelte` component\n * script or inside `$effect.root`). Calls outside a reactive scope\n * will not receive store updates because `$effect` never fires.\n */\nexport function useProjection<T>(\n  registry: ValueOrGetter<ChannelRegistry | null | undefined>,\n  specFactory: () => ProjectionSpec<T>,\n  key: ValueOrGetter<string>,\n  initialValue: T\n): ReactiveValue<T> {\n  let snapshot = $state<T>(initialValue);\n\n  $effect(() => {\n    const reg = unwrap(registry);\n    // Reading `key` inside the effect auto-tracks any `$state` the\n    // getter references so the effect re-runs when it changes.\n    // The resolved value itself is not used beyond this read because\n    // the registry is content-addressed by spec; the key is purely a\n    // reactivity anchor for Svelte.\n    unwrap(key);\n\n    if (reg == null) {\n      snapshot = initialValue;\n      return;\n    }\n\n    const acquired = reg.acquire(specFactory());\n    snapshot = acquired.store.getSnapshot();\n    const unsubscribe = acquired.store.subscribe(() => {\n      snapshot = acquired.store.getSnapshot();\n    });\n\n    return () => {\n      unsubscribe();\n      acquired.release();\n    };\n  });\n\n  return {\n    get current() {\n      return snapshot;\n    },\n  };\n}\n"],"mappings":";AAcA,SAAS,OAAU,OAA4B;AAC7C,KAAI,OAAO,UAAU,WAAY,QAAQ,OAAmB;AAC5D,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDT,SAAgB,cACd,UACA,aACA,KACA,cACkB;CAClB,IAAI,WAAW,OAAU,aAAa;AAEtC,eAAc;EACZ,MAAM,MAAM,OAAO,SAAS;AAM5B,SAAO,IAAI;AAEX,MAAI,OAAO,MAAM;AACf,cAAW;AACX;;EAGF,MAAM,WAAW,IAAI,QAAQ,aAAa,CAAC;AAC3C,aAAW,SAAS,MAAM,aAAa;EACvC,MAAM,cAAc,SAAS,MAAM,gBAAgB;AACjD,cAAW,SAAS,MAAM,aAAa;IACvC;AAEF,eAAa;AACX,gBAAa;AACb,YAAS,SAAS;;GAEpB;AAEF,QAAO,EACL,IAAI,UAAU;AACZ,SAAO;IAEV"}