ilha 0.15.1 → 0.16.0

package/dist/index.js

@@ -1,51 +1,43 @@
-import { _ as isString, f as errorView, i as Fragment, m as isFunction, t as h } from "./vnode-BHUY61Rm.js";
-import { C as makeFiber, S as getFiber, _ as structuralEqual, b as clearFiberView, d as interpret, f as atom, g as isAtomHandle, h as instr, m as handleOwner, n as unsafe, p as batch, u as runSetup, v as untrack, x as closeFiber, y as wrapHandle } from "./paint-core-D9VO-oUM.js";
-import { n as renderToString, t as mount } from "./mount-DCu8b0hE.js";
+import { _ as IlhaError, c as batch, d as untrack, f as wrapHandle, g as makeFiber, h as getFiber, i as runSetup, l as instr, m as closeFiber, o as interpret, p as clearFiberView, s as atom } from "./start-B-e1dG5U.js";
+import { i as errorView, o as isFunction } from "./shared-vpgYXytd.js";
+import { n as unsafe } from "./paint-core-D1n4lbpF.js";
+import { r as renderToString, t as mount } from "./mount-BwuJsiDH.js";
+import { r as Fragment, t as h } from "./vnode-DJ25Jn3D.js";
 import * as Atom from "effect/reactivity/Atom";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
-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 Queue from "effect/Queue";
 
 //#region src/context.ts
-const defaults = /* @__PURE__ */ new WeakMap();
-const getDefaultAtom = (ctx) => {
-	const existing = defaults.get(ctx);
-	if (existing) return existing;
-	const made = Atom.make(ctx.defaultValue);
-	defaults.set(ctx, made);
-	return made;
-};
+const fallbacks = /* @__PURE__ */ new WeakMap();
 const createContext = (defaultValue) => {
 	const id = Symbol("ilha.context");
-	const Provider = (props) => {
-		const fiber = getFiber();
-		const { value: next, children } = props;
-		const handle = atom(next);
-		if (!Object.is(untrack(() => handle()), next)) handle.set(next);
-		fiber.contexts ??= /* @__PURE__ */ new Map();
-		fiber.contexts.set(id, handle.atom);
-		return children;
-	};
-	return {
-		Provider,
+	const ctx = {
+		Provider: ({ value, children }) => {
+			const fiber = getFiber();
+			const handle = atom.lazy(() => value, { snapshot: false });
+			if (!Object.is(untrack(handle), value)) handle.set(value);
+			fiber.contexts ??= /* @__PURE__ */ new Map();
+			fiber.contexts.set(id, handle.atom);
+			return children;
+		},
 		defaultValue,
 		id
 	};
+	fallbacks.set(ctx, Atom.make(defaultValue));
+	return ctx;
 };
 /** Read a context value as an atom handle. Subscribes the active fiber on read. */
 const context = (ctx) => {
 	const fiber = getFiber();
-	let current = fiber;
-	while (current) {
-		const found = current.contexts?.get(ctx.id);
-		if (found) return wrapHandle(found, fiber);
-		current = current.parent;
+	let found = fallbacks.get(ctx);
+	for (let f = fiber; f; f = f.parent) {
+		const provided = f.contexts?.get(ctx.id);
+		if (provided) {
+			found = provided;
+			break;
+		}
 	}
-	return wrapHandle(getDefaultAtom(ctx), fiber);
+	return wrapHandle(found ?? Atom.make(ctx.defaultValue), fiber);
 };
 
 //#endregion
@@ -53,591 +45,118 @@ const context = (ctx) => {
 /** Catch subtree failures and paint a fallback. Supports reset(). */
 const ErrorBoundary = (props) => {
 	const fiber = getFiber();
-	const remount = () => {
-		if (fiber.closed) return;
-		clearFiberView(fiber);
-		const current = fiber.propsBox?.current ?? props;
-		runSetup(fiber, () => ErrorBoundary(current));
-	};
+	const current = () => fiber.propsBox?.current ?? props;
 	fiber.handleError = (error) => {
 		if (fiber.closed) return;
 		clearFiberView(fiber);
-		const { onError, fallback } = fiber.propsBox?.current ?? props;
-		if (isFunction(onError)) onError(error);
-		if (isFunction(fallback)) {
-			fiber.paint(fallback({
-				error,
-				reset: remount
-			}));
-			return;
-		}
-		fiber.paint(errorView(error));
+		const { onError, fallback } = current();
+		onError?.(error);
+		fiber.paint(fallback ? fallback({
+			error,
+			reset: () => {
+				if (!fiber.closed) {
+					clearFiberView(fiber);
+					runSetup(fiber, () => ErrorBoundary(current()));
+				}
+			}
+		}) : errorView(error));
 	};
 	return props.children;
 };
 
 //#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));
-	const fork = Effect.runFork(provided);
-	Effect.runSync(Scope.addFinalizer(scope, Fiber.interrupt(fork)));
-	return () => {
-		Effect.runFork(Scope.close(scope, Exit.void));
-	};
-};
-const useWatchSlot = (fiber, key, mount, fn) => {
-	const i = fiber.watchI ?? 0;
-	fiber.watchI = i + 1;
-	fiber.watchSlots ??= [];
-	const existing = fiber.watchSlots[i];
-	if (existing) {
-		if (existing.key === key) {
-			if (existing.fnRef) existing.fnRef.current = fn;
-			return;
-		}
-		existing.dispose();
-		fiber.watchSlots[i] = void 0;
-	}
-	const fnRef = { current: fn };
-	const unsub = mount((value) => {
-		fnRef.current(value);
-	});
-	const dispose = () => unsub();
-	fiber.watchSlots[i] = {
-		dispose,
-		fnRef,
-		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;
-			const stop = runStreamWatch(fiber, Stream.runForEach(source, (v) => Effect.sync(() => {
-				if (active) run(v);
-			})));
-			return () => {
-				active = false;
-				disposeCell();
-				stop();
-			};
-		}, wrapped);
-		return;
-	}
-	const atom = isAtomHandle(source) ? source.atom : source;
-	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 (or a promise of one) to clean up on unmount. */
-const watchOnce = (fn) => {
-	const fiber = getFiber();
-	const i = fiber.watchI ?? 0;
-	fiber.watchI = i + 1;
-	fiber.watchSlots ??= [];
-	const existing = fiber.watchSlots[i];
-	if (existing) {
-		if (existing.key === WATCH_ONCE) return instr(Effect.void);
-		existing.dispose();
-		fiber.watchSlots[i] = void 0;
-	}
-	const cell = newRunCell();
-	runWithSignal(cell, fn);
-	fiber.watchSlots[i] = {
-		dispose: () => {
-			cancelRun(cell);
-		},
-		key: WATCH_ONCE
-	};
-	return instr(Effect.void);
-};
-/** Run `fn` when `source` changes — and once on mount. Sync, async, and generator components. */
-const watchSource = (source, fn) => {
-	const fiber = (isAtomHandle(source) ? handleOwner.get(source) : void 0) ?? getFiber();
-	registerWatch(fiber, source, fn);
-	return instr(Effect.void);
-};
-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();
-/** Unmount: stop every client cell of one fiber (all keys it ever used). */
-const releaseCells = (byKey) => {
-	for (const [key, entry] of byKey) {
-		const c = entry;
-		c.alive = false;
-		c.ctrl?.abort();
-		const live = liveRefetchers.get(key);
-		live?.delete(c.onInvalidate);
-		if (live && live.size === 0) liveRefetchers.delete(key);
-	}
-	byKey.clear();
-};
-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();
-};
+const ONCE = Symbol("ilha.watch.once");
 /**
-* 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`.
+* Serial runs of one watch slot. Each run gets a fresh signal; starting the
+* next run or cancelling aborts it, which also runs its cleanups.
 */
-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
-				}
+const makeRunner = () => {
+	let ctrl;
+	const cancel = () => ctrl?.abort();
+	return {
+		cancel,
+		run: (fn) => {
+			cancel();
+			ctrl = new AbortController();
+			const { signal } = ctrl;
+			const onCleanup = (c) => {
+				if (!isFunction(c)) return;
+				if (signal.aborted) c();
+				else signal.addEventListener("abort", () => c(), { once: true });
 			};
-			Effect.runSync(Scope.addFinalizer(fiber.scope, Effect.sync(() => sc.ctrl?.abort())));
-			byKey.set(key, sc);
-			ssrCell = sc;
-			const settleSsr = async () => {
+			const settle = async (pending) => {
 				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) {
-		const fresh = {
-			alive: true,
-			ctrl: null,
-			onInvalidate: () => {
-				fresh.revalidate();
-			},
-			revalidate: () => {},
-			sink: {
-				data,
-				error,
-				loading
-			},
-			started: false
-		};
-		cell = fresh;
-		byKey.set(key, cell);
-		let live = liveRefetchers.get(key);
-		if (!live) {
-			live = /* @__PURE__ */ new Set();
-			liveRefetchers.set(key, live);
-		}
-		live.add(cell.onInvalidate);
-	}
-	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);
+					onCleanup(await pending);
+				} catch (error) {
+					console.error(error);
 				}
-				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 {}
-	};
-	c.revalidate = () => {
-		settleStart();
-	};
-	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);
-			}
-		}
-	}
-	watch.once(() => () => {
-		releaseCells(fiberCells);
-	});
-	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;
+			};
+			const out = fn({
+				onCleanup,
+				signal
+			});
+			if (out instanceof Promise) settle(out);
+			else onCleanup(out);
 		}
-		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.
+* Claim the fiber's next watch slot. A slot whose key matches keeps its
+* subscription and takes the new callback; otherwise `open` subscribes anew.
 */
-const fromEventSource = (url, opts) => {
+const useWatchSlot = (key, ref, open) => {
 	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
+	const i = fiber.watchI ?? 0;
+	fiber.watchI = i + 1;
+	fiber.watchSlots ??= [];
+	const existing = fiber.watchSlots[i];
+	if (existing && existing.key === key) existing.ref.fn = ref.fn;
+	else {
+		existing?.dispose();
+		fiber.watchSlots[i] = {
+			dispose: open(fiber),
+			key,
+			ref
 		};
-		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 instr(Effect.void);
+};
+const watch = Object.assign((source, fn) => {
+	const ref = { fn };
+	const key = isFunction(source) ? source.atom : source;
+	return useWatchSlot(key, ref, (fiber) => {
+		const runner = makeRunner();
+		const emit = (value) => runner.run((ctx) => ref.fn(value, ctx));
+		const stop = Stream.isStream(source) ? fiber.run(Stream.runForEach(source, (v) => Effect.sync(() => emit(v)))) : fiber.registry.subscribe(isFunction(source) ? source.atom : source, emit, { immediate: true });
 		return () => {
-			c.users -= 1;
-			if (c.users === 0) {
-				const { stop } = c;
-				c.stop = void 0;
-				stop?.();
-			}
-			c.sinks.delete(sinkKey);
+			runner.cancel();
+			stop();
 		};
 	});
-	return {
-		latest,
-		status,
-		stream: c.stream
-	};
-};
+}, { once: (fn) => useWatchSlot(ONCE, {}, () => {
+	const runner = makeRunner();
+	runner.run(fn);
+	return runner.cancel;
+}) });
 
 //#endregion
 //#region src/when.ts
-const when = (stream, body) => instr(Effect.gen(function* whenBody() {
+/** Rerun `body` for every value of `stream`, replacing the previous run. */
+const when = (stream, body) => instr(Effect.suspend(() => {
 	const parent = getFiber();
 	let child;
-	parent.holes.push({ dispose() {
+	const stop = () => {
 		if (child) closeFiber(child);
-		child = void 0;
-	} });
+	};
+	parent.holes.push({ dispose: stop });
 	const base = stream;
-	const src = parent.runtime.ssr ? base.pipe(Stream.take(1)) : base;
-	yield* Stream.runForEach(src, (value) => Effect.sync(() => {
-		if (child) closeFiber(child);
-		child = makeFiber(parent.runtime, parent.root, parent.paintFn, {
-			onFail: parent.fail,
-			parent
-		});
-		interpret((() => body(value)), child);
-	}));
+	return Stream.runForEach(parent.runtime.ssr ? Stream.take(base, 1) : base, (value) => Effect.sync(() => {
+		stop();
+		child = makeFiber(parent.runtime, parent.root, parent.paintFn, { parent });
+		interpret(() => body(value), child);
+	})).pipe(Effect.asVoid);
 }));
 
 //#endregion
-export { ErrorBoundary, Fragment, atom, batch, context, createContext, fromEventSource, h, invalidate, mount, renderToString, resource, structuralEqual, unsafe, untrack, watch, when };
+export { ErrorBoundary, Fragment, IlhaError, atom, batch, context, createContext, h, mount, renderToString, unsafe, untrack, watch, when };