ilha 0.14.0 → 0.14.2

package/dist/{mount-Dcy4teaf.js → mount-CCMOkDSb.js}

@@ -40,6 +40,12 @@ const runInScope = (effect, registry, scope, onOk, onErr, onDone) => {
 function closeFiber(fiber) {
 	if (fiber.closed) return;
 	fiber.closed = true;
+	fiber.trackRestore?.();
+	fiber.trackRestore = void 0;
+	fiber.renderSub?.();
+	fiber.renderSub = void 0;
+	for (const slot of fiber.watchSlots ?? []) slot?.dispose();
+	fiber.watchSlots = [];
 	for (const h of fiber.holes) h.dispose();
 	fiber.holes = [];
 	Effect.runFork(Scope.close(fiber.scope, Exit.void));
@@ -150,11 +156,124 @@ function isAtomHandle(x) {
 	return typeof x === "function" && x.$$atom === 1;
 }
 let trackGet;
+const trackStack = [];
+function beginPrimitiveFrame(fiber) {
+	const used = fiber.primitiveI ?? 0;
+	const slots = fiber.primitives?.length ?? 0;
+	if (used > 0 && used !== slots) console.warn(`ilha: atom/watch slot count changed between renders (${slots} → ${used}); keep primitive order stable`);
+	fiber.primitiveI = 0;
+	fiber.watchI = 0;
+	const islandFrame = fiber.islandFrame ??= {
+		i: 0,
+		slots: []
+	};
+	const usedIslands = islandFrame.i;
+	if (usedIslands < islandFrame.slots.length) {
+		for (let j = usedIslands; j < islandFrame.slots.length; j++) {
+			const slot = islandFrame.slots[j];
+			if (slot) {
+				slot.unmount?.();
+				islandFrame.slots[j] = void 0;
+			}
+		}
+		islandFrame.slots.length = usedIslands;
+	}
+	islandFrame.i = 0;
+}
+function readTracked(atom, registry) {
+	const frame = trackStack.at(-1);
+	const active = getActiveFiber();
+	if (trackGet && frame && active === frame.fiber) return trackGet(atom);
+	return registry.get(atom);
+}
+function usePrimitiveSlot(fiber, make) {
+	const i = fiber.primitiveI ?? 0;
+	fiber.primitiveI = i + 1;
+	fiber.primitives ??= [];
+	const existing = fiber.primitives[i];
+	if (existing) return {
+		atom: existing,
+		fresh: false
+	};
+	const a = make();
+	fiber.primitives[i] = a;
+	return {
+		atom: a,
+		fresh: true
+	};
+}
+function withTrackGetRun(fiber, fn, onOk, onErr) {
+	const deps = /* @__PURE__ */ new Set();
+	const get = (a) => {
+		deps.add(a);
+		return fiber.registry.get(a);
+	};
+	const restore = () => {
+		if (fiber.trackRestore !== restore) return;
+		const top = trackStack.pop();
+		if (top?.get !== get) {
+			if (top) trackStack.push(top);
+			const i = trackStack.findIndex((frame) => frame.get === get);
+			if (i >= 0) trackStack.splice(i, 1);
+		}
+		trackGet = trackStack.at(-1)?.get;
+		fiber.trackRestore = void 0;
+	};
+	trackStack.push({
+		fiber,
+		deps,
+		get
+	});
+	trackGet = get;
+	fiber.trackRestore = restore;
+	try {
+		const result = withFiber(fiber, () => fn());
+		if (result instanceof Promise) {
+			restore();
+			result.then((value) => {
+				if (fiber.closed) return;
+				onOk({
+					value,
+					deps
+				});
+			}).catch((e) => {
+				if (fiber.closed) return;
+				onErr(e);
+			});
+			return;
+		}
+		restore();
+		onOk({
+			value: result,
+			deps
+		});
+	} catch (e) {
+		restore();
+		onErr(e);
+	}
+}
+function subscribeRenderDeps(fiber, deps, run) {
+	if (deps.size === 0) return () => {};
+	let scheduled = false;
+	const schedule = () => {
+		if (scheduled) return;
+		scheduled = true;
+		fiber.runtime.later(() => {
+			scheduled = false;
+			run();
+		});
+	};
+	const unsubs = [];
+	for (const dep of deps) unsubs.push(fiber.registry.subscribe(dep, schedule));
+	return () => {
+		for (const unsub of unsubs) unsub();
+	};
+}
 function wrapHandle(atom, fiber) {
 	const registry = fiber.registry;
 	const read = (() => {
 		guardHandleFiber(read);
-		return trackGet ? trackGet(atom) : registry.get(atom);
+		return readTracked(atom, registry);
 	});
 	handleOwner.set(read, fiber);
 	Object.defineProperties(read, {
@@ -171,34 +290,40 @@ function wrapHandle(atom, fiber) {
 	});
 	return read;
 }
-function atom(init) {
+function makeAtom(init) {
 	const fiber = getFiber();
-	const computed = typeof init === "function" && !Atom.isAtom(init) && !Effect.isEffect(init) && !Stream.isStream(init);
-	let seed = init;
 	const snap = fiber.runtime.hydrateValues;
-	if (snap && !Atom.isAtom(init) && !Effect.isEffect(init) && !Stream.isStream(init)) {
-		const v = snap[fiber.runtime.hydrateI++];
-		if (!computed && v !== void 0) seed = v;
-	}
-	let a;
-	if (Atom.isAtom(seed)) a = seed;
-	else if (Effect.isEffect(seed) || Stream.isStream(seed)) a = Atom.make(seed);
-	else if (computed) {
-		const fn = init;
-		a = Atom.make((get) => {
-			const prev = trackGet;
-			trackGet = (other) => get(other);
-			try {
-				return fn();
-			} finally {
-				trackGet = prev;
-			}
-		});
-	} else a = Atom.make(seed);
+	const { atom: a, fresh } = usePrimitiveSlot(fiber, () => {
+		let seed = init;
+		if (snap && !Atom.isAtom(init) && !Effect.isEffect(init) && !Stream.isStream(init)) {
+			const v = snap[fiber.runtime.hydrateI++];
+			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);
+	});
+	const handle = wrapHandle(a, fiber);
+	if (fresh && fiber.runtime.ssr) fiber.runtime.ssrValues.push(fiber.registry.get(a));
+	return handle;
+}
+function atomLazy(init) {
+	const fiber = getFiber();
+	const snap = fiber.runtime.hydrateValues;
+	const { atom: a, fresh } = usePrimitiveSlot(fiber, () => {
+		let seed = init();
+		if (snap) {
+			const v = snap[fiber.runtime.hydrateI++];
+			if (v !== void 0) seed = v;
+		}
+		return Atom.make(seed);
+	});
 	const handle = wrapHandle(a, fiber);
-	if (fiber.runtime.ssr) fiber.runtime.ssrValues.push(fiber.registry.get(a));
+	if (fresh && fiber.runtime.ssr) fiber.runtime.ssrValues.push(fiber.registry.get(a));
 	return handle;
 }
+const atom = Object.assign(makeAtom, { lazy: atomLazy });
+const batch = Atom.batch;
 
 //#endregion
 //#region src/errors.ts
@@ -308,12 +433,12 @@ function bindEvents(node, props, fiber) {
 //#endregion
 //#region src/morph.ts
 const PRESERVE_ATTR = "data-morph-preserve";
-const KEY_ATTR = "data-ilha-key";
-const SLOT_ATTR = "data-ilha-slot";
+const KEY_ATTR$1 = "data-ilha-key";
+const SLOT_ATTR$1 = "data-ilha-slot";
 function morphKeyOf(el) {
-	const k = el.getAttribute(KEY_ATTR);
+	const k = el.getAttribute(KEY_ATTR$1);
 	if (k !== null) return `k:${k}`;
-	const s = el.getAttribute(SLOT_ATTR);
+	const s = el.getAttribute(SLOT_ATTR$1);
 	return s === null ? null : `s:${s}`;
 }
 function shouldPreserveMorphAttr(el, name) {
@@ -396,17 +521,17 @@ function morphChildren(fromParent, toParent) {
 			if (fromNode instanceof Element) {
 				const fromKey = morphKeyOf(fromNode);
 				if (fromKey !== null && fromKey !== toKey && toKeys.has(fromKey)) {
-					fromParent.insertBefore(toNode.cloneNode(true), fromNode);
+					fromParent.insertBefore(toNode, fromNode);
 					continue;
 				}
 			}
 		}
 		if (!fromNode) {
-			fromParent.appendChild(toNode.cloneNode(true));
+			fromParent.appendChild(toNode);
 			continue;
 		}
 		if (fromNode.nodeType !== toNode.nodeType) {
-			fromParent.replaceChild(toNode.cloneNode(true), fromNode);
+			fromParent.replaceChild(toNode, fromNode);
 			continue;
 		}
 		if (fromNode.nodeType === 3 || fromNode.nodeType === 8) {
@@ -417,10 +542,10 @@ function morphChildren(fromParent, toParent) {
 			const fromEl = fromNode;
 			const toEl = toNode;
 			if (fromEl.localName !== toEl.localName) {
-				fromParent.replaceChild(toEl.cloneNode(true), fromEl);
+				fromParent.replaceChild(toEl, fromEl);
 				continue;
 			}
-			const slotId = toEl.getAttribute(SLOT_ATTR);
+			const slotId = toEl.getAttribute(SLOT_ATTR$1);
 			if (slotId !== null && fromEl.getAttribute("data-ilha-slot") === slotId) continue;
 			if (fromEl.localName === "input") {
 				const hadChecked = fromEl.hasAttribute("checked");
@@ -552,19 +677,39 @@ function finish(fiber, view) {
 	fiber.park();
 }
 function runSetup(fiber, fn) {
-	try {
-		const out = withFiber(fiber, () => fn());
-		if (isGen(out)) interpret((() => out), fiber);
-		else {
-			fiber.runtime.begin();
-			Promise.resolve(out).then((view) => {
-				withFiber(fiber, () => finish(fiber, view));
-				fiber.runtime.end();
-			}, (e) => {
+	const disposeRenderSub = () => {
+		fiber.renderSub?.();
+		fiber.renderSub = void 0;
+	};
+	const commit = (out, deps) => {
+		if (isGen(out)) {
+			disposeRenderSub();
+			interpret((() => out), fiber);
+			return;
+		}
+		disposeRenderSub();
+		if (!fiber.runtime.ssr) fiber.renderSub = subscribeRenderDeps(fiber, deps, render);
+		withFiber(fiber, () => finish(fiber, out));
+	};
+	const render = () => {
+		if (fiber.closed) return;
+		fiber.runtime.begin();
+		beginPrimitiveFrame(fiber);
+		withTrackGetRun(fiber, () => fn(), ({ value: out, deps }) => {
+			try {
+				commit(out, deps);
+			} catch (e) {
 				withFiber(fiber, () => fiber.fail(asFailure(e)));
+			} finally {
 				fiber.runtime.end();
-			});
-		}
+			}
+		}, (e) => {
+			withFiber(fiber, () => fiber.fail(asFailure(e)));
+			fiber.runtime.end();
+		});
+	};
+	try {
+		render();
 	} catch (e) {
 		fiber.fail(asFailure(e));
 	}
@@ -572,20 +717,27 @@ function runSetup(fiber, fn) {
 
 //#endregion
 //#region src/paint.ts
-const ISLAND = Symbol.for("ilha.island");
-const ISLAND_MOUNT_INTERNAL = Symbol.for("ilha.islandMountInternal");
-const ISLAND_SLOT_TAG = Symbol.for("ilha.islandSlotTag");
-function insert(fiber, nodes) {
+const ISLAND$1 = Symbol.for("ilha.island");
+const ISLAND_MOUNT_INTERNAL$1 = Symbol.for("ilha.islandMountInternal");
+const ISLAND_SLOT_TAG$1 = Symbol.for("ilha.islandSlotTag");
+function insert$1(fiber, nodes) {
 	for (const n of nodes) fiber.root.appendChild(n);
 }
-function disposeHoles(fiber) {
-	for (const h of fiber.holes) h.dispose();
-	fiber.holes = [];
+function disposeHoles$1(fiber, opts) {
+	const keep = [];
+	for (const h of fiber.holes) {
+		if (opts?.morph && h.keepOnMorph) {
+			keep.push(h);
+			continue;
+		}
+		h.dispose();
+	}
+	fiber.holes = keep;
 }
-function skip(x) {
+function skip$1(x) {
 	return x === null || x === void 0 || typeof x === "boolean";
 }
-function applyProps(el, props, fiber) {
+function applyProps$1(el, props, fiber) {
 	for (const [k, v] of Object.entries(props)) {
 		if (k === "children" || k === "key" || k === "ref") continue;
 		if (k === "className") {
@@ -640,10 +792,10 @@ function applyProps(el, props, fiber) {
 		fiber.holes.push({ dispose: () => ref(null) });
 	}
 }
-const KEEP = Symbol("keep");
-function unwrap(value, keep) {
+const KEEP$1 = Symbol("keep");
+function unwrap$1(value, keep) {
 	if (AsyncResult.isAsyncResult(value)) {
-		if (AsyncResult.isWaiting(value) && keep !== void 0) return KEEP;
+		if (AsyncResult.isWaiting(value) && keep !== void 0) return KEEP$1;
 		if (AsyncResult.isFailure(value) && !AsyncResult.isWaiting(value)) return String(AsyncResult.error(value) ?? "error");
 		const v = AsyncResult.value(value);
 		if (v._tag === "Some") return v.value;
@@ -651,18 +803,23 @@ function unwrap(value, keep) {
 	}
 	return value;
 }
-function paintHole(fiber, view) {
-	if (view === KEEP) return;
+function paintHole$1(fiber, view) {
+	if (view === KEEP$1) return;
+	const frame = fiber.islandFrame ??= {
+		i: 0,
+		slots: []
+	};
+	frame.i = 0;
 	const list = Array.isArray(view) ? view : null;
 	if (list && list.length > 0 && list.every((v) => isVNode(v) && v.key != null)) {
-		keyedPaintHole(fiber, list);
+		keyedPaintHole$1(fiber, list);
 		return;
 	}
-	disposeHoles(fiber);
+	disposeHoles$1(fiber);
 	if (fiber.root instanceof Element) fiber.root.replaceChildren();
-	insert(fiber, materialize(view, fiber));
+	insert$1(fiber, materialize$1(view, fiber));
 }
-function keyedPaintHole(fiber, views) {
+function keyedPaintHole$1(fiber, views) {
 	const prev = fiber.keyedHoles ?? /* @__PURE__ */ new Map();
 	const keep = new Set(views.map((v) => String(v.key)));
 	for (const [k, h] of prev) if (!keep.has(k)) closeFiber(h);
@@ -676,34 +833,34 @@ function keyedPaintHole(fiber, views) {
 			nodes.push(reuse.root);
 			continue;
 		}
-		const made = materialize(v, fiber);
+		const made = materialize$1(v, fiber);
 		const hole = fiber.keyedHoles?.get(k);
 		if (hole) next.set(k, hole);
 		nodes.push(...made);
 	}
 	fiber.keyedHoles = next;
 	if (fiber.root instanceof Element) fiber.root.replaceChildren();
-	insert(fiber, nodes);
+	insert$1(fiber, nodes);
 }
-function openHole(parent) {
+function openHole$1(parent) {
 	const id = parent.runtime.nextHole();
 	const host = document.createElement("span");
-	host.setAttribute(SLOT_ATTR, String(id));
+	host.setAttribute(SLOT_ATTR$1, String(id));
 	host.style.display = "contents";
 	const child = makeFiber(parent.runtime, host, (f, v) => {
-		disposeHoles(f);
+		disposeHoles$1(f);
 		if (f.root instanceof Element) f.root.replaceChildren();
-		insert(f, materialize(v, f));
+		insert$1(f, materialize$1(v, f));
 	}, { onFail: (e) => {
 		console.error(e);
-		paintHole(child, errorView(e));
+		paintHole$1(child, errorView$1(e));
 	} });
 	return {
 		fiber: child,
 		nodes: [host]
 	};
 }
-function errorView(e) {
+function errorView$1(e) {
 	return {
 		$$ilha: 1,
 		type: "pre",
@@ -711,67 +868,133 @@ function errorView(e) {
 		children: [failureMessage(e)]
 	};
 }
-function trackHole(parent, hole, extra) {
-	parent.holes.push({ dispose() {
-		extra?.();
-		closeFiber(hole);
-	} });
+function findReusableAtomHost$1(fiber, atom) {
+	for (const h of fiber.holes) if (h.atom === atom && h.host?.isConnected && h.holeFiber && !h.holeFiber.closed) return {
+		host: h.host,
+		hole: h.holeFiber
+	};
 }
-function materialize(view, fiber) {
-	if (skip(view)) return [];
+function refreshAtomHost(fiber, atom, host, hole) {
+	if (hole.closed || !host.isConnected) return;
+	const next = unwrap$1(fiber.registry.get(atom), void 0);
+	if (next === KEEP$1) return;
+	paintHole$1(hole, next);
+}
+function refreshAllAtomHosts(fiber) {
+	for (const h of fiber.holes) if (h.atom && h.host && h.holeFiber) refreshAtomHost(fiber, h.atom, h.host, h.holeFiber);
+}
+function pruneDisconnectedAtomHoles(fiber) {
+	fiber.holes = fiber.holes.filter((h) => {
+		if (!h.atom || !h.host || !h.holeFiber) return true;
+		if (h.host.isConnected) return true;
+		h.dispose();
+		return false;
+	});
+}
+function atomHostPlaceholder$1(host) {
+	const placeholder = document.createElement("span");
+	const slot = host.getAttribute(SLOT_ATTR$1);
+	if (slot !== null) placeholder.setAttribute(SLOT_ATTR$1, slot);
+	placeholder.style.display = "contents";
+	return placeholder;
+}
+function trackHole$1(parent, hole, extra, meta) {
+	parent.holes.push({
+		keepOnMorph: !!(meta?.atom && meta?.host) || !!meta?.keyed,
+		atom: meta?.atom,
+		host: meta?.host,
+		holeFiber: hole,
+		dispose() {
+			extra?.();
+			closeFiber(hole);
+		}
+	});
+}
+function materialize$1(view, fiber) {
+	if (skip$1(view)) return [];
 	if (typeof view === "string" || typeof view === "number" || typeof view === "bigint") return [document.createTextNode(String(view))];
 	if (isAtomHandle(view)) {
-		const { fiber: hole, nodes } = openHole(fiber);
+		const reused = findReusableAtomHost$1(fiber, view.atom);
+		if (reused) return [atomHostPlaceholder$1(reused.host)];
+		const { fiber: hole, nodes } = openHole$1(fiber);
+		const host = nodes[0];
 		let unsub = () => {};
 		fiber.runtime.later(() => {
 			if (hole.closed) return;
 			let keep;
 			unsub = fiber.registry.subscribe(view.atom, (v) => {
 				if (hole.closed) return;
-				const next = unwrap(v, keep);
-				if (next === KEEP) return;
+				const next = unwrap$1(v, keep);
+				if (next === KEEP$1) return;
 				keep = next;
-				paintHole(hole, next);
+				paintHole$1(hole, next);
 			}, { immediate: true });
 		});
-		trackHole(fiber, hole, () => unsub());
+		trackHole$1(fiber, hole, () => unsub(), {
+			atom: view.atom,
+			host
+		});
 		return nodes;
 	}
 	if (Stream.isStream(view)) {
-		const { fiber: hole, nodes } = openHole(fiber);
+		const { fiber: hole, nodes } = openHole$1(fiber);
 		const src = fiber.runtime.ssr ? view.pipe(Stream.take(1)) : view;
 		hole.run(Stream.runForEach(src, (v) => Effect.sync(() => {
-			if (!hole.closed) paintHole(hole, v);
+			if (!hole.closed) paintHole$1(hole, v);
 		})).pipe(Effect.catch((e) => Effect.sync(() => {
-			if (!hole.closed) paintHole(hole, String(e));
+			if (!hole.closed) paintHole$1(hole, String(e));
 		}))), fiber.runtime.ssr ? () => {} : void 0);
-		trackHole(fiber, hole);
+		trackHole$1(fiber, hole);
 		return nodes;
 	}
 	if (isSetupFn(view)) {
-		const { fiber: hole, nodes } = openHole(fiber);
+		const { fiber: hole, nodes } = openHole$1(fiber);
 		fiber.runtime.later(() => {
 			if (!hole.closed) runSetup(hole, view);
 		});
-		trackHole(fiber, hole);
+		trackHole$1(fiber, hole);
 		return nodes;
 	}
 	if (isVNode(view)) {
-		if (view.type === Fragment) return view.children.flatMap((c) => materialize(c, fiber));
+		if (view.type === Fragment) return view.children.flatMap((c) => materialize$1(c, fiber));
 		if (typeof view.type === "function") {
 			const props = {
 				...view.props,
 				children: view.children
 			};
 			const type = view.type;
-			if (type[ISLAND] === true) {
-				const tag = typeof type[ISLAND_SLOT_TAG] === "string" ? type[ISLAND_SLOT_TAG] : "div";
+			if (type[ISLAND$1] === true) {
+				const frame = fiber.islandFrame ??= {
+					i: 0,
+					slots: []
+				};
+				const i = frame.i++;
+				const existing = frame.slots[i];
+				if (existing && existing.type === type && existing.host.isConnected && typeof existing.updateProps === "function") {
+					existing.updateProps(props);
+					return [existing.host];
+				}
+				existing?.unmount?.();
+				const tag = typeof type[ISLAND_SLOT_TAG$1] === "string" ? type[ISLAND_SLOT_TAG$1] : "div";
 				const el = document.createElement(tag);
 				el.setAttribute("data-ilha", "");
-				const mountFn = type[ISLAND_MOUNT_INTERNAL];
+				const mountFn = type[ISLAND_MOUNT_INTERNAL$1];
 				if (typeof mountFn === "function") {
 					const handle = mountFn(el, props);
-					fiber.holes.push({ dispose: () => handle?.unmount?.() });
+					const slot = {
+						type,
+						host: el,
+						updateProps: handle?.updateProps,
+						unmount: handle?.unmount
+					};
+					frame.slots[i] = slot;
+					fiber.holes.push({
+						keepOnMorph: true,
+						dispose: () => {
+							handle?.unmount?.();
+							if (frame.slots[i] === slot) frame.slots[i] = void 0;
+						}
+					});
 				}
 				return [el];
 			}
@@ -783,7 +1006,7 @@ function materialize(view, fiber) {
 				if (next && typeof next.then !== "function" && !isSetupFn(next)) reuse.paint(next);
 				return [reuse.root];
 			}
-			const { fiber: hole, nodes } = openHole(fiber);
+			const { fiber: hole, nodes } = openHole$1(fiber);
 			hole.propsBox = { current: props };
 			if (k) {
 				fiber.keyedHoles ??= /* @__PURE__ */ new Map();
@@ -792,12 +1015,12 @@ function materialize(view, fiber) {
 			fiber.runtime.later(() => {
 				if (!hole.closed) runSetup(hole, () => type(hole.propsBox.current));
 			});
-			trackHole(fiber, hole);
+			trackHole$1(fiber, hole, void 0, k ? { keyed: true } : void 0);
 			return nodes;
 		}
 		const el = document.createElement(view.type);
-		if (view.key != null) el.setAttribute(KEY_ATTR, String(view.key));
-		applyProps(el, view.props, fiber);
+		if (view.key != null) el.setAttribute(KEY_ATTR$1, String(view.key));
+		applyProps$1(el, view.props, fiber);
 		fiber.keyedHoles ??= /* @__PURE__ */ new Map();
 		const childFiber = {
 			...fiber,
@@ -805,10 +1028,10 @@ function materialize(view, fiber) {
 			holes: fiber.holes,
 			keyedHoles: fiber.keyedHoles
 		};
-		for (const c of view.children) for (const n of materialize(c, childFiber)) el.appendChild(n);
+		for (const c of view.children) for (const n of materialize$1(c, childFiber)) el.appendChild(n);
 		return [el];
 	}
-	if (Array.isArray(view) || view && typeof view === "object" && Symbol.iterator in Object(view)) return [...view].flatMap((c) => materialize(c, fiber));
+	if (Array.isArray(view) || view && typeof view === "object" && Symbol.iterator in Object(view)) return [...view].flatMap((c) => materialize$1(c, fiber));
 	return [document.createTextNode(String(view))];
 }
 function canHydrate(fiber, view) {
@@ -816,20 +1039,24 @@ function canHydrate(fiber, view) {
 	const el = fiber.root.firstElementChild;
 	return !!el && el.tagName === view.type.toUpperCase();
 }
-function paint(fiber, view) {
+function paint$1(fiber, view) {
+	fiber.islandFrame ??= {
+		i: 0,
+		slots: []
+	};
 	if (fiber.hydrate) {
 		if (canHydrate(fiber, view)) {
 			const el = fiber.root.firstElementChild;
 			fiber.hydrate = false;
 			fiber.liveEl = el;
-			applyProps(el, view.props, fiber);
+			applyProps$1(el, view.props, fiber);
 			const childFiber = {
 				...fiber,
 				root: el,
 				holes: fiber.holes
 			};
 			el.replaceChildren();
-			for (const c of view.children) for (const n of materialize(c, childFiber)) el.appendChild(n);
+			for (const c of view.children) for (const n of materialize$1(c, childFiber)) el.appendChild(n);
 			return;
 		} else {
 			console.warn("[ilha] hydrate mismatch, full mount");
@@ -838,28 +1065,31 @@ function paint(fiber, view) {
 		}
 	}
 	if (fiber.liveEl && isVNode(view) && typeof view.type === "string" && fiber.liveEl.localName === view.type) {
-		applyProps(fiber.liveEl, view.props, fiber);
+		disposeHoles$1(fiber, { morph: true });
+		applyProps$1(fiber.liveEl, view.props, fiber);
 		const tmp = document.createElement(fiber.liveEl.localName);
-		for (const c of view.children) for (const n of materialize(c, fiber)) tmp.appendChild(n);
+		for (const c of view.children) for (const n of materialize$1(c, fiber)) tmp.appendChild(n);
 		morphInner(fiber.liveEl, tmp);
+		refreshAllAtomHosts(fiber);
+		pruneDisconnectedAtomHoles(fiber);
 		return;
 	}
-	disposeHoles(fiber);
+	disposeHoles$1(fiber);
 	if (fiber.root instanceof Element && fiber.root.childNodes.length > 0) {
 		const tmp = document.createElement("div");
-		for (const n of materialize(view, fiber)) tmp.appendChild(n);
+		for (const n of materialize$1(view, fiber)) tmp.appendChild(n);
 		morphInner(fiber.root, tmp);
 		const first = fiber.root.firstElementChild;
 		if (first) fiber.liveEl = first;
 		return;
 	}
-	insert(fiber, materialize(view, fiber));
+	insert$1(fiber, materialize$1(view, fiber));
 	const first = fiber.root instanceof Element ? fiber.root.firstElementChild : null;
 	if (first) fiber.liveEl = first;
 }
-function paintError(fiber, e) {
+function paintError$1(fiber, e) {
 	console.error(e);
-	paint(fiber, errorView(e));
+	paint$1(fiber, errorView$1(e));
 }
 
 //#endregion
@@ -912,10 +1142,466 @@ function decodeSnapshot(raw) {
 }
 
 //#endregion
-//#region src/mount.ts
+//#region src/ssr-dom.ts
+const VOID = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+/** Tags whose children are raw text — do not HTML-escape content. */
+const RAW_TEXT = /* @__PURE__ */ new Set(["script", "style"]);
+function escapeText(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
 function escapeAttr(s) {
-	return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+	return escapeText(s).replace(/"/g, "&quot;");
+}
+function createSsrText(text) {
+	return {
+		kind: "text",
+		text
+	};
+}
+function createSsrElement(tag) {
+	const lower = tag.toLowerCase();
+	const children = [];
+	const el = {
+		kind: "element",
+		tag: lower,
+		attrs: /* @__PURE__ */ new Map(),
+		children,
+		isConnected: true,
+		tagName: lower.toUpperCase(),
+		localName: lower,
+		setAttribute(name, value) {
+			el.attrs.set(name, value);
+		},
+		getAttribute(name) {
+			return el.attrs.has(name) ? el.attrs.get(name) : null;
+		},
+		removeAttribute(name) {
+			el.attrs.delete(name);
+		},
+		hasAttribute(name) {
+			return el.attrs.has(name);
+		},
+		replaceChildren(...nodes) {
+			children.length = 0;
+			children.push(...nodes);
+		},
+		appendChild(node) {
+			children.push(node);
+		},
+		get textContent() {
+			return children.map((n) => n.kind === "text" ? n.text : n.textContent).join("");
+		},
+		set textContent(value) {
+			children.length = 0;
+			children.push(createSsrText(value));
+		}
+	};
+	return el;
+}
+function createSsrRoot() {
+	const children = [];
+	return {
+		kind: "root",
+		children,
+		appendChild(node) {
+			children.push(node);
+		},
+		replaceChildren() {
+			children.length = 0;
+		},
+		get innerHTML() {
+			return children.map(serializeNode).join("");
+		}
+	};
+}
+function serializeRawText(tag, text) {
+	if (new RegExp(`</${tag}\\b`, "i").test(text)) throw new Error(`ilha: unsafe raw text in <${tag}> (contains "</${tag}")`);
+	return text;
+}
+function serializeNode(node) {
+	if (node.kind === "text") return escapeText(node.text);
+	const parts = [];
+	for (const [name, value] of node.attrs) parts.push(`${name}="${escapeAttr(value)}"`);
+	const attr = parts.length > 0 ? ` ${parts.join(" ")}` : "";
+	const tag = node.tag;
+	if (VOID.has(tag)) return `<${tag}${attr}>`;
+	if (RAW_TEXT.has(tag)) return `<${tag}${attr}>${serializeRawText(tag, node.textContent)}</${tag}>`;
+	return `<${tag}${attr}>${node.children.map(serializeNode).join("")}</${tag}>`;
+}
+
+//#endregion
+//#region src/ssr-paint.ts
+const KEY_ATTR = "data-ilha-key";
+const SLOT_ATTR = "data-ilha-slot";
+const ISLAND = Symbol.for("ilha.island");
+const ISLAND_MOUNT_INTERNAL = Symbol.for("ilha.islandMountInternal");
+const ISLAND_SLOT_TAG = Symbol.for("ilha.islandSlotTag");
+function insert(fiber, nodes) {
+	const root = fiber.root;
+	for (const n of nodes) root.appendChild(n);
+}
+function disposeHoles(fiber) {
+	for (const h of fiber.holes) h.dispose();
+	fiber.holes = [];
+}
+function skip(x) {
+	return x === null || x === void 0 || typeof x === "boolean";
+}
+function bindSsrEvents(el, props, fiber) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(props)) {
+		const type = eventTypeFromProp(key);
+		if (!type || seen.has(type)) continue;
+		seen.add(type);
+		const fn = props[key];
+		if (typeof fn !== "function") continue;
+		const branded = fn[Symbol.for("ilha.actionCall")];
+		const rec = branded?.k ? {
+			k: branded.k,
+			a: branded.a ?? []
+		} : void 0;
+		if (!rec) continue;
+		const id = `${type}:${fiber.runtime.ssrEventI++}`;
+		fiber.runtime.ssrActions[id] = rec;
+		const existing = el.getAttribute("data-ilha-on");
+		el.setAttribute("data-ilha-on", existing ? `${existing},${id}` : id);
+	}
+}
+function applyProps(el, props, fiber) {
+	for (const [k, v] of Object.entries(props)) {
+		if (k === "children" || k === "key" || k === "ref") continue;
+		if (k === "className") {
+			el.setAttribute("class", String(v ?? ""));
+			continue;
+		}
+		if (k === "htmlFor") {
+			el.setAttribute("for", String(v ?? ""));
+			continue;
+		}
+		if (k.toLowerCase() === "srcdoc") continue;
+		if (k === "style" && v != null && v !== false) {
+			const css = typeof v === "string" || typeof v === "object" ? serializeStyleAttr(v) : "";
+			if (css) el.setAttribute("style", css);
+			continue;
+		}
+		if (isEventProp(k)) continue;
+		if (/^on[A-Z]/.test(k)) continue;
+		if (k === "value" || k === "checked" || k === "selected") {
+			const setProp = (x) => {
+				if (k === "value") el.setAttribute("value", String(x ?? ""));
+				else if (k === "checked") {
+					if (x) el.setAttribute("checked", "");
+					else el.removeAttribute("checked");
+				} else if (x) el.setAttribute("selected", "");
+				else el.removeAttribute("selected");
+			};
+			if (isAtomHandle(v)) {
+				const unsub = fiber.registry.subscribe(v.atom, setProp, { immediate: true });
+				fiber.holes.push({ dispose: unsub });
+			} else setProp(v);
+			continue;
+		}
+		if (typeof v === "function") continue;
+		if (v === false || v === null || v === void 0) el.removeAttribute(k);
+		else {
+			const str = v === true ? "" : String(v);
+			if (isUrlAttributeName(k) && !isSafeUrlAttrValue(el.tagName, k, str)) continue;
+			el.setAttribute(k, str);
+		}
+	}
+	bindSsrEvents(el, props, fiber);
+	const ref = props.ref;
+	if (typeof ref === "function") {
+		ref(el);
+		fiber.holes.push({ dispose: () => ref(null) });
+	}
+}
+const KEEP = Symbol("keep");
+function unwrap(value, keep) {
+	if (AsyncResult.isAsyncResult(value)) {
+		if (AsyncResult.isWaiting(value) && keep !== void 0) return KEEP;
+		if (AsyncResult.isFailure(value) && !AsyncResult.isWaiting(value)) return String(AsyncResult.error(value) ?? "error");
+		const v = AsyncResult.value(value);
+		if (v._tag === "Some") return v.value;
+		return "";
+	}
+	return value;
+}
+function paintHole(fiber, view) {
+	if (view === KEEP) return;
+	const frame = fiber.islandFrame ??= {
+		i: 0,
+		slots: []
+	};
+	frame.i = 0;
+	const list = Array.isArray(view) ? view : null;
+	if (list && list.length > 0 && list.every((v) => isVNode(v) && v.key != null)) {
+		keyedPaintHole(fiber, list);
+		return;
+	}
+	disposeHoles(fiber);
+	fiber.root.replaceChildren();
+	insert(fiber, materialize(view, fiber));
+}
+function keyedPaintHole(fiber, views) {
+	const prev = fiber.keyedHoles ?? /* @__PURE__ */ new Map();
+	const keep = new Set(views.map((v) => String(v.key)));
+	for (const [k, h] of prev) if (!keep.has(k)) closeFiber(h);
+	const next = /* @__PURE__ */ new Map();
+	const nodes = [];
+	for (const v of views) {
+		const k = String(v.key);
+		const reuse = prev.get(k);
+		if (reuse && !reuse.closed) {
+			next.set(k, reuse);
+			nodes.push(reuse.root);
+			continue;
+		}
+		const made = materialize(v, fiber);
+		const hole = fiber.keyedHoles?.get(k);
+		if (hole) next.set(k, hole);
+		nodes.push(...made);
+	}
+	fiber.keyedHoles = next;
+	fiber.root.replaceChildren();
+	insert(fiber, nodes);
+}
+function openHole(parent) {
+	const id = parent.runtime.nextHole();
+	const host = createSsrElement("span");
+	host.setAttribute(SLOT_ATTR, String(id));
+	host.setAttribute("style", "display:contents");
+	const child = makeFiber(parent.runtime, host, paint, { onFail: (e) => {
+		console.error(e);
+		paintHole(child, errorView(e));
+	} });
+	return {
+		fiber: child,
+		nodes: [host]
+	};
+}
+function errorView(e) {
+	return {
+		$$ilha: 1,
+		type: "pre",
+		props: { "data-ilha-error": "" },
+		children: [failureMessage(e)]
+	};
 }
+function findReusableAtomHost(fiber, atom) {
+	for (const h of fiber.holes) {
+		const host = h.host;
+		if (h.atom === atom && host?.isConnected && h.holeFiber && !h.holeFiber.closed) return {
+			host,
+			hole: h.holeFiber
+		};
+	}
+}
+function atomHostPlaceholder(host) {
+	const placeholder = createSsrElement("span");
+	const slot = host.getAttribute(SLOT_ATTR);
+	if (slot !== null) placeholder.setAttribute(SLOT_ATTR, slot);
+	placeholder.setAttribute("style", "display:contents");
+	return placeholder;
+}
+function trackHole(parent, hole, extra, meta) {
+	parent.holes.push({
+		keepOnMorph: !!(meta?.atom && meta?.host) || !!meta?.keyed,
+		atom: meta?.atom,
+		host: meta?.host,
+		holeFiber: hole,
+		dispose() {
+			extra?.();
+			if (meta?.host) meta.host.isConnected = false;
+			closeFiber(hole);
+		}
+	});
+}
+function materialize(view, fiber) {
+	if (skip(view)) return [];
+	if (typeof view === "string" || typeof view === "number" || typeof view === "bigint") return [createSsrText(String(view))];
+	if (isAtomHandle(view)) {
+		const reused = findReusableAtomHost(fiber, view.atom);
+		if (reused) return [atomHostPlaceholder(reused.host)];
+		const { fiber: hole, nodes } = openHole(fiber);
+		const host = nodes[0];
+		let unsub = () => {};
+		fiber.runtime.later(() => {
+			if (hole.closed) return;
+			let keep;
+			unsub = fiber.registry.subscribe(view.atom, (v) => {
+				if (hole.closed) return;
+				const next = unwrap(v, keep);
+				if (next === KEEP) return;
+				keep = next;
+				paintHole(hole, next);
+			}, { immediate: true });
+		});
+		trackHole(fiber, hole, () => unsub(), {
+			atom: view.atom,
+			host
+		});
+		return nodes;
+	}
+	if (Stream.isStream(view)) {
+		const { fiber: hole, nodes } = openHole(fiber);
+		hole.run(Stream.runForEach(view.pipe(Stream.take(1)), (v) => Effect.sync(() => {
+			if (!hole.closed) paintHole(hole, v);
+		})).pipe(Effect.catch((e) => Effect.sync(() => {
+			if (!hole.closed) paintHole(hole, String(e));
+		}))), () => {});
+		trackHole(fiber, hole);
+		return nodes;
+	}
+	if (isSetupFn(view)) {
+		const { fiber: hole, nodes } = openHole(fiber);
+		fiber.runtime.later(() => {
+			if (!hole.closed) runSetup(hole, view);
+		});
+		trackHole(fiber, hole);
+		return nodes;
+	}
+	if (isVNode(view)) {
+		if (view.type === Fragment) return view.children.flatMap((c) => materialize(c, fiber));
+		if (typeof view.type === "function") {
+			const props = {
+				...view.props,
+				children: view.children
+			};
+			const type = view.type;
+			if (type[ISLAND] === true) {
+				const frame = fiber.islandFrame ??= {
+					i: 0,
+					slots: []
+				};
+				const i = frame.i++;
+				const existing = frame.slots[i];
+				if (existing && existing.type === type && existing.host.isConnected && typeof existing.updateProps === "function") {
+					existing.updateProps(props);
+					return [existing.host];
+				}
+				existing?.unmount?.();
+				const tag = typeof type[ISLAND_SLOT_TAG] === "string" ? type[ISLAND_SLOT_TAG] : "div";
+				const el = createSsrElement(tag);
+				el.setAttribute("data-ilha", "");
+				const mountFn = type[ISLAND_MOUNT_INTERNAL];
+				if (typeof mountFn === "function") {
+					const handle = mountFn(el, props);
+					const slot = {
+						type,
+						host: el,
+						updateProps: handle?.updateProps,
+						unmount: handle?.unmount
+					};
+					frame.slots[i] = slot;
+					fiber.holes.push({
+						keepOnMorph: true,
+						dispose: () => {
+							el.isConnected = false;
+							handle?.unmount?.();
+							if (frame.slots[i] === slot) frame.slots[i] = void 0;
+						}
+					});
+				}
+				return [el];
+			}
+			const k = view.key == null ? void 0 : String(view.key);
+			const reuse = k ? fiber.keyedHoles?.get(k) : void 0;
+			if (reuse && !reuse.closed) {
+				if (reuse.propsBox) reuse.propsBox.current = props;
+				const next = withFiber(fiber, () => type(reuse.propsBox?.current ?? props));
+				if (next && typeof next.then !== "function" && !isSetupFn(next)) reuse.paint(next);
+				return [reuse.root];
+			}
+			const { fiber: hole, nodes } = openHole(fiber);
+			hole.propsBox = { current: props };
+			if (k) {
+				fiber.keyedHoles ??= /* @__PURE__ */ new Map();
+				fiber.keyedHoles.set(k, hole);
+			}
+			fiber.runtime.later(() => {
+				if (!hole.closed) runSetup(hole, () => type(hole.propsBox.current));
+			});
+			trackHole(fiber, hole, void 0, k ? { keyed: true } : void 0);
+			return nodes;
+		}
+		const el = createSsrElement(view.type);
+		if (view.key != null) el.setAttribute(KEY_ATTR, String(view.key));
+		applyProps(el, view.props, fiber);
+		fiber.keyedHoles ??= /* @__PURE__ */ new Map();
+		const childFiber = {
+			...fiber,
+			root: el,
+			holes: fiber.holes,
+			keyedHoles: fiber.keyedHoles
+		};
+		for (const c of view.children) for (const n of materialize(c, childFiber)) el.appendChild(n);
+		return [el];
+	}
+	if (Array.isArray(view) || view && typeof view === "object" && Symbol.iterator in Object(view)) return [...view].flatMap((c) => materialize(c, fiber));
+	return [createSsrText(String(view))];
+}
+function paint(fiber, view) {
+	fiber.islandFrame ??= {
+		i: 0,
+		slots: []
+	};
+	disposeHoles(fiber);
+	fiber.root.replaceChildren();
+	insert(fiber, materialize(view, fiber));
+}
+function paintError(fiber, e) {
+	console.error(e);
+	paint(fiber, errorView(e));
+}
+function attachSsr(fn, opts) {
+	const root = createSsrRoot();
+	const runtime = makeRuntime({
+		ssr: true,
+		ssrCapture: opts?.ssrCapture === true
+	});
+	let resolve;
+	const ready = new Promise((r) => {
+		resolve = r;
+	});
+	const fiber = makeFiber(runtime, root, paint, { onFail: (e) => {
+		opts?.onError?.(e);
+		paintError(fiber, e);
+		resolve();
+	} });
+	runtime.begin();
+	runtime.setIdle(resolve);
+	runSetup(fiber, fn);
+	runtime.end();
+	return {
+		root,
+		ready,
+		runtime,
+		unmount() {
+			closeFiber(fiber);
+			runtime.close();
+			root.replaceChildren();
+		}
+	};
+}
+
+//#endregion
+//#region src/mount.ts
 function readHydrate(el) {
 	const raw = (el.hasAttribute("data-ilha") ? el : el.querySelector("[data-ilha]"))?.getAttribute("data-ilha-state");
 	if (raw) return decodeSnapshot(raw);
@@ -928,18 +1614,14 @@ function readHydrate(el) {
 }
 function attach(el, fn, opts) {
 	if (!opts?.hydrate) el.innerHTML = "";
-	const runtime = makeRuntime({
-		ssr: opts?.ssr,
-		ssrCapture: opts?.ssrCapture,
-		hydrate: opts?.hydrate ? readHydrate(el) : void 0
-	});
+	const runtime = makeRuntime({ hydrate: opts?.hydrate ? readHydrate(el) : void 0 });
 	let resolve;
 	const ready = new Promise((r) => {
 		resolve = r;
 	});
-	const fiber = makeFiber(runtime, el, paint, { onFail: (e) => {
+	const fiber = makeFiber(runtime, el, paint$1, { onFail: (e) => {
 		opts?.onError?.(e);
-		paintError(fiber, e);
+		paintError$1(fiber, e);
 		resolve();
 	} });
 	if (opts?.hydrate) fiber.hydrate = true;
@@ -960,26 +1642,13 @@ function attach(el, fn, opts) {
 function mount(el, fn, opts) {
 	return attach(el, fn, opts).unmount;
 }
-let domReady;
-function ensureDocument() {
-	if (typeof globalThis.document !== "undefined") return Promise.resolve();
-	domReady ??= import("@happy-dom/global-registrator").then(({ GlobalRegistrator }) => {
-		if (typeof globalThis.document === "undefined") GlobalRegistrator.register();
-	});
-	return domReady;
-}
 async function renderToString(fn, opts) {
-	await ensureDocument();
 	const snapshot = opts?.snapshot !== false;
 	const markers = opts?.markers !== false;
-	const el = document.createElement("div");
-	const { unmount, ready, runtime } = attach(el, fn, {
-		ssr: true,
-		ssrCapture: opts?.captureActions === true
-	});
+	const { unmount, ready, runtime, root } = attachSsr(fn, { ssrCapture: opts?.captureActions === true });
 	if (opts?.timeout == null) await ready;
 	else await Promise.race([ready, new Promise((r) => setTimeout(r, opts.timeout))]);
-	let inner = el.innerHTML;
+	let inner = root.innerHTML;
 	const actions = runtime.ssrActions;
 	if (Object.keys(actions).length > 0) inner = `<template data-ilha-actions="${escapeAttr(JSON.stringify(actions))}"></template>${inner}`;
 	const snap = snapshot ? encodeSnapshot(runtime.ssrValues) : void 0;
@@ -989,4 +1658,4 @@ async function renderToString(fn, opts) {
 }
 
 //#endregion
-export { atom as a, isAtomHandle as c, makeFiber as d, interpret as i, closeFiber as l, renderToString as n, handleOwner as o, paint as r, instr as s, mount as t, getFiber as u };
+export { atom as a, instr as c, getFiber as d, makeFiber as f, interpret as i, isAtomHandle as l, renderToString as n, batch as o, paint$1 as r, handleOwner as s, mount as t, closeFiber as u };