ilha 0.14.0 → 0.14.2

package/README.md

@@ -48,43 +48,48 @@ count.set(1); // replace
 count.update((n) => n + 1); // patch
 ```
 
-In JSX, `{count}` subscribes the render. A function initializer is a **computed** atom:
+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 { atom } from "ilha";
+
 const items = atom([{ n: 1 }, { n: 2 }]);
-const total = atom(() => items().reduce((sum, item) => sum + item.n, 0));
+const total = atom(Atom.map(items.atom, (list) => list.reduce((sum, item) => sum + item.n, 0)));
 ```
 
+Wrap multiple writes in `batch()`. Derived and mutation atoms use Effect's `Atom.map`, `Atom.transform`, and `Atom.fn` — pass `handle.atom`, then wrap in `atom()`. Use `watch(source, fn)` for side effects on atom changes.
+
+Use `atom.lazy(() => …)` for one-time initialization or to store a function value.
+
 Atoms hold data. Do not store JSX in an atom.
 
 ---
 
-## Streams, when, watch, wait
+## Streams and when
 
-Use a generator when you `yield*` instructions.
+Paint [Effect `Stream`](https://www.effect.website/docs/v4/api/effect/Stream) values. Yield a stream of views from a generator, or return one from an async component:
 
 ```tsx
 import * as Stream from "effect/Stream";
 import * as Atom from "effect/unstable/reactivity/Atom";
-import { atom, when } from "ilha";
+import { atom } from "ilha";
 
-const Search = function* () {
-  const q = atom("");
-  yield (
-    <input value={q} oninput={(e: Event) => q.set((e.currentTarget as HTMLInputElement).value)} />
-  );
-  yield* when(Atom.toStream(q.atom).pipe(Stream.debounce("200 millis")), function* (query) {
-    if (!query) return;
-    yield <p>{query}</p>;
-  });
-};
+function* List() {
+  const items = atom(["a", "b"]);
+  yield Stream.map(Atom.toStream(items.atom), (list) => (
+    <ul>
+      {list.map((item) => (
+        <li key={item}>{item}</li>
+      ))}
+    </ul>
+  ));
+}
 ```
 
-- `when(stream, body)` — render `body` for each value (SSR takes the first).
-- `watch(source, fn)` — side effect on an atom or Stream.
-- `wait(body)` — paint until `done(value)`, then continue the generator.
+SSR takes the first emission (`take(1)`); the client keeps listening after `mount`.
 
-Map a Stream of arrays to JSX for lists (`Stream.map`, `Atom.toStream`).
+Ilha also ships `when` for per-emission generator bodies (stale work interrupted). Side effects and pauses use Effect directly — see the [Streams guide](https://ilha.build/guide/ui/streams).
 
 ---
 
@@ -112,7 +117,7 @@ if (host) mount(host, Counter, { hydrate: true });
 | `timeout`        | none    | Serialize after this many ms   |
 | `captureActions` | `false` | Probe handlers for server RPCs |
 
-In Node, `renderToString` registers happy-dom when `document` is missing.
+`renderToString` builds HTML without a DOM — no polyfill in Node, Bun, or edge runtimes.
 
 ---
 

package/dist/define.d.ts

@@ -1,4 +1,4 @@
-import { n as Component } from "./types-DU46exHq.js";
+import { n as Component } from "./types-Cie0Ihl6.js";
 //#region src/define.d.ts
 declare function define(name: string, component: Component): void;
 //#endregion

package/dist/define.js

@@ -1,4 +1,4 @@
-import { t as mount } from "./mount-Dcy4teaf.js";
+import { t as mount } from "./mount-CCMOkDSb.js";
 
 //#region src/define.ts
 function define(name, component) {

package/dist/index.d.ts

@@ -1,23 +1,25 @@
-import { a as Instruction, c as Yielded, i as Fragment, n as Component, r as Done, s as View, t as AtomHandle } from "./types-DU46exHq.js";
-import { t as h } from "./vnode-BZLcG8lC.js";
+import { i as Instruction, n as Component, o as View, r as Fragment, s as Yielded, t as AtomHandle } from "./types-Cie0Ihl6.js";
+import { t as h } from "./vnode-DyFwtMVw.js";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Atom from "effect/unstable/reactivity/Atom";
 import "effect/Scope";
 import { AtomRegistry } from "effect/unstable/reactivity/AtomRegistry";
+//#region src/watch.d.ts
+/** Run `fn` when `source` changes — and once on mount. Sync, async, and generator components. */
+declare function watch<A>(source: AtomHandle<A> | Atom.Atom<A> | Stream.Stream<A, any, any>, fn: (value: A) => void): Instruction<void>;
+//#endregion
 //#region src/atom.d.ts
-declare function atom<A>(init: () => A): AtomHandle<A>;
-declare function atom<A>(init: A | Atom.Atom<A> | Effect.Effect<A, any, any> | Stream.Stream<A, any, any>): AtomHandle<A>;
+interface AtomFn {
+  <A>(init: A | Atom.Atom<A> | Effect.Effect<A, any, any> | Stream.Stream<A, any, any>): AtomHandle<A>;
+  lazy<A>(init: () => A): AtomHandle<A>;
+}
+declare const atom: AtomFn;
+declare const batch: (f: () => void) => void;
 //#endregion
 //#region src/when.d.ts
 declare function when<A, E = never, R = never>(stream: Stream.Stream<A, E, R>, body: (value: A) => Generator<Yielded, View | void, unknown>): Instruction<void, E>;
 //#endregion
-//#region src/watch.d.ts
-declare function watch<A>(source: AtomHandle<A> | Atom.Atom<A> | Stream.Stream<A, any, any>, fn: (value: A) => void): Instruction<void>;
-//#endregion
-//#region src/wait.d.ts
-declare function wait<A>(body: (done: Done<A>) => Generator<Yielded, View | void, unknown>): Instruction<A>;
-//#endregion
 //#region src/mount.d.ts
 type RenderToStringOptions = {
   snapshot?: boolean;
@@ -32,4 +34,4 @@ type MountOptions = {
 declare function mount(el: Element, fn: Component, opts?: MountOptions): () => void;
 declare function renderToString(fn: Component, opts?: RenderToStringOptions): Promise<string>;
 //#endregion
-export { type AtomHandle, type Component, type Done, Fragment, type MountOptions, type RenderToStringOptions, type View, atom, h, mount, renderToString, wait, watch, when };
+export { type AtomHandle, type Component, Fragment, type MountOptions, type RenderToStringOptions, type View, atom, batch, h, mount, renderToString, watch, when };

package/dist/index.js

@@ -1,10 +1,69 @@
-import { a as atom, c as isAtomHandle, d as makeFiber, i as interpret, l as closeFiber, n as renderToString, o as handleOwner, r as paint, s as instr, t as mount, u as getFiber } from "./mount-Dcy4teaf.js";
+import { a as atom, c as instr, d as getFiber, f as makeFiber, i as interpret, l as isAtomHandle, n as renderToString, o as batch, r as paint, s as handleOwner, t as mount, u as closeFiber } from "./mount-CCMOkDSb.js";
 import { i as Fragment, t as h } from "./vnode-DHN2EFHi.js";
 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 Scope from "effect/Scope";
-import * as Deferred from "effect/Deferred";
+import * as Registry from "effect/unstable/reactivity/AtomRegistry";
 
+//#region src/watch.ts
+function 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));
+	};
+}
+function 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) {
+			existing.dispose();
+			fiber.watchSlots[i] = void 0;
+		} else {
+			existing.fnRef.current = fn;
+			return;
+		}
+	}
+	const fnRef = { current: fn };
+	const unsub = mount((value) => fnRef.current(value));
+	const dispose = () => unsub();
+	fiber.watchSlots[i] = {
+		key,
+		fnRef,
+		dispose
+	};
+}
+function registerWatch(fiber, source, fn) {
+	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;
+				stop();
+			};
+		}, fn);
+		return;
+	}
+	const atom = isAtomHandle(source) ? source.atom : source;
+	useWatchSlot(fiber, atom, (run) => fiber.registry.subscribe(atom, run, { immediate: true }), fn);
+}
+/** Run `fn` when `source` changes — and once on mount. Sync, async, and generator components. */
+function watch(source, fn) {
+	registerWatch((isAtomHandle(source) ? handleOwner.get(source) : void 0) ?? getFiber(), source, fn);
+	return instr(Effect.void);
+}
+
+//#endregion
 //#region src/when.ts
 function when(stream, body) {
 	return instr(Effect.gen(function* () {
@@ -25,41 +84,4 @@ function when(stream, body) {
 }
 
 //#endregion
-//#region src/watch.ts
-function watch(source, fn) {
-	return instr(Effect.sync(() => {
-		const fiber = (isAtomHandle(source) ? handleOwner.get(source) : void 0) ?? getFiber();
-		if (Stream.isStream(source)) {
-			fiber.run(Stream.runForEach(source, (v) => Effect.sync(() => fn(v))));
-			return;
-		}
-		const a = isAtomHandle(source) ? source.atom : source;
-		const unsub = fiber.registry.subscribe(a, fn, { immediate: true });
-		Effect.runSync(Scope.addFinalizer(fiber.scope, Effect.sync(unsub)));
-	}));
-}
-
-//#endregion
-//#region src/wait.ts
-function wait(body) {
-	return instr(Effect.gen(function* () {
-		const parent = getFiber();
-		const deferred = yield* Deferred.make();
-		let settled = false;
-		const done = (value) => {
-			if (settled) return;
-			settled = true;
-			Effect.runSync(Deferred.succeed(deferred, value));
-		};
-		const child = makeFiber(parent.runtime, parent.root, paint, { onFail: parent.fail });
-		interpret((() => body(done)), child);
-		try {
-			return yield* Deferred.await(deferred);
-		} finally {
-			closeFiber(child);
-		}
-	}));
-}
-
-//#endregion
-export { Fragment, atom, h, mount, renderToString, wait, watch, when };
+export { Fragment, atom, batch, h, mount, renderToString, watch, when };

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

@@ -1,4 +1,4 @@
-import { i as Fragment } from "./types-DU46exHq.js";
-import { n as JSX } from "./vnode-BZLcG8lC.js";
+import { r as Fragment } from "./types-Cie0Ihl6.js";
+import { n as JSX } from "./vnode-DyFwtMVw.js";
 import { jsx, jsxDEV, jsxs } from "./jsx-runtime.js";
 export { Fragment, type JSX, jsx, jsxDEV, jsxs };

package/dist/jsx-runtime.d.ts

@@ -1,5 +1,5 @@
-import { i as Fragment, s as View } from "./types-DU46exHq.js";
-import { n as JSX, t as h } from "./vnode-BZLcG8lC.js";
+import { o as View, r as Fragment } from "./types-Cie0Ihl6.js";
+import { n as JSX, t as h } from "./vnode-DyFwtMVw.js";
 //#region src/jsx-runtime.d.ts
 declare const jsx: (type: string | typeof Fragment | ((p: Record<string, unknown>) => unknown), props: Record<string, unknown> | null, key?: string | number) => ReturnType<typeof h>;
 declare const jsxs: (type: string | typeof Fragment | ((p: Record<string, unknown>) => unknown), props: Record<string, unknown> | null, key?: string | number) => ReturnType<typeof h>;