ilha 0.14.3 → 0.14.5

package/README.md

@@ -55,10 +55,12 @@ import * as Atom from "effect/unstable/reactivity/Atom";
 import { atom } from "ilha";
 
 const items = atom([{ n: 1 }, { n: 2 }]);
-const total = atom(Atom.map(items.atom, (list) => list.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.
+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 `watch.once(fn)` for mount-only work; return a cleanup function to run on unmount. Use `untrack(() => …)` to read without subscribing. Share values with `createContext` / `context()`. Catch subtree failures with `ErrorBoundary`.
 
 Use `atom.lazy(() => …)` for one-time initialization or to store a function value.
 

package/dist/define.d.ts

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

package/dist/define.js

@@ -1,18 +1,18 @@
-import { t as mount } from "./mount-CCMOkDSb.js";
+import { t as mount } from "./mount-C5idXX3H.js";
 
 //#region src/define.ts
-function define(name, component) {
+const define = (name, component) => {
 	customElements.define(name, class extends HTMLElement {
 		#unmount;
 		connectedCallback() {
-			this.#unmount = mount(this, component, { hydrate: this.hasAttribute("data-ilha") });
+			this.#unmount = mount(this, component, { hydrate: this.matches("[data-ilha]") });
 		}
 		disconnectedCallback() {
 			this.#unmount?.();
 			this.#unmount = void 0;
 		}
 	});
-}
+};
 
 //#endregion
 export { define };

package/dist/index.d.ts

@@ -1,37 +1,77 @@
-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-15tImQ6O.js";
+import { a as Instruction, i as Fragment, l as View, n as Component, t as AtomHandle, u as Yielded } from "./types-CUQdA6hR.js";
+import { t as h } from "./vnode-Bwx8ffNO.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>;
+/** 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, any, any> | Stream.Stream<A, any, any>): AtomHandle<A>;
-  lazy<A>(init: () => A): AtomHandle<A>;
+  <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;
+  children?: View;
+}
+interface IlhaContext<A> {
+  readonly id: symbol;
+  readonly defaultValue: A;
+  readonly Provider: (props: ContextProviderProps<A>) => View;
+}
+declare const createContext: <A>(defaultValue: A) => IlhaContext<A>;
+/** Read a context value as an atom handle. Subscribes the active fiber on read. */
+declare const context: <A>(ctx: IlhaContext<A>) => AtomHandle<A>;
+//#endregion
+//#region src/error-boundary.d.ts
+interface ErrorFallbackProps {
+  error: Error;
+  reset: () => void;
+}
+type ErrorFallback = (props: ErrorFallbackProps) => View;
+interface ErrorBoundaryProps {
+  fallback?: ErrorFallback;
+  onError?: (error: Error) => void;
+  children?: View;
+}
+/** Catch subtree failures and paint a fallback. Supports reset(). */
+declare const ErrorBoundary: (props: ErrorBoundaryProps) => View;
+//#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>;
+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>;
 //#endregion
 //#region src/mount.d.ts
-type RenderToStringOptions = {
+interface RenderToStringOptions {
   snapshot?: boolean;
   markers?: boolean;
   timeout?: number;
   captureActions?: boolean;
-};
-type MountOptions = {
+}
+interface MountOptions {
   hydrate?: boolean;
-  onError?: (error: unknown) => void;
-};
-declare function mount(el: Element, fn: Component, opts?: MountOptions): () => void;
-declare function renderToString(fn: Component, opts?: RenderToStringOptions): Promise<string>;
+  onError?: <E>(error: E) => void;
+}
+declare const mount: (el: Element, fn: Component, opts?: MountOptions) => (() => void);
+declare const renderToString: (fn: Component, opts?: RenderToStringOptions) => Promise<string>;
 //#endregion
-export { type AtomHandle, type Component, Fragment, type MountOptions, type RenderToStringOptions, type View, atom, batch, h, mount, renderToString, watch, when };
+export { type AtomHandle, type Component, type ContextProviderProps, ErrorBoundary, type ErrorBoundaryProps, type ErrorFallback, type ErrorFallbackProps, Fragment, type IlhaContext, type MountOptions, type RenderToStringOptions, type View, type WatchOnceCleanup, atom, batch, context, createContext, h, mount, renderToString, untrack, watch, when };

package/dist/index.js

@@ -1,14 +1,83 @@
-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 { a as atom, c as instr, d as wrapHandle, f as clearFiberView, h as makeFiber, i as interpret, l as isAtomHandle, m as getFiber, n as renderToString, o as batch, p as closeFiber, r as runSetup, s as handleOwner, t as mount, u as untrack } from "./mount-C5idXX3H.js";
+import { d as errorView, i as Fragment, p as isFunction, t as h } from "./vnode-DEMDQ0eA.js";
 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 Scope from "effect/Scope";
 import * as Registry from "effect/unstable/reactivity/AtomRegistry";
 
+//#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 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,
+		defaultValue,
+		id
+	};
+};
+/** 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;
+	}
+	return wrapHandle(getDefaultAtom(ctx), fiber);
+};
+
+//#endregion
+//#region src/error-boundary.ts
+/** 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));
+	};
+	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));
+	};
+	return props.children;
+};
+
+//#endregion
 //#region src/watch.ts
-function runStreamWatch(fiber, effect) {
+const WATCH_ONCE = Symbol("ilha.watch.once");
+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);
@@ -16,31 +85,32 @@ function runStreamWatch(fiber, effect) {
 	return () => {
 		Effect.runFork(Scope.close(scope, Exit.void));
 	};
-}
-function useWatchSlot(fiber, key, mount, fn) {
+};
+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) {
-			existing.dispose();
-			fiber.watchSlots[i] = void 0;
-		} else {
-			existing.fnRef.current = fn;
+		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 unsub = mount((value) => {
+		fnRef.current(value);
+	});
 	const dispose = () => unsub();
 	fiber.watchSlots[i] = {
-		key,
+		dispose,
 		fnRef,
-		dispose
+		key
 	};
-}
-function registerWatch(fiber, source, fn) {
+};
+const registerWatch = (fiber, source, fn) => {
 	if (Stream.isStream(source)) {
 		useWatchSlot(fiber, source, (run) => {
 			let active = true;
@@ -56,32 +126,58 @@ function registerWatch(fiber, source, fn) {
 	}
 	const atom = isAtomHandle(source) ? source.atom : source;
 	useWatchSlot(fiber, atom, (run) => fiber.registry.subscribe(atom, run, { immediate: true }), fn);
-}
+};
+/** Run `fn` once on mount. Return a function 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;
+	}
+	let cleanup = fn();
+	fiber.watchSlots[i] = {
+		dispose: () => {
+			const run = cleanup;
+			cleanup = void 0;
+			run?.();
+		},
+		key: WATCH_ONCE
+	};
+	return instr(Effect.void);
+};
 /** 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);
+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/when.ts
-function when(stream, body) {
-	return instr(Effect.gen(function* () {
-		const parent = getFiber();
-		let child;
-		parent.holes.push({ dispose() {
-			if (child) closeFiber(child);
-			child = void 0;
-		} });
-		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, paint, { onFail: parent.fail });
-			interpret((() => body(value)), child);
-		}));
+const when = (stream, body) => instr(Effect.gen(function* whenBody() {
+	const parent = getFiber();
+	let child;
+	parent.holes.push({ dispose() {
+		if (child) closeFiber(child);
+		child = void 0;
+	} });
+	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);
 	}));
-}
+}));
 
 //#endregion
-export { Fragment, atom, batch, h, mount, renderToString, watch, when };
+export { ErrorBoundary, Fragment, atom, batch, context, createContext, h, mount, renderToString, untrack, watch, when };

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

@@ -1,4 +1,4 @@
-import { r as Fragment } from "./types-Cie0Ihl6.js";
-import { n as JSX } from "./vnode-15tImQ6O.js";
+import { i as Fragment } from "./types-CUQdA6hR.js";
+import { n as JSX } from "./vnode-Bwx8ffNO.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-DHN2EFHi.js";
+import { i as Fragment } from "./vnode-DEMDQ0eA.js";
 import { jsx, jsxDEV, jsxs } from "./jsx-runtime.js";
 
 export { Fragment, jsx, jsxDEV, jsxs };

package/dist/jsx-runtime.d.ts

@@ -1,8 +1,8 @@
-import { o as View, r as Fragment } from "./types-Cie0Ihl6.js";
-import { n as JSX, t as h } from "./vnode-15tImQ6O.js";
+import { i as Fragment, l as View, o as JsxComponent, r as ComponentFn, s as PropBag } from "./types-CUQdA6hR.js";
+import { n as JSX, t as h } from "./vnode-Bwx8ffNO.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>;
-declare const jsxDEV: (type: string | typeof Fragment | ((p: Record<string, unknown>) => unknown), props: Record<string, unknown> | null, key?: string | number) => ReturnType<typeof h>;
+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>;
+declare const jsxDEV: (type: string | Fragment | ComponentFn | JsxComponent, props: PropBag | null, key?: string | number) => ReturnType<typeof h>;
 //#endregion
 export { Fragment, type JSX, type View, h, jsx, jsxDEV, jsxs };

package/dist/jsx-runtime.js

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