ilha 0.14.6 → 0.14.8

package/README.md

@@ -51,7 +51,7 @@ count.update((n) => n + 1); // patch
 In JSX, `{count}` subscribes the render. Derived values use Effect's `Atom.map` or `Atom.transform`:
 
 ```tsx
-import * as Atom from "effect/unstable/reactivity/Atom";
+import * as Atom from "effect/reactivity/Atom";
 import { atom } from "ilha";
 
 const items = atom([{ n: 1 }, { n: 2 }]);
@@ -74,7 +74,7 @@ Paint [Effect `Stream`](https://www.effect.website/docs/v4/api/effect/Stream) va
 
 ```tsx
 import * as Stream from "effect/Stream";
-import * as Atom from "effect/unstable/reactivity/Atom";
+import * as Atom from "effect/reactivity/Atom";
 import { atom } from "ilha";
 
 function* List() {

package/dist/define.d.ts

@@ -1,4 +1,4 @@
-import { n as Component } from "./types-CyoYWhJf.js";
+import { i as Component } from "./types-CJF2qMK6.js";
 //#region src/define.d.ts
 declare const define: (name: string, component: Component) => void;
 //#endregion

package/dist/define.js

@@ -1,4 +1,4 @@
-import { t as mount } from "./mount-DiIEX8s7.js";
+import { t as mount } from "./mount-BQ-zcg2x.js";
 
 //#region src/define.ts
 const define = (name, component) => {

package/dist/index.d.ts

@@ -1,34 +1,11 @@
-import { a as Instruction, c as UnsafeHtml, d as Yielded, i as Fragment, n as Component, t as AtomHandle, u as View } from "./types-CyoYWhJf.js";
-import { t as h } from "./vnode-C_BdUnIA.js";
-import * as Effect from "effect/Effect";
-import * as Stream from "effect/Stream";
-import * as Atom from "effect/unstable/reactivity/Atom";
+import { S as Yielded, b as WatchContext, c as EventSourceStatus, g as UnsafeHtml, h as ResourceOptions, i as Component, l as Fragment, m as ResourceFetcher, n as AtomHandle, o as EventSourceFeed, p as Resource, r as AtomOptions, s as EventSourceOptions, t as AtomEquality, u as Instruction, v as View, x as WatchOnceCleanup, y as WatchCallback } from "./types-CJF2qMK6.js";
+import { t as h } from "./vnode-CUTNGblA.js";
+import * as Atom from "effect/reactivity/Atom";
+import { Equal } from "effect";
+import * as Effect$1 from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import { AtomRegistry } from "effect/reactivity/AtomRegistry";
 import "effect/Scope";
-import { AtomRegistry } from "effect/unstable/reactivity/AtomRegistry";
-//#region src/watch.d.ts
-/** Values delivered to watch callbacks. */
-type WatchValue = string | number | boolean | bigint | null | undefined | readonly WatchValue[] | WatchRecord;
-interface WatchRecord {
-  readonly [key: string]: WatchValue | undefined;
-}
-/** Optional disposer returned from `watch.once`. */
-type WatchOnceCleanup = () => void;
-interface WatchFn {
-  <A extends WatchValue>(source: AtomHandle<A> | Atom.Atom<A> | Stream.Stream<A, unknown, unknown>, fn: (value: A) => void): Instruction<undefined>;
-  once: (fn: () => WatchOnceCleanup | undefined) => Instruction<undefined>;
-}
-declare const watch: WatchFn;
-//#endregion
-//#region src/atom.d.ts
-/** Read atoms inside `fn` without subscribing the active render. Sync only. */
-declare const untrack: <A>(fn: () => A) => A;
-interface AtomFn {
-  <A>(init: A | Atom.Atom<A> | Effect.Effect<A, unknown, AtomRegistry> | Stream.Stream<A, unknown, AtomRegistry>): AtomHandle<A>;
-  lazy: <A>(init: () => A) => AtomHandle<A>;
-}
-declare const atom: AtomFn;
-declare const batch: (f: () => void) => void;
-//#endregion
 //#region src/context.d.ts
 interface ContextProviderProps<A> {
   value: A;
@@ -57,8 +34,52 @@ interface ErrorBoundaryProps {
 /** Catch subtree failures and paint a fallback. Supports reset(). */
 declare const ErrorBoundary: (props: ErrorBoundaryProps) => View;
 //#endregion
+//#region src/watch.d.ts
+/** Values delivered to watch callbacks. */
+type WatchValue = string | number | boolean | bigint | null | undefined | readonly WatchValue[] | WatchRecord;
+interface WatchRecord {
+  readonly [key: string]: WatchValue | undefined;
+}
+interface WatchFn {
+  <A extends WatchValue>(source: AtomHandle<A> | Atom.Atom<A> | Stream$1.Stream<A, unknown, unknown>, fn: WatchCallback<A>): Instruction<undefined>;
+  once: (fn: (ctx: WatchContext) => WatchOnceCleanup | undefined | Promise<WatchOnceCleanup | undefined>) => Instruction<undefined>;
+}
+declare const watch: WatchFn;
+//#endregion
+//#region src/atom.d.ts
+/** Key-order-insensitive deep equality for JSON-shaped values. */
+declare const structuralEqual: typeof Equal.equals;
+/** Read atoms inside `fn` without subscribing the active render. Sync only. */
+declare const untrack: <A>(fn: () => A) => A;
+interface AtomFn {
+  <A>(init: A | Atom.Atom<A> | Effect$1.Effect<A, unknown, AtomRegistry> | Stream$1.Stream<A, unknown, AtomRegistry>, options?: AtomOptions<A>): AtomHandle<A>;
+  lazy: <A>(init: () => A) => AtomHandle<A>;
+}
+declare const atom: AtomFn;
+declare const batch: (f: () => void) => void;
+//#endregion
+//#region src/resource.d.ts
+/** Drop the cached value for `key` and refetch it in live components. */
+declare const invalidate: (key: string) => void;
+/**
+ * Fetch-once, share-everywhere async state for `key`. Concurrent mounts
+ * dedupe on one in-flight request; remounts seed from the shared cache
+ * (and revalidate when `staleWhileRevalidate` holds). Call unconditionally
+ * at the top level of a sync component, before any `await`.
+ */
+declare const resource: <T>(key: string, fetcher: ResourceFetcher<T>, opts?: ResourceOptions) => Resource<T>;
+//#endregion
+//#region src/sse.d.ts
+/**
+ * Subscribe to server-sent events. Opens one connection per `(url, event)`
+ * per component, reconnects with backoff, and closes on unmount. SSR renders
+ * an empty stream with status `"closed"`. Call unconditionally at the top
+ * level of a component.
+ */
+declare const fromEventSource: <T = string>(url: string, opts?: EventSourceOptions<T>) => EventSourceFeed<T>;
+//#endregion
 //#region src/when.d.ts
-declare const when: <A, E = never, R = never>(stream: Stream.Stream<A, E, R>, body: (value: A) => Generator<Yielded, View | undefined, View>) => Instruction<undefined, E>;
+declare const when: <A, E = never, R = never>(stream: Stream$1.Stream<A, E, R>, body: (value: A) => Generator<Yielded, View | undefined, View>) => Instruction<undefined, E>;
 //#endregion
 //#region src/mount.d.ts
 interface RenderToStringOptions {
@@ -85,4 +106,4 @@ declare const renderToString: (fn: Component, opts?: RenderToStringOptions) => P
  */
 declare const unsafe: (html: string) => UnsafeHtml;
 //#endregion
-export { type AtomHandle, type Component, type ContextProviderProps, ErrorBoundary, type ErrorBoundaryProps, type ErrorFallback, type ErrorFallbackProps, Fragment, type IlhaContext, type MountOptions, type RenderToStringOptions, type UnsafeHtml, type View, type WatchOnceCleanup, atom, batch, context, createContext, h, mount, renderToString, unsafe, untrack, watch, when };
+export { type AtomEquality, type AtomHandle, type AtomOptions, type Component, type ContextProviderProps, ErrorBoundary, type ErrorBoundaryProps, type ErrorFallback, type ErrorFallbackProps, type EventSourceFeed, type EventSourceOptions, type EventSourceStatus, Fragment, type IlhaContext, type MountOptions, type RenderToStringOptions, type Resource, type ResourceFetcher, type ResourceOptions, type UnsafeHtml, type View, type WatchCallback, type WatchContext, type WatchOnceCleanup, atom, batch, context, createContext, fromEventSource, h, invalidate, mount, renderToString, resource, structuralEqual, unsafe, untrack, watch, when };

package/dist/index.js

@@ -1,12 +1,13 @@
-import { a as interpret, c as handleOwner, d as untrack, f as wrapHandle, g as makeFiber, h as getFiber, i as runSetup, l as instr, m as closeFiber, n as renderToString, o as atom, p as clearFiberView, r as unsafe, s as batch, t as mount, u as isAtomHandle } from "./mount-DiIEX8s7.js";
-import { d as errorView, i as Fragment, p as isFunction, t as h } from "./vnode-DEMDQ0eA.js";
+import { _ as makeFiber, a as interpret, c as handleOwner, d as structuralEqual, f as untrack, g as getFiber, h as closeFiber, i as runSetup, l as instr, m as clearFiberView, n as renderToString, o as atom, p as wrapHandle, r as unsafe, s as batch, t as mount, u as isAtomHandle } from "./mount-BQ-zcg2x.js";
+import { d as errorView, g as isString, i as Fragment, p as isFunction, t as h } from "./vnode-M-oJMKcv.js";
+import * as Atom from "effect/reactivity/Atom";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
-import * as Atom from "effect/unstable/reactivity/Atom";
 import * as Exit from "effect/Exit";
 import * as Fiber from "effect/Fiber";
+import * as Registry from "effect/reactivity/AtomRegistry";
 import * as Scope from "effect/Scope";
-import * as Registry from "effect/unstable/reactivity/AtomRegistry";
+import * as Queue from "effect/Queue";
 
 //#region src/context.ts
 const defaults = /* @__PURE__ */ new WeakMap();
@@ -77,6 +78,56 @@ const ErrorBoundary = (props) => {
 //#endregion
 //#region src/watch.ts
 const WATCH_ONCE = Symbol("ilha.watch.once");
+const newRunCell = () => ({
+	cleanup: void 0,
+	ctrl: null,
+	extra: [],
+	gen: 0
+});
+const cancelRun = (cell) => {
+	cell.gen += 1;
+	cell.ctrl?.abort();
+	cell.ctrl = null;
+	const run = cell.cleanup;
+	cell.cleanup = void 0;
+	run?.();
+	for (const extra of cell.extra.splice(0)) extra();
+};
+const asCleanup = (value) => isFunction(value) ? value : void 0;
+const settleAsync = async (cell, gen, out) => {
+	try {
+		const c = await out;
+		if (cell.gen === gen) cell.cleanup = asCleanup(c);
+		else asCleanup(c)?.();
+	} catch (error) {
+		console.error(error);
+	}
+};
+const settleRun = (cell, gen, out) => {
+	if (out instanceof Promise) {
+		settleAsync(cell, gen, out);
+		return;
+	}
+	if (cell.gen === gen) cell.cleanup = asCleanup(out);
+	else asCleanup(out)?.();
+};
+const runWithSignal = (cell, fn) => {
+	cancelRun(cell);
+	const { gen } = cell;
+	const ctrl = new AbortController();
+	cell.ctrl = ctrl;
+	const ctx = {
+		onCleanup: (extra) => {
+			if (ctrl.signal.aborted || cell.gen !== gen) {
+				extra();
+				return;
+			}
+			cell.extra.push(extra);
+		},
+		signal: ctrl.signal
+	};
+	settleRun(cell, gen, fn(ctx));
+};
 const runStreamWatch = (fiber, effect) => {
 	const scope = Scope.forkUnsafe(fiber.scope);
 	const provided = effect.pipe(Effect.provideService(Registry.AtomRegistry, fiber.registry));
@@ -110,7 +161,28 @@ const useWatchSlot = (fiber, key, mount, fn) => {
 		key
 	};
 };
+const sourceCells = /* @__PURE__ */ new WeakMap();
 const registerWatch = (fiber, source, fn) => {
+	const slot = fiber.watchI ?? 0;
+	let cells = sourceCells.get(fiber);
+	if (!cells) {
+		cells = [];
+		sourceCells.set(fiber, cells);
+	}
+	const entry = cells[slot] ?? {
+		cell: newRunCell(),
+		fn: void 0
+	};
+	cells[slot] = entry;
+	entry.fn = fn;
+	const { cell } = entry;
+	const wrapped = (value) => {
+		const latest = entry.fn ?? fn;
+		runWithSignal(cell, (ctx) => latest(value, ctx));
+	};
+	const disposeCell = () => {
+		cancelRun(cell);
+	};
 	if (Stream.isStream(source)) {
 		useWatchSlot(fiber, source, (run) => {
 			let active = true;
@@ -119,15 +191,22 @@ const registerWatch = (fiber, source, fn) => {
 			})));
 			return () => {
 				active = false;
+				disposeCell();
 				stop();
 			};
-		}, fn);
+		}, wrapped);
 		return;
 	}
 	const atom = isAtomHandle(source) ? source.atom : source;
-	useWatchSlot(fiber, atom, (run) => fiber.registry.subscribe(atom, run, { immediate: true }), fn);
+	useWatchSlot(fiber, atom, (run) => {
+		const unsub = fiber.registry.subscribe(atom, run, { immediate: true });
+		return () => {
+			disposeCell();
+			unsub();
+		};
+	}, wrapped);
 };
-/** Run `fn` once on mount. Return a function to clean up on unmount. */
+/** Run `fn` once on mount. Return a function (or a promise of one) to clean up on unmount. */
 const watchOnce = (fn) => {
 	const fiber = getFiber();
 	const i = fiber.watchI ?? 0;
@@ -139,12 +218,11 @@ const watchOnce = (fn) => {
 		existing.dispose();
 		fiber.watchSlots[i] = void 0;
 	}
-	let cleanup = fn();
+	const cell = newRunCell();
+	runWithSignal(cell, fn);
 	fiber.watchSlots[i] = {
 		dispose: () => {
-			const run = cleanup;
-			cleanup = void 0;
-			run?.();
+			cancelRun(cell);
 		},
 		key: WATCH_ONCE
 	};
@@ -158,6 +236,381 @@ const watchSource = (source, fn) => {
 };
 const watch = Object.assign(watchSource, { once: watchOnce });
 
+//#endregion
+//#region src/resource.ts
+const sharedCache = /* @__PURE__ */ new Map();
+const liveRefetchers = /* @__PURE__ */ new Map();
+const cells$1 = /* @__PURE__ */ new WeakMap();
+const entryFor = (key) => sharedCache.get(key);
+/** Drop the cached value for `key` and refetch it in live components. */
+const invalidate = (key) => {
+	sharedCache.delete(key);
+	const live = liveRefetchers.get(key);
+	if (!live) return;
+	for (const refetch of live) refetch();
+};
+/**
+* Fetch-once, share-everywhere async state for `key`. Concurrent mounts
+* dedupe on one in-flight request; remounts seed from the shared cache
+* (and revalidate when `staleWhileRevalidate` holds). Call unconditionally
+* at the top level of a sync component, before any `await`.
+*/
+const resource = (key, fetcher, opts) => {
+	const fiber = getFiber();
+	const data = atom(void 0);
+	const error = atom(void 0);
+	const loading = atom(true);
+	let byKey = cells$1.get(fiber);
+	if (!byKey) {
+		byKey = /* @__PURE__ */ new Map();
+		cells$1.set(fiber, byKey);
+	}
+	if (fiber.runtime.ssr) {
+		let ssrCell = byKey.get(key);
+		if (!ssrCell) {
+			const { runtime } = fiber;
+			const sc = {
+				ctrl: null,
+				refetch: async () => {
+					sc.ctrl?.abort();
+					const ctrl = new AbortController();
+					sc.ctrl = ctrl;
+					sc.sink.loading.set(true);
+					runtime.begin();
+					try {
+						const v = await fetcher(key, { signal: ctrl.signal });
+						if (!ctrl.signal.aborted) {
+							sc.sink.data.set(v);
+							sc.sink.error.set(void 0);
+							sc.sink.loading.set(false);
+						}
+						return v;
+					} catch (fetchError) {
+						if (!ctrl.signal.aborted) {
+							sc.sink.error.set(fetchError);
+							sc.sink.loading.set(false);
+						}
+						throw fetchError;
+					} finally {
+						runtime.end();
+					}
+				},
+				sink: {
+					data,
+					error,
+					loading
+				}
+			};
+			Effect.runSync(Scope.addFinalizer(fiber.scope, Effect.sync(() => sc.ctrl?.abort())));
+			byKey.set(key, sc);
+			ssrCell = sc;
+			const settleSsr = async () => {
+				try {
+					await sc.refetch();
+				} catch {}
+			};
+			settleSsr();
+		}
+		ssrCell.sink = {
+			data,
+			error,
+			loading
+		};
+		return {
+			data,
+			error,
+			loading,
+			refetch: ssrCell.refetch
+		};
+	}
+	let cell = byKey.get(key);
+	if (!cell) {
+		cell = {
+			alive: true,
+			ctrl: null,
+			held: false,
+			sink: {
+				data,
+				error,
+				loading
+			},
+			started: false
+		};
+		byKey.set(key, cell);
+	}
+	cell.sink = {
+		data,
+		error,
+		loading
+	};
+	const c = cell;
+	const fiberCells = byKey;
+	const adoptShared = async (shared) => {
+		try {
+			const v = await shared;
+			if (c.alive) {
+				c.sink.data.set(v);
+				c.sink.error.set(void 0);
+				c.sink.loading.set(false);
+			}
+		} catch (fetchError) {
+			if (c.alive) {
+				c.sink.error.set(fetchError);
+				c.sink.loading.set(false);
+			}
+		}
+	};
+	const start = () => {
+		if (!c.alive) return Promise.resolve(c.sink.data());
+		const hit = entryFor(key);
+		if (hit?.promise) {
+			c.sink.loading.set(true);
+			adoptShared(hit.promise);
+			return hit.promise;
+		}
+		c.ctrl?.abort();
+		const ctrl = new AbortController();
+		c.ctrl = ctrl;
+		c.sink.loading.set(true);
+		const flight = {};
+		const run = async () => {
+			try {
+				const v = await fetcher(key, { signal: ctrl.signal });
+				if (entryFor(key)?.promise === flight.promise) sharedCache.set(key, {
+					data: v,
+					has: true
+				});
+				if (c.alive && !ctrl.signal.aborted) {
+					c.sink.data.set(v);
+					c.sink.error.set(void 0);
+					c.sink.loading.set(false);
+				}
+				return v;
+			} catch (fetchError) {
+				const cur = entryFor(key);
+				if (cur?.promise === flight.promise) cur.promise = void 0;
+				if (c.alive && !ctrl.signal.aborted) {
+					c.sink.error.set(fetchError);
+					c.sink.loading.set(false);
+				}
+				throw fetchError;
+			}
+		};
+		const p = run();
+		flight.promise = p;
+		const prev = entryFor(key);
+		sharedCache.set(key, {
+			data: prev?.data,
+			has: prev?.has ?? false,
+			promise: p
+		});
+		return p;
+	};
+	const settleStart = async () => {
+		try {
+			await start();
+		} catch {}
+	};
+	if (!c.started) {
+		c.started = true;
+		const swr = opts?.staleWhileRevalidate ?? true;
+		const hit = entryFor(key);
+		if (hit?.promise) {
+			if (hit.has) {
+				c.sink.data.set(hit.data);
+				c.sink.loading.set(false);
+			}
+			adoptShared(hit.promise);
+		} else if (hit?.has) {
+			c.sink.data.set(hit.data);
+			c.sink.error.set(void 0);
+			c.sink.loading.set(false);
+			if (swr) settleStart();
+		} else {
+			const seed = c.sink.data();
+			if (seed === void 0) settleStart();
+			else {
+				sharedCache.set(key, {
+					data: seed,
+					has: true
+				});
+				if (swr) settleStart();
+				else c.sink.loading.set(false);
+			}
+		}
+	}
+	if (!c.held) {
+		c.held = true;
+		const onInvalidate = () => {
+			settleStart();
+		};
+		watch.once(() => {
+			let live = liveRefetchers.get(key);
+			if (!live) {
+				live = /* @__PURE__ */ new Set();
+				liveRefetchers.set(key, live);
+			}
+			live.add(onInvalidate);
+			return () => {
+				c.alive = false;
+				c.ctrl?.abort();
+				const s = liveRefetchers.get(key);
+				s?.delete(onInvalidate);
+				if (s && s.size === 0) liveRefetchers.delete(key);
+				if (fiberCells.get(key) === c) fiberCells.delete(key);
+			};
+		});
+	}
+	return {
+		data,
+		error,
+		loading,
+		refetch: () => start()
+	};
+};
+
+//#endregion
+//#region src/sse.ts
+const cells = /* @__PURE__ */ new WeakMap();
+const MAX_BACKOFF_MS = 3e4;
+const setStatus = (c, next) => {
+	c.state = next;
+	for (const sink of c.sinks.values()) sink.status.set(next);
+};
+const connect = ({ cell: c, decode, event, retryBase, url }) => {
+	let attempt = 0;
+	let timer;
+	let source;
+	let detach;
+	let disposed = false;
+	const emit = (value) => {
+		c.last = { value };
+		for (const sink of c.sinks.values()) sink.latest.set(value);
+		for (const push of c.targets) push(value);
+	};
+	const onMessage = (ev) => {
+		const raw = ev.data;
+		if (!isString(raw)) return;
+		let value;
+		try {
+			value = decode(raw);
+		} catch {
+			return;
+		}
+		emit(value);
+	};
+	const open = () => {
+		if (disposed) return;
+		setStatus(c, attempt === 0 ? "connecting" : "retrying");
+		const es = new EventSource(url);
+		source = es;
+		const onOpen = () => {
+			attempt = 0;
+			setStatus(c, "open");
+		};
+		const onError = () => {
+			if (disposed || es.readyState !== EventSource.CLOSED) return;
+			detach?.();
+			es.close();
+			attempt += 1;
+			setStatus(c, "retrying");
+			timer = setTimeout(open, Math.min(retryBase * 2 ** (attempt - 1), MAX_BACKOFF_MS));
+		};
+		const messageEvent = event ?? "message";
+		es.addEventListener(messageEvent, onMessage);
+		es.addEventListener("open", onOpen);
+		es.addEventListener("error", onError);
+		detach = () => {
+			es.removeEventListener(messageEvent, onMessage);
+			es.removeEventListener("open", onOpen);
+			es.removeEventListener("error", onError);
+		};
+	};
+	open();
+	return () => {
+		disposed = true;
+		clearTimeout(timer);
+		detach?.();
+		source?.close();
+		setStatus(c, "closed");
+	};
+};
+/**
+* Subscribe to server-sent events. Opens one connection per `(url, event)`
+* per component, reconnects with backoff, and closes on unmount. SSR renders
+* an empty stream with status `"closed"`. Call unconditionally at the top
+* level of a component.
+*/
+const fromEventSource = (url, opts) => {
+	const fiber = getFiber();
+	const status = atom("connecting");
+	const latest = atom(void 0);
+	const feedKey = `${url}\n${opts?.event ?? ""}`;
+	let byKey = cells.get(fiber);
+	if (!byKey) {
+		byKey = /* @__PURE__ */ new Map();
+		cells.set(fiber, byKey);
+	}
+	let cell = byKey.get(feedKey);
+	if (!cell) {
+		const targets = /* @__PURE__ */ new Set();
+		const stream = fiber.runtime.ssr ? Stream.empty : Stream.callback((queue) => {
+			const push = (value) => {
+				Queue.offerUnsafe(queue, value);
+			};
+			targets.add(push);
+			return Effect.acquireRelease(Effect.void, () => Effect.sync(() => targets.delete(push)));
+		});
+		cell = {
+			sinks: /* @__PURE__ */ new Map(),
+			state: "connecting",
+			stream,
+			targets,
+			users: 0
+		};
+		byKey.set(feedKey, cell);
+	}
+	const sinkKey = latest.atom;
+	cell.sinks.set(sinkKey, {
+		latest,
+		status
+	});
+	const c = cell;
+	const decode = opts?.schema ?? ((raw) => raw);
+	const retryBase = opts?.retryBaseMs ?? 1e3;
+	watch.once(() => {
+		if (fiber.runtime.ssr || globalThis.EventSource === void 0) {
+			status.set("closed");
+			return;
+		}
+		c.users += 1;
+		if (c.stop) {
+			status.set(c.state);
+			if (c.last) latest.set(c.last.value);
+		} else c.stop = connect({
+			cell: c,
+			decode,
+			event: opts?.event,
+			retryBase,
+			url
+		});
+		return () => {
+			c.users -= 1;
+			if (c.users === 0) {
+				const { stop } = c;
+				c.stop = void 0;
+				stop?.();
+			}
+			c.sinks.delete(sinkKey);
+		};
+	});
+	return {
+		latest,
+		status,
+		stream: c.stream
+	};
+};
+
 //#endregion
 //#region src/when.ts
 const when = (stream, body) => instr(Effect.gen(function* whenBody() {
@@ -180,4 +633,4 @@ const when = (stream, body) => instr(Effect.gen(function* whenBody() {
 }));
 
 //#endregion
-export { ErrorBoundary, Fragment, atom, batch, context, createContext, h, mount, renderToString, unsafe, untrack, watch, when };
+export { ErrorBoundary, Fragment, atom, batch, context, createContext, fromEventSource, h, invalidate, mount, renderToString, resource, structuralEqual, unsafe, untrack, watch, when };

package/dist/jsx-dev-runtime.d.ts

@@ -1,4 +1,4 @@
-import { i as Fragment } from "./types-CyoYWhJf.js";
-import { n as JSX } from "./vnode-C_BdUnIA.js";
+import { l as Fragment } from "./types-CJF2qMK6.js";
+import { n as JSX } from "./vnode-CUTNGblA.js";
 import { jsx, jsxDEV, jsxs } from "./jsx-runtime.js";
 export { Fragment, type JSX, jsx, jsxDEV, jsxs };

package/dist/jsx-dev-runtime.js

@@ -1,4 +1,4 @@
-import { i as Fragment } from "./vnode-DEMDQ0eA.js";
+import { i as Fragment } from "./vnode-M-oJMKcv.js";
 import { jsx, jsxDEV, jsxs } from "./jsx-runtime.js";
 
 export { Fragment, jsx, jsxDEV, jsxs };

package/dist/jsx-runtime.d.ts

@@ -1,5 +1,5 @@
-import { i as Fragment, o as JsxComponent, r as ComponentFn, s as PropBag, u as View } from "./types-CyoYWhJf.js";
-import { n as JSX, t as h } from "./vnode-C_BdUnIA.js";
+import { a as ComponentFn, d as JsxComponent, f as PropBag, l as Fragment, v as View } from "./types-CJF2qMK6.js";
+import { n as JSX, t as h } from "./vnode-CUTNGblA.js";
 //#region src/jsx-runtime.d.ts
 declare const jsx: (type: string | Fragment | ComponentFn | JsxComponent, props: PropBag | null, key?: string | number) => ReturnType<typeof h>;
 declare const jsxs: (type: string | Fragment | ComponentFn | JsxComponent, props: PropBag | null, key?: string | number) => ReturnType<typeof h>;

package/dist/jsx-runtime.js

@@ -1,4 +1,4 @@
-import { i as Fragment, t as h } from "./vnode-DEMDQ0eA.js";
+import { i as Fragment, t as h } from "./vnode-M-oJMKcv.js";
 
 //#region src/jsx-runtime.ts
 const jsx = (type, props, key) => h(type, key === void 0 ? props : {