ilha 0.14.5 → 0.14.7

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 : {

package/dist/{mount-C5idXX3H.js → mount-rXNnaIWf.js}

@@ -1,12 +1,13 @@
-import { _ as skip, a as ISLAND, b as failureMessage, c as KEEP, d as errorView, f as isBigInt, g as isString, h as isObject, i as Fragment, l as KEY_ATTR, m as isNumber, n as isSetupFn, o as ISLAND_MOUNT_INTERNAL, p as isFunction, r as isVNode, s as ISLAND_SLOT_TAG, u as SLOT_ATTR, v as unwrap, x as toError, y as asFailure } 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 skip, a as ISLAND, b as failureMessage, c as KEEP, d as errorView, f as isBigInt, g as isString, h as isObject, i as Fragment, l as KEY_ATTR, m as isNumber, n as isSetupFn, o as ISLAND_MOUNT_INTERNAL, p as isFunction, r as isVNode, s as ISLAND_SLOT_TAG, u as SLOT_ATTR, v as unwrap, x as toError, y as asFailure } from "./vnode-M-oJMKcv.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 * as Cause from "effect/Cause";
 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";
 
 //#region src/runtime.ts
 const stack = [];
@@ -24,15 +25,15 @@ const withFiber = (fiber, fn) => {
 		stack.pop();
 	}
 };
-const provide = (effect, registry) => effect.pipe(Effect.provideService(Registry.AtomRegistry, registry));
+const provide = (effect, registry) => effect.pipe(Effect$1.provideService(Registry.AtomRegistry, registry));
 const runInScope = (effect, registry, scope, onOk, onErr, onDone) => {
 	const provided = provide(effect, registry);
-	const f = Effect.runFork(onOk || onDone ? provided.pipe(Effect.onExit((ex) => Effect.sync(() => {
+	const f = Effect$1.runFork(onOk || onDone ? provided.pipe(Effect$1.onExit((ex) => Effect$1.sync(() => {
 		onDone?.();
 		if (Exit.isSuccess(ex)) onOk?.(ex.value);
 		else if (!Cause.hasInterruptsOnly(ex.cause)) onErr?.(Cause.squash(ex.cause));
 	}))) : provided);
-	Effect.runSync(Scope.addFinalizer(scope, Fiber.interrupt(f)));
+	Effect$1.runSync(Scope.addFinalizer(scope, Fiber.interrupt(f)));
 };
 /** Clear render subscriptions and child holes without closing the fiber scope. */
 const clearFiberView = (fiber) => {
@@ -55,7 +56,7 @@ const closeFiber = (fiber) => {
 	fiber.trackRestore = void 0;
 	fiber.handleError = void 0;
 	clearFiberView(fiber);
-	Effect.runFork(Scope.close(fiber.scope, Exit.void));
+	Effect$1.runFork(Scope.close(fiber.scope, Exit.void));
 };
 const makeRuntime = (opts) => {
 	const registry = Registry.make();
@@ -69,7 +70,7 @@ const makeRuntime = (opts) => {
 		},
 		close: () => {
 			onIdle = void 0;
-			Effect.runFork(Scope.close(scope, Exit.void));
+			Effect$1.runFork(Scope.close(scope, Exit.void));
 			registry.dispose();
 		},
 		end: () => {
@@ -183,6 +184,8 @@ const instr = (effect) => {
 	return out;
 };
 const isAtomHandle = (x) => isFunction(x) && x.$$atom === 1;
+/** Key-order-insensitive deep equality for JSON-shaped values. */
+const structuralEqual = Equal.equals;
 let trackGet;
 const trackStack = [];
 /** Read atoms inside `fn` without subscribing the active render. Sync only. */
@@ -218,6 +221,34 @@ const beginPrimitiveFrame = (fiber) => {
 		islandFrame.slots.length = usedIslands;
 	}
 	islandFrame.i = 0;
+	let { componentFrame } = fiber;
+	if (!componentFrame) {
+		componentFrame = {
+			i: 0,
+			slots: []
+		};
+		fiber.componentFrame = componentFrame;
+	}
+	const usedComponents = componentFrame.i;
+	if (usedComponents < componentFrame.slots.length) {
+		for (let j = usedComponents; j < componentFrame.slots.length; j += 1) {
+			const slot = componentFrame.slots[j];
+			if (slot) {
+				const { hole } = slot;
+				if (!hole.closed) {
+					const idx = fiber.holes.findIndex((h) => h.holeFiber === hole);
+					if (idx === -1) closeFiber(hole);
+					else {
+						const [removed] = fiber.holes.splice(idx, 1);
+						removed?.dispose();
+					}
+				}
+			}
+			componentFrame.slots[j] = void 0;
+		}
+		componentFrame.slots.length = usedComponents;
+	}
+	componentFrame.i = 0;
 };
 const readTracked = (atom, registry) => {
 	const frame = trackStack.at(-1);
@@ -333,19 +364,23 @@ const wrapHandle = (atom, fiber) => {
 	});
 	return read;
 };
-const makeAtom = (init) => {
+const makeAtom = (init, options) => {
 	const fiber = getFiber();
 	const snap = fiber.runtime.hydrateValues;
 	const { atom: a, fresh } = usePrimitiveSlot(fiber, () => {
 		let seed = init;
-		if (snap && !Atom.isAtom(init) && !Effect.isEffect(init) && !Stream.isStream(init)) {
+		if (snap && !Atom.isAtom(init) && !Effect$1.isEffect(init) && !Stream$1.isStream(init)) {
 			const v = snap[fiber.runtime.hydrateI];
 			fiber.runtime.hydrateI += 1;
 			if (v !== void 0) seed = v;
 		}
 		if (Atom.isAtom(seed)) return seed;
-		if (Effect.isEffect(seed) || Stream.isStream(seed)) return Atom.make(seed);
-		return Atom.make(seed);
+		if (Effect$1.isEffect(seed) || Stream$1.isStream(seed)) return Atom.make(seed);
+		const made = Atom.make(seed);
+		const eq = options?.equals;
+		if (eq === void 0) return made;
+		const equalsFn = eq === "structural" ? structuralEqual : eq;
+		return Atom.withEquality(made, equalsFn);
 	});
 	const handle = wrapHandle(a, fiber);
 	if (fresh && fiber.runtime.ssr) fiber.runtime.ssrValues.push(fiber.registry.get(a));
@@ -392,7 +427,7 @@ const interpret = (gen, fiber) => {
 			}
 			let effect;
 			if (isInstruction(step.value)) ({effect} = step.value);
-			else if (Effect.isEffect(step.value)) effect = step.value;
+			else if (Effect$1.isEffect(step.value)) effect = step.value;
 			if (effect) {
 				fiber.inFlight = true;
 				fiber.run(effect, (a) => {
@@ -507,7 +542,7 @@ const bindEvents = (node, props, fiber) => {
 			const fn = el.__ilhaProps?.[key];
 			if (!isFunction(fn)) return;
 			const out = fn(ev);
-			if (Effect.isEffect(out)) fiber.run(out);
+			if (Effect$1.isEffect(out)) fiber.run(out);
 		});
 	}
 };
@@ -538,6 +573,7 @@ const syncAttributes = (from, to) => {
 	const names = [];
 	for (const { name } of from.attributes) names.push(name);
 	for (const name of names) {
+		if (name === "open" && !to.hasAttribute("open")) continue;
 		if (shouldPreserveMorphAttr(from, name)) continue;
 		if (!to.hasAttribute(name)) from.removeAttribute(name);
 	}
@@ -590,19 +626,29 @@ const collectKeys = (parent) => {
 	return keys;
 };
 const morphInput = (fromEl, toEl) => {
-	const hadChecked = fromEl.hasAttribute("checked");
-	const hadValue = fromEl.getAttribute("value");
 	syncAttributes(fromEl, toEl);
-	const hasChecked = toEl.hasAttribute("checked");
-	if (hasChecked !== hadChecked) fromEl.checked = hasChecked;
-	const newValue = toEl.getAttribute("value");
-	if (newValue !== hadValue) fromEl.value = newValue ?? "";
+	const from = fromEl;
+	const to = toEl;
+	const toChecked = toEl.hasAttribute("checked");
+	if (toChecked !== fromEl.hasAttribute("checked")) {
+		if (toChecked) fromEl.setAttribute("checked", "");
+		else fromEl.removeAttribute("checked");
+	}
+	if (toChecked && from.checked !== to.checked) from.checked = to.checked;
+	const toValue = toEl.getAttribute("value");
+	if (toValue !== fromEl.getAttribute("value")) {
+		if (toValue === null) fromEl.removeAttribute("value");
+		else fromEl.setAttribute("value", toValue);
+	}
+	if (toValue !== null && from.value !== to.value) from.value = to.value;
 };
 const morphTextarea = (fromEl, toEl) => {
-	const newText = toEl.textContent ?? "";
-	if (fromEl.textContent !== newText) {
-		fromEl.textContent = newText;
-		fromEl.value = newText;
+	syncAttributes(fromEl, toEl);
+	const from = fromEl;
+	const to = toEl;
+	if (to.textContent !== "" || from.textContent !== to.textContent) {
+		if (from.value !== to.value) from.value = to.value;
+		if (from.textContent !== to.textContent) from.textContent = to.textContent;
 	}
 };
 const morphSelect = (fromEl, toEl, api) => {
@@ -784,8 +830,30 @@ const serializeStyleAttr = (value) => {
 	return serializeStyleEntries(value);
 };
 
+//#endregion
+//#region src/unsafe.ts
+/**
+* Mark a string as pre-rendered HTML and paint it without escaping.
+* Use it for markup you built or sanitized yourself — SVG from an external
+* library, Markdown rendered to HTML, embed codes. Never pass untrusted
+* user input: unlike interpolated strings, this content is not escaped and
+* scripts inserted this way do not run, but event attributes and other
+* markup still apply.
+*/
+const unsafe = (html) => ({
+	$$ilhaUnsafe: 1,
+	html
+});
+const isUnsafeHtml = (x) => {
+	if (!isObject(x)) return false;
+	return x.$$ilhaUnsafe === 1;
+};
+
 //#endregion
 //#region src/paint-core.ts
+const SVG_NS = "http://www.w3.org/2000/svg";
+const MATHML_NS = "http://www.w3.org/1998/Math/MathML";
+const HTML_NS = "http://www.w3.org/1999/xhtml";
 const disposeHoles = (fiber, opts) => {
 	const keep = [];
 	for (const h of fiber.holes) {
@@ -797,6 +865,38 @@ const disposeHoles = (fiber, opts) => {
 	}
 	fiber.holes = keep;
 };
+const parentNsOf = (root) => {
+	if ("namespaceURI" in root) return root.namespaceURI ?? null;
+	return null;
+};
+const elementNs = (lower, parentNs) => {
+	if (lower === "svg") return SVG_NS;
+	if (lower === "math") return MATHML_NS;
+	if (lower === "foreignobject") return HTML_NS;
+	if (parentNs === "http://www.w3.org/2000/svg" || parentNs === "http://www.w3.org/1998/Math/MathML") return parentNs;
+};
+const canMorphRoot = (root) => typeof Element !== "undefined" && typeof document !== "undefined" && root instanceof Element && root.childNodes.length > 0;
+const sweepComponentSlots = (fiber) => {
+	const cframe = fiber.componentFrame;
+	if (!cframe) return;
+	const { slots } = cframe;
+	for (let j = cframe.i; j < slots.length; j += 1) {
+		const s = slots[j];
+		if (s) {
+			const { hole } = s;
+			if (!hole.closed) {
+				const idx = fiber.holes.findIndex((h) => h.holeFiber === hole);
+				if (idx === -1) closeFiber(hole);
+				else {
+					const [removed] = fiber.holes.splice(idx, 1);
+					removed?.dispose();
+				}
+			}
+		}
+		slots[j] = void 0;
+	}
+	slots.length = cframe.i;
+};
 const findReusableAtomHost = (fiber, atom) => {
 	for (const h of fiber.holes) if (h.atom === atom && h.host?.isConnected && h.holeFiber && !h.holeFiber.closed) return {
 		hole: h.holeFiber,
@@ -926,14 +1026,41 @@ const createPainter = (ops) => {
 				fiber.islandFrame = frame;
 			}
 			frame.i = 0;
+			let cframe = fiber.componentFrame;
+			if (!cframe) {
+				cframe = {
+					i: 0,
+					slots: []
+				};
+				fiber.componentFrame = cframe;
+			}
+			cframe.i = 0;
 			const list = Array.isArray(view) ? view : null;
 			if (list && list.length > 0 && list.every((v) => isVNode(v) && v.key !== null && v.key !== void 0)) {
 				paintFns.keyedPaintHole(fiber, list);
 				return;
 			}
-			disposeHoles(fiber);
-			ops.clearRoot(fiber.root);
-			api.insert(fiber, api.materialize(view, fiber));
+			const kept = /* @__PURE__ */ new Set();
+			for (const s of cframe.slots) if (s && !s.hole.closed) kept.add(s.hole);
+			const keep = [];
+			for (const h of fiber.holes) {
+				if (h.holeFiber && kept.has(h.holeFiber)) {
+					keep.push(h);
+					continue;
+				}
+				h.dispose();
+			}
+			fiber.holes = keep;
+			const fresh = api.materialize(view, fiber);
+			if (canMorphRoot(fiber.root)) {
+				const tmp = document.createElement("div");
+				for (const n of fresh) tmp.append(n);
+				morphInner(fiber.root, tmp);
+			} else {
+				ops.clearRoot(fiber.root);
+				api.insert(fiber, fresh);
+			}
+			sweepComponentSlots(fiber);
 		}
 	};
 	const materializeAtom = (view, fiber) => {
@@ -962,9 +1089,9 @@ const createPainter = (ops) => {
 	};
 	const materializeStream = (view, fiber) => {
 		const { fiber: hole, nodes } = api.openHole(fiber);
-		const src = fiber.runtime.ssr ? view.pipe(Stream.take(1)) : view;
-		const effect = Effect.gen(function* streamPaint() {
-			const result = yield* Effect.result(Stream.runForEach(src, (v) => Effect.sync(() => {
+		const src = fiber.runtime.ssr ? view.pipe(Stream$1.take(1)) : view;
+		const effect = Effect$1.gen(function* streamPaint() {
+			const result = yield* Effect$1.result(Stream$1.runForEach(src, (v) => Effect$1.sync(() => {
 				if (!hole.closed) api.paintHole(hole, v);
 			})));
 			if (result._tag === "Failure" && !hole.closed) api.paintHole(hole, String(result.failure));
@@ -1014,6 +1141,50 @@ const createPainter = (ops) => {
 		}
 		return [el];
 	};
+	const materializeUnkeyedComponent = (run, type, props, fiber) => {
+		let { componentFrame: cframe } = fiber;
+		if (!cframe) {
+			cframe = {
+				i: 0,
+				slots: []
+			};
+			fiber.componentFrame = cframe;
+		}
+		const at = cframe.i;
+		cframe.i = at + 1;
+		const existing = cframe.slots[at];
+		if (existing) {
+			const { hole } = existing;
+			if (existing.type === type && !hole.closed) {
+				hole.propsBox = { current: props };
+				runSetup(hole, () => run(props));
+				return [ops.asNode(hole.root)];
+			}
+			if (!hole.closed) {
+				const idx = fiber.holes.findIndex((h) => h.holeFiber === hole);
+				if (idx === -1) closeFiber(hole);
+				else {
+					const [removed] = fiber.holes.splice(idx, 1);
+					removed?.dispose();
+				}
+			}
+		}
+		const { fiber: hole, nodes } = api.openHole(fiber);
+		hole.propsBox = { current: props };
+		hole.componentType = type;
+		cframe.slots[at] = {
+			hole,
+			type
+		};
+		fiber.runtime.later(() => {
+			if (hole.closed) return;
+			const box = hole.propsBox;
+			if (!box) return;
+			runSetup(hole, () => run(box.current));
+		});
+		trackHole(fiber, hole, void 0, { keyed: true });
+		return nodes;
+	};
 	const materializeComponent = (view, type, fiber) => {
 		const props = {
 			...view.props,
@@ -1030,23 +1201,25 @@ const createPainter = (ops) => {
 			if (next && !isThenable(next) && !isSetupFn(next)) reuse.paint(next);
 			return [ops.asNode(reuse.root)];
 		}
-		const { fiber: hole, nodes } = api.openHole(fiber);
-		hole.propsBox = { current: props };
-		if (k) {
-			fiber.keyedHoles ??= /* @__PURE__ */ new Map();
-			fiber.keyedHoles.set(k, hole);
-		}
+		if (!k) return materializeUnkeyedComponent(run, type, props, fiber);
+		const { fiber: khole, nodes: knodes } = api.openHole(fiber);
+		khole.propsBox = { current: props };
+		fiber.keyedHoles ??= /* @__PURE__ */ new Map();
+		fiber.keyedHoles.set(k, khole);
 		fiber.runtime.later(() => {
-			if (hole.closed) return;
-			const box = hole.propsBox;
+			if (khole.closed) return;
+			const box = khole.propsBox;
 			if (!box) return;
-			runSetup(hole, () => run(box.current));
+			runSetup(khole, () => run(box.current));
 		});
-		trackHole(fiber, hole, void 0, k ? { keyed: true } : void 0);
-		return nodes;
+		trackHole(fiber, khole, void 0, { keyed: true });
+		return knodes;
 	};
 	const materializeElement = (view, fiber) => {
-		const el = ops.createElement(view.type);
+		const tag = view.type;
+		const lower = tag.toLowerCase();
+		const ns = elementNs(lower, parentNsOf(fiber.root));
+		const el = ops.createElement(tag, ns);
 		if (view.key !== null && view.key !== void 0) el.setAttribute(KEY_ATTR, String(view.key));
 		api.applyProps(el, view.props, fiber);
 		fiber.keyedHoles ??= /* @__PURE__ */ new Map();
@@ -1065,10 +1238,11 @@ const createPainter = (ops) => {
 		return materializeElement(view, fiber);
 	};
 	paintFns.materialize = (view, fiber) => {
-		if (skip(view)) return [];
+		if (skip(view)) return [ops.createText("")];
+		if (isUnsafeHtml(view)) return ops.createRaw(view.html, fiber.root);
 		if (isTextish(view)) return [ops.createText(String(view))];
 		if (isAtomHandle(view)) return materializeAtom(view, fiber);
-		if (Stream.isStream(view)) return materializeStream(view, fiber);
+		if (Stream$1.isStream(view)) return materializeStream(view, fiber);
 		if (isSetupFn(view)) {
 			const { fiber: hole, nodes } = api.openHole(fiber);
 			fiber.runtime.later(() => {
@@ -1125,7 +1299,12 @@ const core$1 = createPainter({
 	clearRoot: (root) => {
 		if (root instanceof Element) root.replaceChildren();
 	},
-	createElement: (tag) => document.createElement(tag),
+	createElement: (tag, ns) => ns ? document.createElementNS(ns, tag) : document.createElement(tag),
+	createRaw: (html, parent) => {
+		const range = document.createRange();
+		range.selectNodeContents(parent);
+		return [...range.createContextualFragment(html).childNodes];
+	},
 	createSlotHost: (slotId) => {
 		const host = document.createElement("span");
 		if (slotId !== null) host.setAttribute(SLOT_ATTR, slotId);
@@ -1136,9 +1315,23 @@ const core$1 = createPainter({
 	disconnect: noopDisconnect,
 	setFormControl: (el, key, v) => {
 		const node = el;
-		if (key === "value") node.value = String(v ?? "");
-		else if (key === "checked") node.checked = Boolean(v);
-		else node.selected = Boolean(v);
+		if (key === "value") {
+			if (v === null || v === void 0) {
+				el.removeAttribute("value");
+				node.value = "";
+			} else {
+				el.setAttribute("value", String(v));
+				node.value = String(v);
+			}
+		} else if (key === "checked") {
+			node.checked = Boolean(v);
+			if (v) el.setAttribute("checked", "");
+			else el.removeAttribute("checked");
+		} else {
+			node.selected = Boolean(v);
+			if (v) el.setAttribute("selected", "");
+			else el.removeAttribute("selected");
+		}
 	},
 	setStyle: (el, css) => {
 		el.style.cssText = css;
@@ -1184,8 +1377,14 @@ const paintMorphLive = (fiber, view) => {
 	if (!fiber.liveEl) return;
 	core$1.disposeHoles(fiber, { morph: true });
 	core$1.applyProps(fiber.liveEl, view.props, fiber);
-	const tmp = document.createElement(fiber.liveEl.localName);
-	for (const c of view.children) for (const n of core$1.materialize(c, fiber)) tmp.append(n);
+	const liveNs = fiber.liveEl.namespaceURI;
+	const tmp = liveNs && liveNs !== "http://www.w3.org/1999/xhtml" ? document.createElementNS(liveNs, fiber.liveEl.localName) : document.createElement(fiber.liveEl.localName);
+	const childFiber = {
+		...fiber,
+		holes: fiber.holes,
+		root: tmp
+	};
+	for (const c of view.children) for (const n of core$1.materialize(c, childFiber)) tmp.append(n);
 	morphInner(fiber.liveEl, tmp);
 	refreshAllAtomHosts(fiber);
 	pruneDisconnectedAtomHoles(fiber);
@@ -1208,7 +1407,7 @@ const paint$1 = (fiber, view) => {
 		paintMorphLive(fiber, view);
 		return;
 	}
-	core$1.disposeHoles(fiber);
+	core$1.disposeHoles(fiber, { morph: true });
 	if (fiber.root instanceof Element && fiber.root.childNodes.length > 0) {
 		const tmp = document.createElement("div");
 		for (const n of core$1.materialize(view, fiber)) tmp.append(n);
@@ -1298,6 +1497,10 @@ const VOID = /* @__PURE__ */ new Set([
 const RAW_TEXT = /* @__PURE__ */ new Set(["script", "style"]);
 const escapeText = (s) => s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 const escapeAttr = (s) => escapeText(s).replaceAll("\"", "&quot;");
+const createSsrRaw = (html) => ({
+	html,
+	kind: "raw"
+});
 const createSsrText = (text) => ({
 	kind: "text",
 	text
@@ -1308,6 +1511,7 @@ const serializeRawText = (tag, text) => {
 };
 const serializeNode = (node) => {
 	if (node.kind === "text") return escapeText(node.text);
+	if (node.kind === "raw") return node.html;
 	const parts = [];
 	for (const [name, value] of node.attrs) parts.push(`${name}="${escapeAttr(value)}"`);
 	const attr = parts.length > 0 ? ` ${parts.join(" ")}` : "";
@@ -1364,7 +1568,11 @@ const createSsrElement = (tag) => {
 		tag: lower,
 		tagName: lower.toUpperCase(),
 		get textContent() {
-			return children.map((n) => n.kind === "text" ? n.text : n.textContent).join("");
+			return children.map((n) => {
+				if (n.kind === "text") return n.text;
+				if (n.kind === "raw") return n.html;
+				return n.textContent;
+			}).join("");
 		},
 		set textContent(value) {
 			children.length = 0;
@@ -1435,6 +1643,7 @@ const ssrOps = {
 	bindEvents: bindSsrEvents,
 	clearRoot: (root) => ssrAs(root).replaceChildren(),
 	createElement: createSsrElement,
+	createRaw: (html, _parent) => [createSsrRaw(html)],
 	createSlotHost: (slotId) => {
 		const host = createSsrElement("span");
 		if (slotId !== null) host.setAttribute(SLOT_ATTR, slotId);
@@ -1561,4 +1770,4 @@ const renderToString = async (fn, opts) => {
 };
 
 //#endregion
-export { atom as a, instr as c, wrapHandle as d, clearFiberView as f, makeFiber as h, interpret as i, isAtomHandle as l, getFiber as m, renderToString as n, batch as o, closeFiber as p, runSetup as r, handleOwner as s, mount as t, untrack as u };
+export { makeFiber as _, interpret as a, handleOwner as c, structuralEqual as d, untrack as f, getFiber as g, closeFiber as h, runSetup as i, instr as l, clearFiberView as m, renderToString as n, atom as o, wrapHandle as p, unsafe as r, batch as s, mount as t, isAtomHandle as u };

package/dist/types-CJF2qMK6.d.ts

@@ -0,0 +1,100 @@
+import { Effect, Stream } from "effect";
+import { AtomRegistry } from "effect/reactivity/AtomRegistry";
+import "effect/Scope";
+import { Atom } from "effect/reactivity";
+//#region src/types.d.ts
+type JsonText = string | number | bigint | boolean | null | undefined;
+/** Runtime prop bag values painted onto elements / passed to components. */
+type PropValue = JsonText | PropBag | StyleObject | EventHandler | AtomHandle<JsonText> | readonly PropValue[];
+type StyleObject = Readonly<Record<string, string | number | null | undefined>>;
+type EventHandler = (event: Event) => void;
+/** Indexed bag — interface so PropValue can recurse without a circular type alias. */
+interface PropBag {
+  readonly [key: string]: PropValue | undefined;
+}
+type View = VNode | UnsafeHtml | JsonText | AtomHandle<unknown> | Stream.Stream<View, unknown, unknown> | GeneratorFn | Component | View[] | Iterable<View>;
+declare const Fragment: unique symbol;
+type Fragment = typeof Fragment;
+type ComponentFn = (props: PropBag) => View | Promise<View | undefined> | undefined;
+/** JSX/tag component with its own props shape (Provider, ErrorBoundary, …). */
+type JsxComponent = (props: never) => View | Promise<View | undefined> | Generator<View, View | undefined, View> | undefined;
+/** Raw HTML view produced by `unsafe()` — painted without escaping. */
+interface UnsafeHtml {
+  readonly $$ilhaUnsafe: 1;
+  readonly html: string;
+}
+interface VNode {
+  readonly $$ilha: 1;
+  readonly type: string | Fragment | ComponentFn | JsxComponent;
+  readonly props: PropBag;
+  readonly children: View[];
+  readonly key?: string | number;
+}
+type GeneratorFn = () => Generator<Yielded, View | undefined, View>;
+type Yielded = View | Instruction<unknown> | Effect.Effect<unknown, unknown, unknown>;
+interface Instruction<A, E = Error> extends Iterable<Instruction<A, E>, A>, PromiseLike<A> {
+  readonly $$ilhaOp: 1;
+  readonly effect: Effect.Effect<A, E, AtomRegistry>;
+}
+type Component = (() => View | undefined | Promise<View | undefined>) | GeneratorFn;
+interface AtomHandle<A> {
+  readonly $$atom: 1;
+  readonly atom: Atom.Atom<A>;
+  (): A;
+  set: (next: A) => void;
+  update: (f: (current: A) => A) => void;
+}
+/** Equality for plain-value atoms. `"structural"` deep-compares JSON-shaped values. */
+type AtomEquality<A> = "structural" | ((prev: A, next: A) => boolean);
+interface AtomOptions<A = unknown> {
+  /** Skip subscriber notify when `equals(prev, next)` holds. Plain values only. */
+  readonly equals?: AtomEquality<A>;
+}
+/** Optional disposer returned from `watch.once`. */
+type WatchOnceCleanup = () => void;
+/**
+ * Cancellation context handed to watch callbacks. `signal` aborts when the
+ * run goes stale (a newer value arrives), on unmount, or on slot disposal.
+ * Register extra teardowns with `onCleanup`.
+ */
+interface WatchContext {
+  readonly signal: AbortSignal;
+  onCleanup: (fn: () => void) => void;
+}
+type WatchCallback<A> = (value: A, ctx: WatchContext) => WatchOnceCleanup | undefined | Promise<WatchOnceCleanup | undefined>;
+/** Options for `resource()`. */
+interface ResourceOptions {
+  /** Serve cached data while revalidating in the background. Default `true`. */
+  readonly staleWhileRevalidate?: boolean;
+}
+/** Async fetch scoped to a resource key. Receives an abort signal. */
+type ResourceFetcher<T> = (key: string, ctx: {
+  signal: AbortSignal;
+}) => Promise<T>;
+/** Handles returned by `resource()`. */
+interface Resource<T> {
+  readonly data: AtomHandle<T | undefined>;
+  readonly error: AtomHandle<unknown>;
+  readonly loading: AtomHandle<boolean>;
+  refetch: () => Promise<T | undefined>;
+}
+/** Connection state of a `fromEventSource` feed. */
+type EventSourceStatus = "connecting" | "open" | "retrying" | "closed";
+/** Options for `fromEventSource()`. */
+interface EventSourceOptions<T = string> {
+  /** Named event to listen for. Default: the `message` event. */
+  readonly event?: string;
+  /** Decode (and validate) `data` into `T`. Throwing skips the message. */
+  readonly schema?: (data: string) => T;
+  /** Base backoff between reconnects. Default `1000`. Capped at 30s. */
+  readonly retryBaseMs?: number;
+}
+/** Live server-sent-events feed. */
+interface EventSourceFeed<T = string> {
+  /** Paint with `yield Stream.map(feed.stream, ...)`; watch `latest` instead in sync components. */
+  readonly stream: Stream.Stream<T, never, never>;
+  readonly status: AtomHandle<EventSourceStatus>;
+  readonly latest: AtomHandle<T | undefined>;
+}
+//#endregion
+export { Yielded as S, VNode as _, ComponentFn as a, WatchContext as b, EventSourceStatus as c, JsxComponent as d, PropBag as f, UnsafeHtml as g, ResourceOptions as h, Component as i, Fragment as l, ResourceFetcher as m, AtomHandle as n, EventSourceFeed as o, Resource as p, AtomOptions as r, EventSourceOptions as s, AtomEquality as t, Instruction as u, View as v, WatchOnceCleanup as x, WatchCallback as y };

package/dist/{vnode-Bwx8ffNO.d.ts → vnode-CUTNGblA.d.ts}

@@ -1,4 +1,4 @@
-import { c as VNode, i as Fragment, l as View, o as JsxComponent, r as ComponentFn, s as PropBag, t as AtomHandle } from "./types-CUQdA6hR.js";
+import { _ as VNode, a as ComponentFn, d as JsxComponent, f as PropBag, l as Fragment, n as AtomHandle, v as View } from "./types-CJF2qMK6.js";
 //#region src/jsx-types.d.ts
 declare namespace JSX {
   export type Element = View;
@@ -71,9 +71,21 @@ declare namespace JSX {
     onanimationend?: Handler<Target, globalThis.AnimationEvent>;
     onanimationiteration?: Handler<Target, globalThis.AnimationEvent>;
     ontransitionend?: Handler<Target, globalThis.TransitionEvent>;
+    ontoggle?: Handler<Target, globalThis.Event>;
+    onbeforetoggle?: Handler<Target, globalThis.Event>;
+    onclose?: Handler<Target, globalThis.Event>;
+    oncancel?: Handler<Target, globalThis.Event>;
     onload?: Handler<Target, globalThis.Event>;
     onerror?: Handler<Target, globalThis.Event>;
   }
+  /**
+   * Props every JSX tag accepts without a hand-added declaration.
+   * Components receive `key` through this interface, so you never add
+   * `key` to your own prop types.
+   */
+  export interface IntrinsicAttributes {
+    key?: string | number;
+  }
   type AriaProps = Partial<Record<`aria-${string}`, Attr>>;
   type DataProps = Partial<Record<`data-${string}`, Attr>>;
   /** Shared HTML attributes. Prefer `class` / `for`; `className` / `htmlFor` also work. */

package/dist/{vnode-DEMDQ0eA.js → vnode-M-oJMKcv.js}

@@ -1,4 +1,4 @@
-import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+import * as AsyncResult from "effect/reactivity/AsyncResult";
 import * as Option from "effect/Option";
 import * as Result from "effect/Result";