ilha 0.12.1 → 0.14.0

package/dist/index.js

@@ -1,2984 +1,65 @@
-import { ISLAND_MOUNT_HANDLES, ISLAND_MOUNT_INTERNAL, serializeServerManifest, setJsxRuntimeBridge, setServerActionBinder } from "./internal.js";
-import { effect as effect$1, endBatch, setActiveSub, signal, startBatch } from "alien-signals";
+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 { i as Fragment, t as h } from "./vnode-DHN2EFHi.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Scope from "effect/Scope";
+import * as Deferred from "effect/Deferred";
 
-//#region src/index.ts
-const __DEV__ = false;
-const MAX_SNAPSHOT_CHARS = 262144;
-const MAX_SNAPSHOT_DEPTH = 32;
-function exceedsMaxDepth(value, depth) {
-	if (depth > MAX_SNAPSHOT_DEPTH) return true;
-	if (value === null || typeof value !== "object") return false;
-	if (Array.isArray(value)) {
-		for (const item of value) if (exceedsMaxDepth(item, depth + 1)) return true;
-		return false;
-	}
-	for (const key in value) {
-		if (!Object.hasOwn(value, key)) continue;
-		if (exceedsMaxDepth(value[key], depth + 1)) return true;
-	}
-	return false;
-}
-const UNSAFE_SNAPSHOT_KEYS = /* @__PURE__ */ new Set([
-	"__proto__",
-	"constructor",
-	"prototype"
-]);
-function stripUnsafeKeys(value) {
-	if (value === null || typeof value !== "object") return;
-	if (Array.isArray(value)) {
-		for (const item of value) stripUnsafeKeys(item);
-		return;
-	}
-	for (const key of Object.getOwnPropertyNames(value)) if (UNSAFE_SNAPSHOT_KEYS.has(key)) delete value[key];
-	else stripUnsafeKeys(value[key]);
-}
-function safeParseSnapshot(raw, label) {
-	if (raw.length > MAX_SNAPSHOT_CHARS) {
-		`${label}`;
-		return;
-	}
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch {
-		`${label}`;
-		return;
-	}
-	if (exceedsMaxDepth(parsed, 1)) {
-		`${label}`;
-		return;
-	}
-	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-		`${label}`;
-		return;
-	}
-	stripUnsafeKeys(parsed);
-	return parsed;
-}
-function shallowEqualInput(a, b) {
-	if (Object.is(a, b)) return true;
-	if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) return false;
-	const ak = Object.keys(a);
-	const bk = Object.keys(b);
-	if (ak.length !== bk.length) return false;
-	for (const k of ak) {
-		if (!Object.hasOwn(b, k)) return false;
-		if (!Object.is(a[k], b[k])) return false;
-	}
-	return true;
-}
-function parseHtmlFragment(html) {
-	const tpl = document.createElement("template");
-	tpl.innerHTML = html;
-	return tpl.content;
-}
-function extractDirectChildSlotIdsInOrder(root) {
-	const ids = [];
-	for (const el of root.querySelectorAll("[data-ilha-slot]")) {
-		if (!(el instanceof Element)) continue;
-		let parent = el.parentElement ?? el.parentNode;
-		let nested = false;
-		while (parent && parent !== root) {
-			if (parent instanceof Element && parent.hasAttribute("data-ilha-slot")) {
-				nested = true;
-				break;
-			}
-			parent = parent instanceof Element ? parent.parentElement ?? parent.parentNode : parent.parentNode;
-		}
-		if (!nested) ids.push(el.getAttribute("data-ilha-slot"));
-	}
-	return ids;
-}
-function extractSlotPropsAttr(root, slotId) {
-	for (const el of root.querySelectorAll(`[${SLOT_ATTR}]`)) if (el.getAttribute(SLOT_ATTR) === slotId) return el.getAttribute(PROPS_ATTR) ?? "";
-	return null;
-}
-const SLOT_TAG_NAME_RE = /^[a-z][a-z0-9-]*$/i;
-function assertValidSlotTagName(tag) {
-	const trimmed = tag.trim();
-	if (trimmed.length === 0) throw new Error("The { as } option requires a non-empty HTML tag name.");
-	if (!SLOT_TAG_NAME_RE.test(trimmed)) throw new Error(`The { as } option tag must be a valid HTML element name (got "${tag}"). Use names like "span", "div", or "li".`);
-	return trimmed.toLowerCase();
-}
-function getIslandSlotTag(island) {
-	const tag = island[ISLAND_SLOT_TAG];
-	if (typeof tag === "string" && tag.length > 0) return tag;
-	return "div";
-}
-function wrapIslandSlotHtml({ tag, id, propsAttr, inner }) {
-	return `<${tag} ${SLOT_ATTR}="${escapeHtml(id)}"${propsAttr}>${inner}</${tag}>`;
-}
-function isStableInlineSlotMount({ initialHtml, renderedHtml, slotIds }) {
-	if (typeof document === "undefined") return false;
-	const initialRoot = parseHtmlFragment(initialHtml);
-	const renderedRoot = parseHtmlFragment(renderedHtml);
-	const initialOrder = extractDirectChildSlotIdsInOrder(initialRoot);
-	const renderedOrder = extractDirectChildSlotIdsInOrder(renderedRoot);
-	if (initialOrder.length !== renderedOrder.length || initialOrder.some((id, i) => id !== renderedOrder[i])) return false;
-	for (const id of slotIds) {
-		const initialProps = extractSlotPropsAttr(initialRoot, id);
-		const renderedProps = extractSlotPropsAttr(renderedRoot, id);
-		if (initialProps === null || renderedProps === null) return false;
-		if (initialProps !== renderedProps) return false;
-	}
-	return true;
-}
-/**
-* Props safe to embed in `data-ilha-props`.
-* Functions cannot round-trip through JSON; children are owned by the live slot
-* map (client) and/or the inlined SSR subtree — never depend on the attr for them.
-* RawHtml is tagged so a rare attr-only mount can revive `Symbol.for("ilha.raw")`.
-*/
-function slotPropsForAttr(props, captureActions = false) {
-	if (props === void 0) return void 0;
-	let out;
-	for (const key of Object.keys(props)) {
-		if (key === "children") continue;
-		const value = props[key];
-		if (typeof value === "function") {
-			const id = captureActions && !isRawHtmlValue(value) ? actionManifestId(value) : void 0;
-			if (id) {
-				const a = actionBoundArgs(value);
-				(out ??= {})[key] = Array.isArray(a) ? {
-					__ilha: "action",
-					k: id,
-					a
-				} : {
-					__ilha: "action",
-					k: id
-				};
-			}
-			continue;
-		}
-		if (typeof value === "symbol") continue;
-		const encoded = encodeSlotPropValue(value);
-		if (encoded === void 0 && value !== void 0 && value !== null) continue;
-		(out ??= {})[key] = encoded;
-	}
-	return out;
-}
-const SLOT_RAW = Symbol.for("ilha.raw");
-function isRawHtmlValue(v) {
-	return !!(v && typeof v === "object" && SLOT_RAW in v);
-}
-function encodeSlotPropValue(value, seen) {
-	if (value == null) return value;
-	if (typeof value === "function" || typeof value === "symbol") return void 0;
-	if (typeof value !== "object") return value;
-	if (isRawHtmlValue(value)) return {
-		__ilha: "raw",
-		value: value.value
-	};
-	const visited = seen ?? /* @__PURE__ */ new WeakSet();
-	if (visited.has(value)) throw new TypeError("encodeSlotPropValue: circular reference in slot props");
-	visited.add(value);
-	if (Array.isArray(value)) return value.map((item) => encodeSlotPropValue(item, visited)).filter((item) => item !== void 0);
-	if (Object.getPrototypeOf(value) !== Object.prototype) return void 0;
-	const obj = value;
-	const encoded = {};
-	for (const key of Object.keys(obj)) {
-		const next = encodeSlotPropValue(obj[key], visited);
-		if (next !== void 0 || obj[key] === null) encoded[key] = next;
-	}
-	return encoded;
-}
-function makeRawHtml(value) {
-	return {
-		[SLOT_RAW]: true,
-		value
-	};
-}
-function reviveSlotPropValue(value) {
-	if (value == null || typeof value !== "object") return value;
-	if (Array.isArray(value)) return value.map(reviveSlotPropValue);
-	const obj = value;
-	if (obj.__ilha === "raw" && typeof obj.value === "string") return makeRawHtml(obj.value);
-	const out = {};
-	for (const key of Object.keys(obj)) out[key] = reviveSlotPropValue(obj[key]);
-	return out;
-}
-/** Revive attr-parsed props, restoring tagged `__ilha:raw` RawHtml values. */
-function reviveSlotProps(props) {
-	if (typeof props !== "object" || props === null || Array.isArray(props)) return {};
-	return reviveSlotPropValue(props);
-}
-/** Serialized form of slot props, matching the decoded `data-ilha-props` attr. */
-function serializeSlotProps(props) {
-	const safe = slotPropsForAttr(props);
-	return safe === void 0 ? "" : JSON.stringify(safe);
-}
-const MORPH_CONTROLLER_SLOT_SELECTOR = "[data-slot]";
-const MORPH_CONTROLLER_ATTRS = /* @__PURE__ */ new Set([
-	"data-checked",
-	"data-unchecked",
-	"data-indeterminate",
-	"aria-checked",
-	"data-open",
-	"data-closed",
-	"data-state",
-	"aria-expanded",
-	"aria-hidden",
-	"data-selected",
-	"data-panel-open"
-]);
-/**
-* Opt-in contract for controller-owned attributes: an element carrying
-* `data-morph-preserve="attr-a attr-b class"` keeps those attributes exactly
-* as they are in the live DOM — the morph neither overwrites nor removes them.
-* The Areia list above stays as a built-in default for `[data-slot]` elements.
-*/
-const MORPH_PRESERVE_ATTR = "data-morph-preserve";
-function shouldPreserveMorphAttr(el, name) {
-	if (name === MORPH_PRESERVE_ATTR) return el.hasAttribute(MORPH_PRESERVE_ATTR);
-	const custom = el.getAttribute(MORPH_PRESERVE_ATTR);
-	if (custom !== null) {
-		for (const token of custom.split(/\s+/)) if (token === name) return true;
-	}
-	return el.matches(MORPH_CONTROLLER_SLOT_SELECTOR) && MORPH_CONTROLLER_ATTRS.has(name);
-}
-function syncAttributes(from, to) {
-	for (const { name, value } of to.attributes) {
-		if (shouldPreserveMorphAttr(from, name)) continue;
-		if (from.getAttribute(name) !== value) from.setAttribute(name, value);
-	}
-	for (const { name } of Array.from(from.attributes)) {
-		if (shouldPreserveMorphAttr(from, name)) continue;
-		if (!to.hasAttribute(name)) from.removeAttribute(name);
-	}
-}
-/**
-* Morph identity key: explicit `data-key`, or the child-island slot id.
-* Slot hosts are matched by id like keyed list items so a mounted child
-* island's host element is reconciled IN PLACE on parent re-renders — never
-* detached and reinserted, which would blur a focused element inside it.
-*/
-function morphKeyOf(el) {
-	const k = el.getAttribute("data-key");
-	if (k !== null) return `k:${k}`;
-	const s = el.getAttribute(SLOT_ATTR);
-	return s === null ? null : `s:${s}`;
-}
-function morphChildren(fromParent, toParent) {
-	const toNodes = Array.from(toParent.childNodes);
-	let fromKeyed = null;
-	for (const child of fromParent.children) {
-		const k = morphKeyOf(child);
-		if (k !== null && !(fromKeyed ??= /* @__PURE__ */ new Map()).has(k)) fromKeyed.set(k, child);
-	}
-	let toKeys = null;
-	if (fromKeyed !== null) {
-		toKeys = /* @__PURE__ */ new Set();
-		for (const child of toParent.children) {
-			const k = morphKeyOf(child);
-			if (k !== null) toKeys.add(k);
-		}
-	}
-	for (let i = 0; i < toNodes.length; i++) {
-		const toNode = toNodes[i];
-		let fromNode = fromParent.childNodes[i];
-		if (fromKeyed !== null) {
-			const toKey = toNode.nodeType === 1 ? morphKeyOf(toNode) : null;
-			if (toKey !== null) {
-				const match = fromKeyed.get(toKey);
-				if (match) {
-					fromKeyed.delete(toKey);
-					if (match !== fromNode) {
-						fromParent.insertBefore(match, fromNode ?? null);
-						fromNode = match;
-					}
-				}
-			}
-			if (fromNode instanceof Element) {
-				const fromKey = morphKeyOf(fromNode);
-				if (fromKey !== null && fromKey !== toKey && toKeys.has(fromKey)) {
-					fromParent.insertBefore(toNode.cloneNode(true), fromNode);
-					continue;
-				}
-			}
-		}
-		if (!fromNode) {
-			fromParent.appendChild(toNode.cloneNode(true));
-			continue;
-		}
-		if (fromNode.nodeType !== toNode.nodeType) {
-			fromParent.replaceChild(toNode.cloneNode(true), fromNode);
-			continue;
-		}
-		if (fromNode.nodeType === 3 || fromNode.nodeType === 8) {
-			if (fromNode.nodeValue !== toNode.nodeValue) fromNode.nodeValue = toNode.nodeValue;
-			continue;
-		}
-		if (fromNode.nodeType === 1) {
-			const fromEl = fromNode;
-			const toEl = toNode;
-			if (fromEl.localName !== toEl.localName || fromEl.namespaceURI !== toEl.namespaceURI) {
-				fromParent.replaceChild(toEl.cloneNode(true), fromEl);
-				continue;
-			}
-			if (fromEl.hasAttribute(SLOT_ATTR) && !fromEl.isConnected) {
-				fromParent.replaceChild(toEl.cloneNode(true), fromEl);
-				continue;
-			}
-			{
-				const slotId = toEl.getAttribute(SLOT_ATTR);
-				if (slotId !== null && fromEl.getAttribute(SLOT_ATTR) === slotId) {
-					const props = toEl.getAttribute(PROPS_ATTR);
-					if (props !== null && fromEl.getAttribute(PROPS_ATTR) !== props) fromEl.setAttribute(PROPS_ATTR, props);
-					continue;
-				}
-			}
-			if (fromEl.localName === "input" && fromEl.type !== toEl.type) {
-				fromParent.replaceChild(toEl.cloneNode(true), fromEl);
-				continue;
-			}
-			if (fromEl.localName === "input") {
-				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 ?? "";
-				continue;
-			}
-			if (fromEl.localName === "select") {
-				const before = /* @__PURE__ */ new Map();
-				for (const o of fromEl.options) before.set(o, {
-					attr: o.hasAttribute("selected"),
-					live: o.selected
-				});
-				syncAttributes(fromEl, toEl);
-				morphChildren(fromEl, toEl);
-				const options = Array.from(fromEl.options);
-				if (options.some((o) => o.hasAttribute("selected") !== (before.get(o)?.attr ?? false))) for (const o of options) o.selected = o.hasAttribute("selected");
-				else for (const o of options) {
-					const prev = before.get(o);
-					if (prev && o.selected !== prev.live) o.selected = prev.live;
-				}
-				continue;
-			}
-			syncAttributes(fromEl, toEl);
-			if (fromEl.localName === "textarea") {
-				const newText = toEl.textContent ?? "";
-				if (fromEl.textContent !== newText) {
-					fromEl.textContent = newText;
-					fromEl.value = newText;
-				}
-			} else morphChildren(fromEl, toEl);
-		}
-	}
-	while (fromParent.childNodes.length > toNodes.length) fromParent.lastChild.remove();
-}
-/**
-* Invariant: the morph must never lose focus for an element that survives it.
-* Surviving slot hosts and keyed elements are patched in place, but a genuine
-* reorder still detaches-and-reinserts an ancestor of `document.activeElement`,
-* which blurs it in real engines — snapshot before, restore after.
-*/
-function snapshotFocusForMorph() {
-	if (typeof document === "undefined") return null;
-	const active = document.activeElement;
-	if (!(active instanceof HTMLElement) || active === document.body) return null;
-	let selection = null;
-	let range = null;
-	try {
-		if (active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement) selection = {
-			start: active.selectionStart,
-			end: active.selectionEnd,
-			dir: active.selectionDirection
-		};
-		else if (active.isContentEditable) {
-			const sel = window.getSelection();
-			if (sel && sel.rangeCount > 0) range = sel.getRangeAt(0).cloneRange();
-		}
-	} catch {}
-	return {
-		active,
-		selection,
-		range
-	};
-}
-function restoreFocusAfterMorph(snapshot) {
-	if (!snapshot) return;
-	const { active, selection, range } = snapshot;
-	if (!active.isConnected) return;
-	try {
-		if (document.activeElement !== active) active.focus({ preventScroll: true });
-		if (selection && selection.start !== null) {
-			const el = active;
-			if (el.selectionStart !== selection.start || el.selectionEnd !== selection.end) el.setSelectionRange(selection.start, selection.end, selection.dir ?? "none");
-		}
-		if (range && range.startContainer.isConnected) {
-			const sel = window.getSelection();
-			if (sel) {
-				const current = sel.rangeCount > 0 ? sel.getRangeAt(0) : null;
-				if (!(current !== null && current.startContainer === range.startContainer && current.startOffset === range.startOffset && current.endContainer === range.endContainer && current.endOffset === range.endOffset)) {
-					sel.removeAllRanges();
-					sel.addRange(range);
-				}
-			}
-		}
-	} catch {}
-}
-function morphInner(from, to) {
-	if (from.localName !== to.localName || from.namespaceURI !== to.namespaceURI) throw new Error("[ilha] morph: elements must match");
-	const focus = snapshotFocusForMorph();
-	morphChildren(from, to);
-	restoreFocusAfterMorph(focus);
-}
-function isStandardSchema(value) {
-	if (value == null || typeof value !== "object") return false;
-	const std = value["~standard"];
-	return std != null && typeof std.validate === "function" && std.version === 1;
-}
-function validateSchema(schema, value) {
-	const result = schema["~standard"].validate(value);
-	if (result instanceof Promise) throw new Error("[ilha] Async schemas are not supported.");
-	if (result.issues) throw new Error(`[ilha] Validation failed:\n${result.issues.map((i) => `  - ${i.message}`).join("\n")}`);
-	return result.value;
-}
-const ESC = {
-	"&": "&amp;",
-	"<": "&lt;",
-	">": "&gt;",
-	"\"": "&quot;",
-	"'": "&#39;"
-};
-function escapeHtml(value) {
-	return String(value).replace(/[&<>"']/g, (c) => ESC[c]);
-}
-const SAFE_CSS_PROP_RE = /^(-{2}[a-zA-Z][a-zA-Z0-9-]*|-?[a-zA-Z][a-zA-Z0-9-]*)$/;
-const URL_ATTRS = /* @__PURE__ */ new Set([
-	"href",
-	"src",
-	"srcset",
-	"imagesrcset",
-	"action",
-	"formaction",
-	"cite",
-	"data",
-	"poster"
-]);
-const SAFE_DATA_IMAGE_RE = /^data:image\/(png|jpe?g|gif|webp|avif)[;,]/i;
-const UNSAFE_SCHEME_RE = /^(?:javascript|vbscript):/i;
-const DATA_IMAGE_CONTEXTS = /* @__PURE__ */ new Set([
-	"img:src",
-	"source:srcset",
-	"link:imagesrcset"
-]);
-function normalizeUrl(value) {
-	return value.replace(/[\u0000-\u0020]/g, "");
-}
-function checkUrl(normalized, allowDataImage) {
-	if (UNSAFE_SCHEME_RE.test(normalized)) return false;
-	if (/^data:/i.test(normalized)) return allowDataImage && SAFE_DATA_IMAGE_RE.test(normalized);
-	return true;
-}
-/** Strict single-URL check — all data: URLs rejected. */
-function isSafeUrl(value) {
-	return checkUrl(normalizeUrl(value), false);
-}
-/** Element- and attribute-aware URL policy for rendered attributes.
-* `srcset`/`imagesrcset` validate each comma-separated candidate URL. */
-function isSafeUrlAttrValue(tagName, attrName, value) {
-	const attr = attrName.toLowerCase();
-	const allowDataImage = DATA_IMAGE_CONTEXTS.has(`${tagName.toLowerCase()}:${attr}`) && !attr.startsWith("srcset") && attr !== "imagesrcset";
-	if (/^(?:srcset|imagesrcset)$/i.test(attr)) return value.split(",").every((candidate) => {
-		const url = candidate.trim().split(/\s+/)[0] ?? "";
-		return url === "" || checkUrl(normalizeUrl(url), false);
-	});
-	return checkUrl(normalizeUrl(value), allowDataImage);
-}
-function isUrlAttributeName(name) {
-	const lower = name.toLowerCase();
-	return URL_ATTRS.has(lower) || /:(href|src|srcset|imagesrcset|action|formaction|cite|data|poster)$/.test(lower);
-}
-function isPlainObject(v) {
-	return v !== null && typeof v === "object" && Object.getPrototypeOf(v) === Object.prototype;
-}
-function serializeStyle(value) {
-	return Object.entries(value).map(([k, v]) => {
-		if (!SAFE_CSS_PROP_RE.test(k)) return "";
-		const prop = k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
-		const str = String(v);
-		if (/[<>{};]/.test(str) || /expression\(/i.test(str) || /javascript:/i.test(str)) return "";
-		return `${prop}:${str}`;
-	}).filter(Boolean).join(";");
-}
-function serializeScriptJson(value) {
-	return JSON.stringify(value).replace(/</g, "\\u003C");
-}
-function escapeStyleText(text) {
-	return text.replace(/</g, "\\3C ");
-}
-function dedentString(str) {
-	if (str.length === 0 || str[0] !== "\n") return str;
-	const lines = str.split("\n");
-	while (lines.length && lines[0].trim() === "") lines.shift();
-	while (lines.length && lines[lines.length - 1].trim() === "") lines.pop();
-	if (!lines.length) return "";
-	const indent = Math.min(...lines.filter((l) => l.trim() !== "").map((l) => l.match(/^(\s*)/)[1].length));
-	return lines.map((l) => l.slice(indent)).join("\n");
-}
-const RAW = Symbol.for("ilha.raw");
-const SIGNAL_ACCESSOR = Symbol.for("ilha.signalAccessor");
-const ISLAND = Symbol.for("ilha.island");
-const ISLAND_CALL = Symbol.for("ilha.islandCall");
-const ASTRO_RENDERER_GLOBAL = Symbol.for("ilha.astroRenderer");
-const ISLAND_SLOT_TAG = Symbol.for("ilha.islandSlotTag");
-const ISLAND_CLIENT_REF = Symbol.for("ilha.clientRef");
-/** @internal Sync re-render of an island from a state snapshot. Attached by
-* render(); used by server-frame endpoints to produce HTML for streamed
-* updates without a live mount. Not part of the public surface. */
-const ISLAND_RENDER_STATE = Symbol.for("ilha.renderState");
-/** @internal Async SSR render that records the event→action manifest into the
-* provided map. Used by emitIslandSlot so nested server islands ship their
-* interactive surface alongside their inlined HTML. */
-const ISLAND_SSR_MANIFEST = Symbol.for("ilha.ssrManifest");
-const SLOT_ATTR = "data-ilha-slot";
-const PROPS_ATTR = "data-ilha-props";
-const CLIENT_REF_ATTR = "data-ilha-client-ref";
-const STATE_ATTR = "data-ilha-state";
-function normalizeElseOutput(value) {
-	if (value == null || value === false) return value;
-	return Array.isArray(value) ? value : [value];
-}
-function createEachResult(items, mapFn) {
-	const mapped = items.length === 0 ? [] : items.map(mapFn);
-	const result = mapped;
-	Object.defineProperty(result, "else", {
-		value(fallback) {
-			if (items.length === 0) return normalizeElseOutput(typeof fallback === "function" ? fallback(items) : fallback);
-			return mapped;
-		},
-		enumerable: false
-	});
-	return result;
-}
-function createEachBuilder(items) {
-	return {
-		key(keyFn) {
-			return { as(mapFn) {
-				return createEachResult(items, (item, index) => mapFn(item, index, keyFn(item, index)));
-			} };
-		},
-		as(mapFn) {
-			return createEachResult(items, mapFn);
-		}
-	};
-}
-/**
-* Svelte-style `{#each}` helper for mapping collections to rendered output
-* with an optional empty fallback.
-*
-* @example — plain list (empty → [])
-* each(items).as((item) => html`<li>${item.name}</li>`)
-*
-* @example — keyed list feeding island.key(), with empty fallback
-* each(items)
-*   .key((item) => item.id)
-*   .as((item, _i, id) => Row.key(id)({ item }))
-*   .else(() => html`<EmptyState />`)
-*/
-function each(items) {
-	if (typeof items === "function") throw new TypeError("[ilha] each() expected an array but received a function. Call accessors first (each(state.items())) or pass a snapshot from a reactive render.");
-	return createEachBuilder(Array.isArray(items) ? items : []);
-}
-/** Marks SSR action stubs so event registration can recognize action
-* references without ever invoking them (executing a handler body during
-* render would run its side effects server-side). Symbol.for brands keep
-* this recognizable across duplicate ilha copies and external action
-* implementations (e.g. oxidejs) in the same realm. */
-const SSR_ACTION_STUB = Symbol.for("ilha.ssrActionStub");
-const ACTION_MANIFEST_ID = Symbol.for("ilha.actionManifestId");
-const ACTION_BOUND_ARGS = Symbol.for("ilha.actionBoundArgs");
-/** Serialized size ceiling for `.with()` payloads (JSON chars). */
-const MAX_BOUND_ARGS_CHARS = 8192;
-/** Manifest id for a brand-recognized action reference, else undefined.
-* Anything that isn't a branded action stub is rejected outright — event
-* handlers are never executed during SSR to discover what they call. */
-function actionManifestId(fn) {
-	if (typeof fn !== "function" || !(SSR_ACTION_STUB in fn)) return void 0;
-	return fn[ACTION_MANIFEST_ID];
-}
-/** Bound args recorded by `.with()` on an action reference, else undefined. */
-function actionBoundArgs(fn) {
-	if (typeof fn !== "function" || !(ACTION_BOUND_ARGS in fn)) return void 0;
-	const args = fn[ACTION_BOUND_ARGS];
-	return Array.isArray(args) ? args : void 0;
-}
-/** Attach `.with(...args)` to an action accessor. Returns an explicit,
-* serializable action REFERENCE — never a closure to inspect or probe.
-* Arguments are validated JSON-safe at bind time; the hydration manifest
-* stores `{ actionId, args }` directly and the client RPC path sends them
-* only after a real user event. On the client, calling the bound reference
-* invokes the accessor with the bound payload. */
-/** Keys that must never appear in a bound payload — they become dangerous
-* if an RPC handler or downstream library merges the object into another. */
-const UNSAFE_KEYS = /* @__PURE__ */ new Set([
-	"__proto__",
-	"constructor",
-	"prototype"
-]);
-/** Strict JSON-safety validator: accept, or throw — never transform.
-* Rejects undefined, functions, symbols, bigint, non-finite numbers,
-* Dates/custom prototypes/Map/Set, circular values, and unsafe keys so a
-* bound payload is byte-identical to what the author wrote. */
-function assertJsonSafe(value, seen = /* @__PURE__ */ new WeakSet()) {
-	if (value === null) return;
-	switch (typeof value) {
-		case "string":
-		case "boolean": return;
-		case "number":
-			if (Number.isFinite(value)) return;
-			throw new TypeError("with() rejects non-finite numbers.");
-		case "object": break;
-		default: throw new TypeError(`with() rejects ${typeof value} values.`);
-	}
-	if (seen.has(value)) throw new TypeError("with() rejects circular values.");
-	seen.add(value);
-	if (Array.isArray(value)) {
-		for (const item of value) assertJsonSafe(item, seen);
-		return;
-	}
-	if (Object.getPrototypeOf(value) !== Object.prototype) throw new TypeError("with() accepts plain objects only.");
-	for (const [key, child] of Object.entries(value)) {
-		if (UNSAFE_KEYS.has(key)) throw new TypeError(`with() rejects unsafe key "${key}".`);
-		assertJsonSafe(child, seen);
-	}
-}
-/** Deep-clone an already-validated JSON-safe value. */
-function cloneJsonSafe(value) {
-	return structuredClone(value);
-}
-function attachWith(accessor) {
-	Object.defineProperty(accessor, "with", {
-		enumerable: false,
-		value: (...args) => {
-			for (const arg of args) assertJsonSafe(arg);
-			const serialized = cloneJsonSafe(args);
-			if (JSON.stringify(serialized).length > MAX_BOUND_ARGS_CHARS) throw new RangeError(`with() payload exceeds ${MAX_BOUND_ARGS_CHARS} JSON characters.`);
-			const manifestId = actionManifestId(accessor);
-			const bound = (...runtimeArgs) => {
-				return accessor(serialized.length > 0 ? serialized.length === 1 ? serialized[0] : serialized : runtimeArgs.length === 1 ? runtimeArgs[0] : runtimeArgs);
-			};
-			const brand = bound;
-			brand[SSR_ACTION_STUB] = true;
-			brand[ACTION_MANIFEST_ID] = manifestId;
-			brand[ACTION_BOUND_ARGS] = serialized;
-			return bound;
-		}
-	});
-}
-setServerActionBinder(function bindExternalAction(fn, manifestId) {
-	const action = fn;
-	action[SSR_ACTION_STUB] = true;
-	action[ACTION_MANIFEST_ID] = manifestId;
-	attachWith(action);
-	return action;
-});
-const RENDER_CTX_STACK = Symbol.for("ilha.renderCtxStack");
-function renderCtxStack() {
-	const g = globalThis;
-	return g[RENDER_CTX_STACK] ??= [];
-}
-function pushRenderCtx(liveHost, asyncChildren, manifest) {
-	const ctx = {
-		slots: /* @__PURE__ */ new Map(),
-		positional: 0,
-		liveHost,
-		pending: asyncChildren ? /* @__PURE__ */ new Map() : void 0,
-		binds: [],
-		events: [],
-		manifest
-	};
-	renderCtxStack().push(ctx);
-	return ctx;
-}
-function popRenderCtx() {
-	renderCtxStack().pop();
-}
-function currentRenderCtx() {
-	const stack = renderCtxStack();
-	return stack[stack.length - 1];
-}
-function isIsland(v) {
-	return typeof v === "function" && ISLAND in v;
-}
-function isIslandCall(v) {
-	if (v == null || typeof v !== "object" && typeof v !== "function") return false;
-	if (ISLAND_CALL in v) return true;
-	return typeof v === "object" && "island" in v && isIsland(v.island);
-}
-function emitIslandSlot({ island, props, key }) {
-	const ctx = currentRenderCtx();
-	let id;
-	if (key === void 0) id = ctx ? `p:${ctx.positional++}` : "p:0";
-	else id = `k:${key}`;
-	if (ctx) ctx.slots.set(id, {
-		island,
-		props
-	});
-	const slotTag = getIslandSlotTag(island);
-	const clientRef = island[ISLAND_CLIENT_REF];
-	const attrProps = slotPropsForAttr(props, typeof clientRef === "string" && ctx?.manifest === true);
-	const propsAttr = (attrProps ? ` ${PROPS_ATTR}='${escapeHtml(JSON.stringify(attrProps))}'` : "") + (typeof clientRef === "string" ? ` ${CLIENT_REF_ATTR}="${escapeHtml(clientRef)}"` : "");
-	if (ctx?.liveHost) return wrapIslandSlotHtml({
-		tag: slotTag,
-		id,
-		propsAttr,
-		inner: ""
-	});
-	if (ctx?.pending) {
-		popRenderCtx();
-		try {
-			const manifest = /* @__PURE__ */ new Map();
-			const ssrWithManifest = island[ISLAND_SSR_MANIFEST];
-			const result = ssrWithManifest ? ssrWithManifest(props, manifest) : island.toStringAsync(props);
-			const prefix = () => serializeServerManifest(manifest);
-			if (result instanceof Promise) {
-				ctx.pending.set(id, result.then(String).then((html) => prefix() + html));
-				return wrapIslandSlotHtml({
-					tag: slotTag,
-					id,
-					propsAttr,
-					inner: asyncSlotMarker(id)
-				});
-			}
-			return wrapIslandSlotHtml({
-				tag: slotTag,
-				id,
-				propsAttr,
-				inner: prefix() + String(result)
-			});
-		} finally {
-			renderCtxStack().push(ctx);
-		}
-	}
-	const inner = island.toString(props);
-	return wrapIslandSlotHtml({
-		tag: slotTag,
-		id,
-		propsAttr,
-		inner
-	});
-}
-function asyncSlotMarker(id) {
-	return `<!--ilha-async:${escapeHtml(id)}-->`;
-}
-async function resolveAsyncChildren(html, pending) {
-	for (const [id, promise] of pending) {
-		const inner = await promise;
-		html = html.split(asyncSlotMarker(id)).join(inner);
-	}
-	return html;
-}
-function resolveSignalSetter(read, value) {
-	if (typeof value !== "function") return value;
-	const prevSub = setActiveSub(void 0);
-	try {
-		return value(read());
-	} finally {
-		setActiveSub(prevSub);
-	}
-}
-function markSignalAccessor(fn) {
-	fn[SIGNAL_ACCESSOR] = true;
-	const accessor = fn;
-	accessor.select = ((...args) => createSelectAccessor(accessor, args));
-	return accessor;
-}
-function isSignalAccessor(v) {
-	return typeof v === "function" && SIGNAL_ACCESSOR in v;
-}
-function getAtPath(obj, path) {
-	let cur = obj;
-	for (const seg of path) {
-		if (cur == null) return void 0;
-		cur = cur[seg];
-	}
-	return cur;
-}
-function setAtPath({ object, path, value }) {
-	const obj = object;
-	if (path.length === 0) return value;
-	const [head, ...rest] = path;
-	if (Array.isArray(obj)) {
-		const idx = head;
-		if (idx < 0 || idx >= obj.length) return obj;
-		const next = obj[idx];
-		const updated = rest.length === 0 ? value : setAtPath({
-			object: next,
-			path: rest,
-			value
-		});
-		if (Object.is(next, updated)) return obj;
-		const copy = obj.slice();
-		copy[idx] = updated;
-		return copy;
-	}
-	if (obj !== null && typeof obj === "object") {
-		const record = obj;
-		const key = String(head);
-		const next = record[key];
-		const updated = rest.length === 0 ? value : setAtPath({
-			object: next,
-			path: rest,
-			value
-		});
-		if (rest.length === 0) {
-			if (Object.is(next, value)) return obj;
-		} else if (Object.is(next, updated)) return obj;
-		return {
-			...record,
-			[key]: updated
-		};
-	}
-	return rest.length === 0 ? value : setAtPath({
-		object: void 0,
-		path: rest,
-		value
-	});
-}
-function toPathSegment(prop) {
-	if (typeof prop === "symbol") return null;
-	if (prop === "length") return null;
-	if (/^\d+$/.test(prop)) return Number(prop);
-	return prop;
-}
-function trackSelectPath(rootState, selector) {
-	const path = [];
-	const track = (value) => {
-		if (value === null || typeof value !== "object" && typeof value !== "function") return value;
-		return new Proxy(value, { get(target, prop, receiver) {
-			const seg = toPathSegment(prop);
-			if (seg != null) path.push(seg);
-			const next = Reflect.get(target, prop, receiver);
-			return seg != null && next !== null && typeof next === "object" ? track(next) : next;
+//#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;
 		} });
-	};
-	selector(track(rootState));
-	return path;
-}
-function createSelectAccessor(root, input) {
-	const selector = typeof input[0] === "function" ? input[0] : void 0;
-	let path;
-	if (selector) {
-		path = trackSelectPath(root(), selector);
-		const selected = selector(root());
-		const resolved = path.length === 0 ? root() : getAtPath(root(), path);
-		if (!Object.is(selected, resolved)) throw new Error("select(): selector must only traverse nested properties or array indexes — derived or transformed values are not supported.");
-	} else path = input;
-	const read = (from) => selector ? path.length === 0 ? selector(from) : getAtPath(from, path) : getAtPath(from, path);
-	return markSignalAccessor((...args) => {
-		if (args.length === 0) return read(root());
-		const previousRoot = root();
-		const previousSelected = read(previousRoot);
-		const value = resolveSignalSetter(() => previousSelected, args[0]);
-		const next = path.length === 0 && selector ? value : setAtPath({
-			object: previousRoot,
-			path,
-			value
-		});
-		if (!Object.is(previousRoot, next)) root(() => next);
-	});
-}
-function ilhaRaw(value) {
-	return {
-		[RAW]: true,
-		value
-	};
-}
-/**
-* Serialize a JSON-safe value into executable `<script>` content safely. `<`
-* is escaped as `\u003C`, so a value can never close the script block or open
-* the `<!--` escape hatch. Use it for script-element data:
-*
-* ```ts
-* html`<script>const d = ${json(payload)};<\/script>`
-* ```
-*
-* Like `raw()`, `json()` is for element *content* only — interpolating it into
-* an attribute is author error. It does not protect against values that are
-* not valid JSON (functions, symbols, undefined, cyclic objects are dropped
-* or throw, matching `JSON.stringify`).
-*/
-function json(value) {
-	return ilhaRaw(serializeScriptJson(value));
-}
-/**
-* Escape text for a `<style>` element body. `<` becomes the CSS hex escape
-* `\3C `, so the value can never close the style block or open the `<!--`
-* escape hatch while surviving CSS parsing:
-*
-* ```ts
-* html`<style>${css(cssSource)}</style>`
-* ```
-*
-* Like `raw()`, `css()` is for element *content* only — interpolating it into
-* an attribute is author error.
-*/
-function css(value) {
-	return ilhaRaw(escapeStyleText(value));
-}
-function interpolateValue(v) {
-	if (v == null || v === true || v === false) return "";
-	if (Array.isArray(v)) return v.map(interpolateValue).join("");
-	if (isRawHtml(v)) return v.value;
-	if (isIslandCall(v)) {
-		const call = typeof v === "function" ? v() : v;
-		return emitIslandSlot({
-			island: call.island,
-			props: call.props,
-			key: call.key
-		});
-	}
-	if (isIsland(v)) return emitIslandSlot({
-		island: v,
-		props: void 0,
-		key: void 0
-	});
-	if (isSignalAccessor(v)) return escapeHtml(v());
-	if (typeof v === "function") return escapeHtml(v());
-	return escapeHtml(v);
-}
-const BIND_VALID_KINDS = /* @__PURE__ */ new Set([
-	"value",
-	"checked",
-	"files",
-	"open",
-	"group",
-	"this"
-]);
-const BIND_PREFIX_RE = /\bbind:([a-zA-Z]+)\s*=\s*("|')?$/;
-const EVENT_PREFIX_RE = /(?:^|\s)on([a-zA-Z][a-zA-Z0-9-]*)(?::([a-zA-Z][a-zA-Z0-9-]*))?\s*=\s*("|')?$/;
-const NATIVE_EVENT_MODIFIERS = /* @__PURE__ */ new Set([
-	"abortable",
-	"once",
-	"capture",
-	"passive"
-]);
-const FULL_VALUE_ATTR_RE = /(?:^|\s)([a-zA-Z_:][a-zA-Z0-9:._-]*)\s*=\s*("|')?$/;
-const UNQUOTED_HAZARD_RE = /[\s=]|`/;
-function resolveTemplateValue(v) {
-	if (isSignalAccessor(v)) return v();
-	if (typeof v === "function") return v();
-	return v;
-}
-function openTagName(source, index) {
-	const open = source.lastIndexOf("<", index);
-	if (open === -1) return "element";
-	return (source.slice(open).match(/^<\s*([a-zA-Z][a-zA-Z0-9:._-]*)/)?.[1] ?? "element").toLowerCase();
-}
-function isEventAttributePosition(source, index) {
-	let open = -1;
-	let quote = null;
-	for (let i = 0; i < index; i++) {
-		const char = source[i];
-		if (open === -1) {
-			if (char === "<") open = i;
-			continue;
-		}
-		if (quote) {
-			if (char === quote) quote = null;
-		} else if (char === "\"" || char === "'") quote = char;
-		else if (char === ">") open = -1;
-	}
-	if (open === -1 || quote !== null) return false;
-	return !/^\s*[!/?]/.test(source.slice(open + 1, index));
-}
-function findTagCloseIndex(chunk, initialQuote) {
-	let quote = initialQuote;
-	for (let i = 0; i < chunk.length; i++) {
-		const ch = chunk[i];
-		if (quote !== null) {
-			if (ch === quote) quote = null;
-		} else if (ch === "\"" || ch === "'") quote = ch;
-		else if (ch === ">") return {
-			index: i,
-			quote
-		};
-	}
-	return {
-		index: -1,
-		quote
-	};
-}
-function extractElementStaticValue(prefix) {
-	const lastOpen = prefix.lastIndexOf("<");
-	if (lastOpen === -1) return null;
-	const tagPrefix = prefix.slice(lastOpen);
-	if (tagPrefix.includes(">")) return null;
-	const m = tagPrefix.match(/\bvalue\s*=\s*("([^"]*)"|'([^']*)'|([^\s>]+))/);
-	if (!m) return null;
-	return m[2] ?? m[3] ?? m[4] ?? null;
-}
-function emitBindSSR({ kind, index, accessor, prefixForStaticPeek }) {
-	const spec = `${kind}:${index}`;
-	let v;
-	try {
-		v = accessor();
-	} catch {
-		v = void 0;
-	}
-	switch (kind) {
-		case "value": return [` value="${escapeHtml(v ?? "")}"`, spec];
-		case "checked": return [v ? ` checked` : ``, spec];
-		case "open": return [v ? ` open` : ``, spec];
-		case "files": return [``, spec];
-		case "this": return [``, spec];
-		case "group": {
-			const optionValue = extractElementStaticValue(prefixForStaticPeek);
-			if (optionValue == null) return [``, spec];
-			return [(Array.isArray(v) ? v.map(String).includes(optionValue) : v != null && String(v) === optionValue) ? ` checked` : ``, spec];
-		}
-	}
-}
-function ilhaHtml(strings, ...values) {
-	let result = "";
-	let stripLeadingQuote = null;
-	let pendingBindSpecs = "";
-	let pendingEventSpecs = "";
-	let pendingQuote = null;
-	const ctx = currentRenderCtx();
-	for (let i = 0; i < strings.length; i++) {
-		let chunk = strings[i];
-		if (stripLeadingQuote !== null) {
-			if (chunk.startsWith(stripLeadingQuote)) chunk = chunk.slice(1);
-			stripLeadingQuote = null;
-		}
-		if (pendingBindSpecs !== "" || pendingEventSpecs !== "") {
-			const { index: gtIdx, quote } = findTagCloseIndex(chunk, pendingQuote);
-			if (gtIdx === -1) pendingQuote = quote;
-			else {
-				const head = chunk.slice(0, gtIdx).replace(/\s*\/\s*$/, "");
-				const bindAttr = pendingBindSpecs ? ` data-ilha-bind="${pendingBindSpecs}"` : "";
-				const eventAttr = pendingEventSpecs ? ` data-ilha-on="${pendingEventSpecs}"` : "";
-				chunk = head + bindAttr + eventAttr + ">" + chunk.slice(gtIdx + 1);
-				pendingBindSpecs = "";
-				pendingEventSpecs = "";
-				pendingQuote = null;
-			}
-		}
-		if (i >= values.length) {
-			result += chunk;
-			continue;
-		}
-		const value = values[i];
-		const eventMatch = chunk.match(EVENT_PREFIX_RE);
-		const eventMatchStart = eventMatch ? chunk.length - eventMatch[0].length : -1;
-		if (!eventMatch && typeof value === "function") {
-			const ambiguous = chunk.match(/(?:^|\s)on([a-zA-Z][a-zA-Z0-9-]*)(?::[a-zA-Z][a-zA-Z0-9-]*)?\s*=\s*(?:(?:"[^"]*)|(?:'[^']*)|(?:[^\s"'=<>`]+))$/);
-			const start = ambiguous ? chunk.length - ambiguous[0].length : -1;
-			if (ambiguous && isEventAttributePosition(result + chunk, result.length + start)) throw new Error(`[ilha] on${ambiguous[1]} handler must occupy the entire attribute value. Write on${ambiguous[1]}=\${handler}.`);
-		}
-		const eventAttributeFragment = eventMatch !== null && chunk.slice(0, eventMatchStart).trim() === "";
-		if (eventMatch && (eventAttributeFragment || isEventAttributePosition(result + chunk, result.length + eventMatchStart))) {
-			const eventName = eventMatch[1].toLowerCase();
-			const rawModifier = eventMatch[2]?.toLowerCase();
-			const modifier = rawModifier !== void 0 && NATIVE_EVENT_MODIFIERS.has(rawModifier) ? rawModifier : void 0;
-			const openQuote = eventMatch[3] ?? null;
-			const nextChunk = strings[i + 1] ?? "";
-			if (!(openQuote ? nextChunk.startsWith(openQuote) : /^(?:\s|\/?>|$)/.test(nextChunk))) throw new Error(`[ilha] on${eventName} handler must occupy the entire attribute value. Write on${eventName}=\${handler}.`);
-			const cleanPrefix = chunk.slice(0, eventMatchStart).replace(/\s+$/, "");
-			result += cleanPrefix;
-			typeof value === "function" && SSR_ACTION_STUB in value;
-			if (ctx && typeof value === "function") {
-				const index = ctx.events.length;
-				if (rawModifier && !modifier) {} else {
-					ctx.events.push({
-						type: eventName,
-						handler: value,
-						modifier
-					});
-					pendingEventSpecs += (pendingEventSpecs ? "," : "") + `${eventName}:${index}`;
-				}
-			}
-			if (openQuote) stripLeadingQuote = openQuote;
-			continue;
-		}
-		const m = chunk.match(BIND_PREFIX_RE);
-		if (m && isSignalAccessor(value)) {
-			const name = m[1];
-			const openQuote = m[2] ?? null;
-			if (!BIND_VALID_KINDS.has(name)) {
-				result += chunk + interpolateValue(value);
-				continue;
-			}
-			if (!ctx) {
-				const stripped = chunk.slice(0, chunk.length - m[0].length);
-				const quote = openQuote ?? "\"";
-				result += stripped + name + "=" + quote + interpolateValue(value) + quote;
-				if (openQuote) stripLeadingQuote = openQuote;
-				continue;
-			}
-			const matchStart = chunk.length - m[0].length;
-			const cleanPrefix = chunk.slice(0, matchStart).replace(/\s+$/, "");
-			const index = ctx.binds.length;
-			ctx.binds.push({
-				kind: name,
-				accessor: value
-			});
-			const [valueAttrs, spec] = emitBindSSR({
-				kind: name,
-				index,
-				accessor: value,
-				prefixForStaticPeek: cleanPrefix
-			});
-			result += cleanPrefix + valueAttrs;
-			pendingBindSpecs += (pendingBindSpecs ? "," : "") + spec;
-			if (openQuote) stripLeadingQuote = openQuote;
-			continue;
-		}
-		const attrMatch = chunk.match(FULL_VALUE_ATTR_RE);
-		if (attrMatch && isEventAttributePosition(result + chunk, result.length + attrMatch.index)) {
-			const attrName = attrMatch[1];
-			const openQuote = attrMatch[2] ?? null;
-			if (openQuote) stripLeadingQuote = openQuote;
-			const cleanPrefix = chunk.slice(0, attrMatch.index).replace(/\s+$/, "");
-			if (attrName.length > 2 && /^on/i.test(attrName)) {
-				result += cleanPrefix;
-				continue;
-			}
-			if (attrName.toLowerCase() === "srcdoc") {
-				result += cleanPrefix;
-				continue;
-			}
-			if (isIsland(value) || isIslandCall(value)) {
-				stripLeadingQuote = null;
-				result += chunk + interpolateValue(value);
-				continue;
-			}
-			if (isUrlAttributeName(attrName)) {
-				if (isRawHtml(value)) {
-					result += cleanPrefix + ` ${attrName}="${value.value}"`;
-					continue;
-				}
-				const resolved = resolveTemplateValue(value);
-				if (resolved == null || resolved === false) {
-					result += cleanPrefix;
-					continue;
-				}
-				const url = String(resolved);
-				if (!isSafeUrlAttrValue(openTagName(result + chunk, result.length + attrMatch.index), attrName, url)) {
-					result += cleanPrefix;
-					continue;
-				}
-				const quotedUrl = openQuote !== null || UNQUOTED_HAZARD_RE.test(url);
-				result += cleanPrefix + ` ${attrName}=` + (quotedUrl ? `"${escapeHtml(url)}"` : escapeHtml(url));
-				continue;
-			}
-			if (attrName.toLowerCase() === "style") {
-				if (!isRawHtml(value)) {
-					const resolved = resolveTemplateValue(value);
-					if (isPlainObject(resolved)) {
-						result += cleanPrefix + ` style="${escapeHtml(serializeStyle(resolved))}"`;
-						continue;
-					}
-				}
-			}
-			if (isRawHtml(value)) {
-				stripLeadingQuote = null;
-				result += chunk + interpolateValue(value);
-				continue;
-			}
-			const resolved = resolveTemplateValue(value);
-			if (resolved == null || resolved === false) {
-				result += cleanPrefix;
-				continue;
-			}
-			if (resolved === true) {
-				result += cleanPrefix + ` ${attrName}`;
-				continue;
-			}
-			const generic = String(resolved);
-			if (openQuote !== null || UNQUOTED_HAZARD_RE.test(generic)) result += cleanPrefix + ` ${attrName}="${escapeHtml(generic)}"`;
-			else result += cleanPrefix + ` ${attrName}=${escapeHtml(generic)}`;
-			continue;
-		}
-		result += chunk + interpolateValue(value);
-	}
-	if (pendingBindSpecs !== "") result += ` data-ilha-bind="${pendingBindSpecs}"`;
-	if (pendingEventSpecs !== "") result += ` data-ilha-on="${pendingEventSpecs}"`;
-	return {
-		[RAW]: true,
-		value: dedentString(result)
-	};
-}
-function isRawHtml(v) {
-	if (typeof v !== "object" || v === null) return false;
-	return RAW in v && typeof v.value === "string";
-}
-function unwrapHtml(v) {
-	return isRawHtml(v) ? v.value : v;
-}
-const contextRegistry = /* @__PURE__ */ new Map();
-function ilhaContextFn(key, initial) {
-	if (contextRegistry.has(key)) return contextRegistry.get(key);
-	const s = signal(initial);
-	const accessor = markSignalAccessor((...args) => {
-		if (args.length === 0) return s();
-		s(resolveSignalSetter(() => s(), args[0]));
-	});
-	contextRegistry.set(key, accessor);
-	return accessor;
-}
-const ilhaContext = Object.assign(ilhaContextFn, {
-	/** Remove a context signal from the registry. Returns true if it existed. */
-	delete(key) {
-		return contextRegistry.delete(key);
-	},
-	/** Remove all context signals from the registry (e.g. between tests). */
-	clear() {
-		contextRegistry.clear();
-	}
-});
-/**
-* Create a free-standing reactive signal that lives outside any island.
-* Internal: used by state()'s slot-drift fallback. The public way to create
-* free-standing shared state is `context(key, initial)`.
-*/
-function ilhaSignal(initial) {
-	if (currentFrame()?.creating && __DEV__);
-	const s = signal(initial);
-	return markSignalAccessor((...args) => {
-		if (args.length === 0) return s();
-		s(resolveSignalSetter(() => s(), args[0]));
-	});
-}
-/**
-* Run a free-standing reactive effect outside any island. `fn` runs once
-* immediately and again whenever a signal it read changes. It may return a
-* cleanup function, invoked before each re-run and on stop. Signal writes
-* inside the effect are batched. Returns a stop function that disposes the
-* effect and runs the final cleanup.
-*
-* ```ts
-* const stop = effect(() => {
-*   document.title = `${cart.count()} items`;
-* });
-* ```
-*/
-function ilhaEffect(fn) {
-	let cleanup;
-	const runCleanup = () => {
-		if (typeof cleanup === "function") {
-			try {
-				cleanup();
-			} catch (err) {
-				console.error(err);
-			}
-			cleanup = void 0;
-		}
-	};
-	const stop = effect$1(() => {
-		runCleanup();
-		startBatch();
-		try {
-			cleanup = fn();
-		} catch (err) {
-			console.error(err);
-		} finally {
-			endBatch();
-		}
-	});
-	return () => {
-		stop();
-		runCleanup();
-	};
-}
-/**
-* Run `fn` with reactive tracking suspended. Reading signals inside `fn`
-* returns their current value without subscribing the surrounding scope.
-* Use this in effects/deriveds when you want to peek at state without
-* causing a re-run on its changes.
-*/
-function untrack(fn) {
-	const prev = setActiveSub(void 0);
-	try {
-		return fn();
-	} finally {
-		setActiveSub(prev);
-	}
-}
-/**
-* Run `fn` as an atomic batch — multiple signal writes inside the callback
-* produce a single propagation pass, so dependents (effects, deriveds,
-* island re-renders) see the final state and run once instead of once per
-* write. Returns whatever `fn` returns.
-*
-* Note: `.on()` handlers and `.effect()` runs are batched implicitly, so
-* you only need this when triggering multiple writes from outside an
-* island (e.g. from a top-level event listener or async callback).
-*/
-function batch(fn) {
-	startBatch();
-	try {
-		return fn();
-	} finally {
-		endBatch();
-	}
-}
-/**
-* Keep a standalone signal in sync with persistent storage:
-*
-* 1. On call, reads `key` and writes the stored value into the signal.
-* 2. Subscribes to the signal and writes its value back on every change.
-* 3. Optionally mirrors writes from other tabs (`storage` events).
-*
-* No-op on the server (returns an inert unsubscribe). Call the returned
-* unsubscribe to stop syncing.
-*
-* ```ts
-* const cart = signal([] as string[]);
-* persist(cart, "cart");
-* ```
-*/
-function persist(accessor, key, options = {}) {
-	if (typeof window === "undefined") return () => {};
-	const storage = options.storage ?? window.localStorage;
-	const serialize = options.serialize ?? JSON.stringify;
-	const deserialize = options.deserialize ?? ((raw) => {
-		try {
-			return JSON.parse(raw);
-		} catch {
-			return null;
-		}
-	});
-	const label = `[ilha] persist("${key}")`;
-	const applyRaw = (raw) => {
-		if (raw == null) return;
-		try {
-			const value = deserialize(raw);
-			if (value !== null) {
-				const prevSub = setActiveSub(void 0);
-				try {
-					accessor(() => value);
-				} finally {
-					setActiveSub(prevSub);
-				}
-			}
-		} catch (err) {
-			console.error(`${label}: failed to restore`, err);
-		}
-	};
-	try {
-		applyRaw(storage.getItem(key));
-	} catch (err) {
-		console.error(`${label}: failed to read storage`, err);
-	}
-	const stopEffect = ilhaEffect(() => {
-		try {
-			storage.setItem(key, serialize(accessor()));
-		} catch (err) {
-			console.error(`${label}: failed to write storage`, err);
-		}
-	});
-	let onStorage = null;
-	if (options.crossTab !== false && storage === window.localStorage) {
-		onStorage = (e) => {
-			if (e.key !== key) return;
-			applyRaw(e.newValue);
-		};
-		window.addEventListener("storage", onStorage);
-	}
-	return () => {
-		stopEffect();
-		if (onStorage) window.removeEventListener("storage", onStorage);
-	};
-}
-function createDerivedAccessor(read, write) {
-	const accessor = markSignalAccessor((...args) => {
-		if (args.length > 0) {
-			if (write) write(args[0]);
-			return;
-		}
-		return read().value;
-	});
-	return new Proxy(accessor, { get(target, prop, receiver) {
-		if (prop === "loading" || prop === "value" || prop === "error") return read()[prop];
-		return Reflect.get(target, prop, receiver);
-	} });
-}
-function defaultDerivedAccessor() {
-	return createDerivedAccessor(() => ({
-		loading: false,
-		value: void 0,
-		error: 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 BIND_SENTINEL_ATTR = "data-ilha-bind";
-const EVENT_SENTINEL_ATTR = "data-ilha-on";
-function parseBindSentinel(value) {
-	const out = [];
-	for (const part of value.split(",")) {
-		const [kind, idx] = part.split(":");
-		if (!kind || !idx) continue;
-		const i = Number(idx);
-		if (!Number.isInteger(i) || i < 0) continue;
-		out.push({
-			kind,
-			index: i
-		});
-	}
-	return out;
-}
-function resolveBindOps(el, kind) {
-	const input = el;
-	switch (kind) {
-		case "value": return {
-			event: el.tagName === "SELECT" ? "change" : "input",
-			read: (el) => el.value,
-			write: (el, v) => el.value = v == null ? "" : String(v)
-		};
-		case "checked": return {
-			event: "change",
-			read: (el) => el.checked,
-			write: (el, v) => el.checked = Boolean(v)
-		};
-		case "files": return {
-			event: "change",
-			read: (el) => el.files,
-			write: () => {}
-		};
-		case "open": return {
-			event: "toggle",
-			read: (el) => el.open,
-			write: (el, v) => el.open = Boolean(v)
-		};
-		case "this": return {
-			event: null,
-			read: () => void 0,
-			write: () => {}
-		};
-		case "group": {
-			const isCheckbox = input.type === "checkbox";
-			return {
-				event: "change",
-				read: (el) => {
-					const i = el;
-					if (isCheckbox) return {
-						__ilhaGroup: true,
-						value: i.value,
-						checked: i.checked
-					};
-					return i.checked ? i.value : void 0;
-				},
-				write: (el, v) => {
-					const i = el;
-					if (isCheckbox) i.checked = (Array.isArray(v) ? v.map(String) : []).includes(i.value);
-					else i.checked = v != null && String(v) === i.value;
-				}
-			};
-		}
-	}
-}
-function templateElementBelongsToHost(host, candidate) {
-	if (candidate === host) return true;
-	let current = candidate;
-	while (current && current !== host) {
-		if (current.hasAttribute(SLOT_ATTR) || current.hasAttribute("data-ilha")) return false;
-		current = current.parentElement;
-	}
-	return current === host;
-}
-function applyJsxEvents({ host, records, reportError, unmountSignal, onceFired }) {
-	if (records.length === 0) return () => {};
-	const cleanups = [];
-	const elements = [];
-	if (host.hasAttribute(EVENT_SENTINEL_ATTR)) elements.push(host);
-	elements.push(...Array.from(host.querySelectorAll(`[${EVENT_SENTINEL_ATTR}]`)).filter((element) => templateElementBelongsToHost(host, element)));
-	for (const el of elements) {
-		const sentinel = el.getAttribute(EVENT_SENTINEL_ATTR) ?? "";
-		for (const part of sentinel.split(",")) {
-			const separator = part.lastIndexOf(":");
-			if (separator < 1) continue;
-			const type = part.slice(0, separator);
-			const index = Number(part.slice(separator + 1));
-			if (!Number.isInteger(index) || index < 0) continue;
-			const record = records[index];
-			if (!record || record.type !== type) continue;
-			if (record.modifier === "once" && onceFired.get(el)?.has(type)) continue;
-			const listenerController = new AbortController();
-			let invocationController;
-			const options = {
-				once: record.modifier === "once",
-				capture: record.modifier === "capture",
-				passive: record.modifier === "passive"
-			};
-			const reportHandlerError = (error) => {
-				if (error?.name !== "AbortError") reportError(error);
-			};
-			const listener = (event) => {
-				if (record.modifier === "once") {
-					let fired = onceFired.get(el);
-					if (!fired) onceFired.set(el, fired = /* @__PURE__ */ new Set());
-					fired.add(type);
-				}
-				if (record.modifier === "abortable") {
-					invocationController?.abort();
-					invocationController = new AbortController();
-				}
-				const signal = invocationController ? AbortSignal.any([listenerController.signal, invocationController.signal]) : listenerController.signal;
-				let result;
-				startBatch();
-				try {
-					result = record.handler(event, { signal });
-				} catch (error) {
-					reportHandlerError(error);
-					return;
-				} finally {
-					endBatch();
-				}
-				if (result != null && typeof result.then === "function") Promise.resolve(result).catch(reportHandlerError);
-			};
-			const stop = () => {
-				listenerController.abort();
-				invocationController?.abort();
-				el.removeEventListener(type, listener, options);
-			};
-			el.addEventListener(type, listener, options);
-			unmountSignal.addEventListener("abort", stop, { once: true });
-			cleanups.push(() => {
-				unmountSignal.removeEventListener("abort", stop);
-				stop();
-			});
-		}
-	}
-	return () => cleanups.forEach((cleanup) => cleanup());
-}
-function applyTemplateBindings(host, binds, phase = "all") {
-	if (binds.length === 0) return () => {};
-	const cleanups = [];
-	const elements = [];
-	if (host.hasAttribute(BIND_SENTINEL_ATTR)) elements.push(host);
-	for (const el of host.querySelectorAll(`[${BIND_SENTINEL_ATTR}]`)) if (templateElementBelongsToHost(host, el)) elements.push(el);
-	for (const el of elements) {
-		const specs = parseBindSentinel(el.getAttribute(BIND_SENTINEL_ATTR));
-		for (const spec of specs) {
-			const record = binds[spec.index];
-			if (!record) continue;
-			if (record.kind !== spec.kind) continue;
-			const { event, read, write } = resolveBindOps(el, spec.kind);
-			const accessor = record.accessor;
-			if (spec.kind === "this") {
-				if (phase !== "listen") {
-					accessor(el);
-					cleanups.push(() => accessor(null));
-				}
-				continue;
-			}
-			if (phase !== "listen") try {
-				write(el, accessor());
-			} catch (err) {}
-			if (phase === "reflect" || event === null) continue;
-			const listener = () => {
-				const raw = read(el);
-				if (spec.kind === "group") {
-					const groupRead = raw;
-					if (groupRead === void 0) return;
-					if (typeof groupRead === "object" && groupRead.__ilhaGroup) {
-						const currentArr = accessor();
-						const arr = Array.isArray(currentArr) ? [...currentArr] : [];
-						const idx = arr.findIndex((x) => String(x) === groupRead.value);
-						if (groupRead.checked && idx === -1) {
-							let coercedVal = groupRead.value;
-							const templateVal = Array.isArray(currentArr) && currentArr.length > 0 ? currentArr[0] : void 0;
-							if (templateVal !== void 0) {
-								if (typeof templateVal === "number") {
-									const n = Number(coercedVal);
-									coercedVal = Number.isNaN(n) ? coercedVal : n;
-								} else if (typeof templateVal === "boolean") coercedVal = Boolean(coercedVal);
-							}
-							arr.push(coercedVal);
-						} else if (!groupRead.checked && idx !== -1) arr.splice(idx, 1);
-						accessor(arr);
-						return;
-					}
-					const currentVal = accessor();
-					let coerced = groupRead;
-					if (typeof currentVal === "number" && typeof groupRead === "string") {
-						const n = Number(groupRead);
-						coerced = Number.isNaN(n) ? 0 : n;
-					} else if (typeof currentVal === "boolean") coerced = Boolean(groupRead);
-					accessor(coerced);
-					return;
-				}
-				const currentVal = accessor();
-				let value = raw;
-				if (typeof currentVal === "number" && typeof raw === "string") {
-					const n = Number(raw);
-					value = Number.isNaN(n) ? 0 : n;
-				} else if (typeof currentVal === "boolean") value = Boolean(raw);
-				accessor(value);
-			};
-			el.addEventListener(event, listener);
-			cleanups.push(() => el.removeEventListener(event, listener));
-		}
-	}
-	return () => cleanups.forEach((c) => c());
-}
-const globalErrorHandlers = /* @__PURE__ */ new Set();
-function reportToGlobal(error, source) {
-	if (globalErrorHandlers.size === 0) return false;
-	for (const handler of globalErrorHandlers) try {
-		handler(error, source);
-	} catch (handlerErr) {
-		console.error(handlerErr);
-	}
-	return true;
-}
-/**
-* Register a global error handler invoked when any island reports an error
-* and has no local onError() handler. Returns an unsubscribe function.
-*/
-function onUncaughtError(fn) {
-	globalErrorHandlers.add(fn);
-	return () => {
-		globalErrorHandlers.delete(fn);
-	};
-}
-const FRAME_STACK = Symbol.for("ilha.primitiveFrameStack");
-function frameStack() {
-	const g = globalThis;
-	return g[FRAME_STACK] ??= [];
-}
-function currentFrame() {
-	const stack = frameStack();
-	return stack[stack.length - 1];
-}
-function withFrame(frame, fn) {
-	frameStack().push(frame);
-	try {
-		return fn();
-	} finally {
-		frameStack().pop();
-	}
-}
-function freshFrame(options) {
-	return {
-		slots: [],
-		cursor: 0,
-		creating: true,
-		ssr: options?.ssr ?? false,
-		instance: options?.instance ?? null,
-		stateIndex: 0,
-		derivedIndex: 0,
-		actionIndex: 0,
-		pendingDerived: options?.ssr ? [] : null,
-		actionManifest: options?.ssr ? /* @__PURE__ */ new Map() : null
-	};
-}
-const PRIMITIVE_NAMES = {
-	state: "state",
-	derived: "derived",
-	action: "action",
-	effect: "effect",
-	once: "effect.once",
-	error: "onError"
-};
-/** Reserve the next slot for a primitive call. Throws outside an island
-* render; warns in dev on hook count/kind drift during re-renders. */
-function acquireSlot(kind) {
-	const frame = currentFrame();
-	if (!frame) throw new Error(`[ilha] ${PRIMITIVE_NAMES[kind]}() called outside an island render. Primitives are only valid while an island component (or a plain component owned by one) is rendering.`);
-	const index = frame.cursor++;
-	if (frame.creating) return void 0;
-	const existing = frame.slots[index];
-	return existing && existing.kind === kind ? existing : void 0;
-}
-/**
-* Declare island-local reactive state at this call position. The initializer
-* applies only when the instance is created — later renders reuse the same
-* underlying signal, so prop-driven initializers never reset user state.
-*
-* A function argument is treated as a lazy initializer:
-*   const count = state(() => expensiveInitialValue());
-* To store a function VALUE, return it from the updater wrapper on write:
-*   setCallback(() => nextCallback);
-*/
-function state(init) {
-	const frame = currentFrame();
-	const existing = acquireSlot("state");
-	if (existing) return existing.acc;
-	const f = frame;
-	if (!f.creating) return ilhaSignal(void 0);
-	const index = f.stateIndex++;
-	const snap = f.ssr ? void 0 : f.instance?.stateSnapshot?.s?.[index];
-	const initial = snap === void 0 ? typeof init === "function" ? init() : init : snap;
-	const s = signal(initial);
-	const acc = markSignalAccessor((...args) => {
-		if (args.length === 0) return s();
-		const next = resolveSignalSetter(() => s(), args[0]);
-		s(next);
-	});
-	f.slots[f.cursor - 1] = {
-		kind: "state",
-		acc
-	};
-	return acc;
-}
-/** True for async iterables (incl. async generators). */
-function isAsyncIterable(value) {
-	return value !== null && typeof value[Symbol.asyncIterator] === "function";
-}
-/**
-* Declare derived state at this call position: synchronous computations,
-* Promises, or async generators. Reads track their dependencies; async work
-* races latest-run-wins and aborts stale runs through `ctx.signal`.
-*/
-function derived(fn) {
-	const frame = currentFrame();
-	const existing = acquireSlot("derived");
-	const f = frame;
-	if (existing) {
-		const slot = existing;
-		slot.fn = fn;
-		if (f.ssr && !f.creating && !slot.ssrAsync) {
-			const ac = new AbortController();
-			const prevSub = setActiveSub(void 0);
-			try {
-				const result = slot.fn({ signal: ac.signal });
-				if (!(result instanceof Promise) && !isAsyncIterable(result)) slot.env({
-					loading: false,
-					value: result,
-					error: void 0
-				});
-			} catch (err) {
-				slot.env({
-					loading: false,
-					value: void 0,
-					error: err instanceof Error ? err : new Error(String(err))
-				});
-			} finally {
-				setActiveSub(prevSub);
-			}
-		}
-		return slot.acc;
-	}
-	if (!f.creating) return defaultDerivedAccessor();
-	const index = f.derivedIndex++;
-	const env = signal({
-		loading: false,
-		value: void 0,
-		error: void 0
-	});
-	let fromSnapshot = false;
-	if (!f.ssr) {
-		const snap = f.instance?.stateSnapshot?.d?.[index];
-		if (snap) {
-			env({ ...snap });
-			fromSnapshot = true;
-		}
-	}
-	const accessor = createDerivedAccessor(() => env(), (value) => {
-		const prevSub = setActiveSub(void 0);
-		try {
-			env({
-				loading: false,
-				value,
-				error: void 0
-			});
-		} finally {
-			setActiveSub(prevSub);
-		}
-	});
-	const slot = {
-		kind: "derived",
-		env,
-		acc: accessor,
-		fn,
-		ssrAsync: false,
-		fromSnapshot
-	};
-	if (f.ssr) {
-		const ac = new AbortController();
-		const prevSub = setActiveSub(void 0);
-		let result;
-		let threw = false;
-		let syncError;
-		try {
-			result = slot.fn({ signal: ac.signal });
-		} catch (err) {
-			threw = true;
-			syncError = err;
-		} finally {
-			setActiveSub(prevSub);
-		}
-		let pull = null;
-		if (threw) env({
-			loading: false,
-			value: void 0,
-			error: syncError instanceof Error ? syncError : new Error(String(syncError))
-		});
-		else if (result instanceof Promise) {
-			env({
-				loading: true,
-				value: void 0,
-				error: void 0
-			});
-			pull = result.then((value) => env({
-				loading: false,
-				value,
-				error: void 0
-			}), (err) => env({
-				loading: false,
-				value: void 0,
-				error: err instanceof Error ? err : new Error(String(err))
-			}));
-			result.catch(() => {});
-		} else if (isAsyncIterable(result)) {
-			env({
-				loading: true,
-				value: void 0,
-				error: void 0
-			});
-			const iterable = result;
-			pull = (async () => {
-				const it = iterable[Symbol.asyncIterator]();
-				try {
-					const first = await it.next();
-					env({
-						loading: false,
-						value: first.done ? void 0 : first.value,
-						error: void 0
-					});
-				} finally {
-					await it.return?.(void 0);
-				}
-			})();
-		} else env({
-			loading: false,
-			value: result,
-			error: void 0
-		});
-		slot.ssrAsync = pull !== null;
-		if (pull) f.pendingDerived.push({
-			index,
-			promise: pull.catch(() => {})
-		});
-	}
-	f.slots[f.cursor - 1] = slot;
-	return accessor;
-}
-/**
-* Declare a reactive operation at this call position. Use plain functions
-* for ordinary operations; action() adds pending/data/error tracking,
-* concurrent-invocation bookkeeping, and lifecycle cancellation.
-*/
-function action(fn) {
-	const frame = currentFrame();
-	const existing = acquireSlot("action");
-	const f = frame;
-	if (existing) return existing.acc;
-	if (!f.creating) {
-		const noop = (() => {});
-		Object.defineProperties(noop, {
-			pending: { get: () => false },
-			data: { get: () => void 0 },
-			error: { get: () => void 0 }
-		});
-		attachWith(noop);
-		return noop;
-	}
-	const manifestId = `a${f.actionIndex++}`;
-	if (f.ssr) {
-		const invoke = (..._callArgs) => {};
-		invoke[SSR_ACTION_STUB] = true;
-		invoke[ACTION_MANIFEST_ID] = manifestId;
-		Object.defineProperties(invoke, {
-			pending: {
-				get: () => false,
-				enumerable: true
-			},
-			data: {
-				get: () => void 0,
-				enumerable: true
-			},
-			error: {
-				get: () => void 0,
-				enumerable: true
-			}
-		});
-		f.actionManifest.set(invoke, manifestId);
-		f.slots[f.cursor - 1] = {
-			kind: "action",
-			acc: invoke,
-			fn
-		};
-		const ssrAccessor = invoke;
-		attachWith(ssrAccessor);
-		return ssrAccessor;
-	}
-	const instance = f.instance;
-	const envelope = signal({
-		pending: 0,
-		data: void 0,
-		error: void 0
-	});
-	const readEnvelope = () => untrack(() => envelope());
-	let latestRun = 0;
-	const invoke = (payload) => {
-		if (currentRenderCtx()) return;
-		if (instance.disposed) return;
-		const run = ++latestRun;
-		const runSignal = instance.unmountController.signal;
-		let result;
-		let isAsync = false;
-		startBatch();
-		try {
-			result = slot.fn(payload, { signal: runSignal });
-			isAsync = result != null && typeof result.then === "function";
-			const current = readEnvelope();
-			envelope(isAsync ? {
-				pending: current.pending + 1,
-				data: current.data,
-				error: void 0
-			} : {
-				pending: current.pending,
-				data: result,
-				error: void 0
-			});
-		} catch (error) {
-			const normalized = error instanceof Error ? error : new Error(String(error));
-			envelope({
-				pending: readEnvelope().pending,
-				data: void 0,
-				error: normalized
-			});
-			instance.reportError(normalized, "action");
+
+//#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;
-		} finally {
-			endBatch();
-		}
-		if (!isAsync) return;
-		Promise.resolve(result).then((data) => {
-			if (instance.disposed || runSignal.aborted || run !== latestRun) return;
-			const value = readEnvelope();
-			envelope({
-				pending: value.pending,
-				data,
-				error: void 0
-			});
-		}).catch((error) => {
-			if (instance.disposed || runSignal.aborted || error?.name === "AbortError") return;
-			const normalized = error instanceof Error ? error : new Error(String(error));
-			if (run === latestRun) {
-				const value = readEnvelope();
-				envelope({
-					pending: value.pending,
-					data: void 0,
-					error: normalized
-				});
-			}
-			instance.reportError(normalized, "action");
-		}).finally(() => {
-			if (instance.disposed) return;
-			const value = readEnvelope();
-			envelope({
-				...value,
-				pending: Math.max(0, value.pending - 1)
-			});
-		});
-	};
-	const slot = {
-		kind: "action",
-		acc: invoke,
-		fn
-	};
-	Object.defineProperties(invoke, {
-		pending: {
-			get: () => envelope().pending > 0,
-			enumerable: true
-		},
-		data: {
-			get: () => envelope().data,
-			enumerable: true
-		},
-		error: {
-			get: () => envelope().error,
-			enumerable: true
 		}
-	});
-	f.slots[f.cursor - 1] = slot;
-	instance.actionIds.set(slot.acc, manifestId);
-	const clientAccessor = invoke;
-	clientAccessor[ACTION_MANIFEST_ID] = manifestId;
-	attachWith(clientAccessor);
-	return clientAccessor;
-}
-/**
-* Reactive side effect. Inside an island render, registers an ordered effect
-* slot that tracks signals read in the body, reruns on change, cleans up
-* before rerun and on unmount, and is client-only. Outside an island render,
-* behaves as the standalone reactive effect and returns a stop function.
-*
-* @returns Inside an island render, `void` (an effect slot is registered and
-* cleaned up automatically). At module scope, a stop function that disposes
-* the effect and runs its final cleanup. The union return type is deliberate:
-* the same call shape cannot be discriminated at the call site.
-*/
-const effect = Object.assign((fn) => {
-	const frame = currentFrame();
-	if (!frame) {
-		let cleanup;
-		let controller = null;
-		const runCleanup = () => {
-			if (typeof cleanup === "function") {
-				try {
-					cleanup();
-				} catch (err) {
-					console.error(err);
-				}
-				cleanup = void 0;
-			}
-		};
-		const stop = ilhaEffect(() => {
-			runCleanup();
-			if (controller) controller.abort();
-			controller = new AbortController();
-			startBatch();
-			try {
-				cleanup = fn({ signal: controller.signal });
-			} catch (err) {
-				console.error(err);
-			} finally {
-				endBatch();
-			}
-		});
-		return () => {
-			stop();
-			runCleanup();
-			controller?.abort();
-		};
-	}
-	const existing = acquireSlot("effect");
-	if (existing) {
-		existing.fn = fn;
-		return;
-	}
-	if (!frame.creating) return;
-	frame.slots[frame.cursor - 1] = {
-		kind: "effect",
-		fn
-	};
-}, { once(fn) {
-	if (acquireSlot("once")) return;
-	const f = currentFrame();
-	if (!f) throw new Error("[ilha] effect.once() called outside an island render. It registers per-instance setup and is only valid while an island component is rendering.");
-	if (!f.creating) return;
-	f.slots[f.cursor - 1] = {
-		kind: "once",
-		fn
-	};
-} });
-/**
-* Register an error handler slot for this island. Handlers run in
-* declaration order; state, derived values, actions, and props should be
-* accessed through lexical closure rather than the context object.
-*/
-function onError(fn) {
-	if (!currentFrame()) throw new Error("[ilha] onError() called outside an island render. Register it while an island component is rendering.");
-	const existing = acquireSlot("error");
-	if (existing) {
-		existing.fn = fn;
-		return;
-	}
-	const f = currentFrame();
-	if (!f || !f.creating) return;
-	f.slots[f.cursor - 1] = {
-		kind: "error",
-		fn
-	};
-}
-function parseStateSnapshot(raw) {
-	const parsed = safeParseSnapshot(raw, STATE_ATTR);
-	if (parsed === void 0) return void 0;
-	const rec = parsed;
-	if (rec["v"] !== 2) return;
-	const out = { skipOnce: rec["_skipOnMount"] === true };
-	if (Array.isArray(rec["s"])) {
-		stripUnsafeKeys(rec["s"]);
-		out.s = rec["s"];
-	}
-	if (Array.isArray(rec["d"])) {
-		stripUnsafeKeys(rec["d"]);
-		out.d = rec["d"].map((entry) => {
-			const e = entry ?? {};
-			const errorValue = e.error;
-			return {
-				loading: e.loading === true,
-				value: e.value,
-				error: errorValue == null ? void 0 : errorValue instanceof Error ? errorValue : new Error(String(errorValue))
-			};
-		});
-	}
-	return out;
+		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)));
+	}));
 }
-const ilha = ((...args) => {
-	let schema = null;
-	let component;
-	let options;
-	const first = args[0];
-	const second = args[1];
-	if (isStandardSchema(first)) {
-		schema = first;
-		component = second;
-		options = args[2];
-	} else {
-		component = first;
-		options = second;
-	}
-	if (typeof component !== "function") throw new Error("[ilha] ilha() requires a component function.");
-	const configuredSlotTag = options?.as === void 0 ? "div" : assertValidSlotTagName(options.as);
-	function resolveInput(props) {
-		const merged = { ...props };
-		if (!schema) return merged;
-		return validateSchema(schema, merged);
-	}
-	function renderWithCtx({ render, liveHost, asyncChildren, manifest }) {
-		const ctx = pushRenderCtx(liveHost, asyncChildren, manifest);
+
+//#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 {
-			const html = unwrapHtml(render());
-			const slots = ctx.slots;
-			const binds = ctx.binds;
-			const events = ctx.events;
-			if (ctx.pending && ctx.pending.size > 0) {
-				const pending = ctx.pending;
-				return (async () => {
-					return {
-						html: await resolveAsyncChildren(html, pending),
-						slots,
-						binds,
-						events
-					};
-				})();
-			}
-			return {
-				html,
-				slots,
-				binds,
-				events
-			};
+			return yield* Deferred.await(deferred);
 		} finally {
-			popRenderCtx();
-		}
-	}
-	/** Invoke the component inside the given frame + render context. */
-	function runInFrame(frame, props) {
-		return () => withFrame(frame, () => component(props));
-	}
-	function recordEventsManifest(eventsOut, events, frame) {
-		if (!eventsOut || events.length === 0) return;
-		events.forEach((record, index) => {
-			const id = frame.actionManifest?.get(record.handler) ?? actionManifestId(record.handler);
-			if (!id) return;
-			const args = actionBoundArgs(record.handler);
-			eventsOut.set(`${record.type}:${index}`, Array.isArray(args) ? {
-				k: id,
-				a: args
-			} : id);
-		});
-	}
-	function renderToString(props, sync = false, eventsOut, forceAsyncChildren = false) {
-		const input = resolveInput(props);
-		const frame = freshFrame({ ssr: true });
-		const first = forceAsyncChildren ? renderWithCtx({
-			render: runInFrame(frame, input),
-			asyncChildren: true,
-			manifest: eventsOut !== void 0
-		}) : renderWithCtx({
-			render: runInFrame(frame, input),
-			manifest: eventsOut !== void 0
-		});
-		const finish = (firstHtml) => firstHtml.html;
-		const needsAsync = forceAsyncChildren || (frame.pendingDerived?.length ?? 0) > 0;
-		if (first instanceof Promise) return first.then((out) => {
-			recordEventsManifest(eventsOut, out.events, frame);
-			return needsAsync ? awaitPending(out) : out.html;
-		});
-		recordEventsManifest(eventsOut, first.events, frame);
-		if (!needsAsync || sync) {
-			if (sync && (frame.pendingDerived?.length ?? 0) > 0 && __DEV__);
-			return finish(first);
-		}
-		return awaitPending(first);
-		function awaitPending(out) {
-			const pendings = frame.pendingDerived ?? [];
-			if (pendings.length === 0) return Promise.resolve(out.html);
-			return Promise.all(pendings.map((p) => p.promise)).then(() => {
-				frame.creating = false;
-				frame.cursor = 0;
-				const second = forceAsyncChildren ? renderWithCtx({
-					render: runInFrame(frame, input),
-					asyncChildren: true,
-					manifest: eventsOut !== void 0
-				}) : renderWithCtx({
-					render: runInFrame(frame, input),
-					manifest: eventsOut !== void 0
-				});
-				const done = (o) => {
-					recordEventsManifest(eventsOut, o.events, frame);
-					return o.html;
-				};
-				return second instanceof Promise ? second.then(done) : done(second);
-			});
-		}
-	}
-	function mountIsland(host, props) {
-		return mountIslandInternal(host, props).unmount;
-	}
-	function mountIslandInternal(host, props) {
-		if (props === void 0) {
-			const rawProps = host.getAttribute(PROPS_ATTR);
-			if (rawProps) {
-				const parsed = safeParseSnapshot(rawProps, PROPS_ATTR);
-				if (parsed !== void 0) props = reviveSlotProps(parsed);
-			}
-		}
-		const inputSignal = signal(resolveInput(props));
-		const derivedPropsVersion = signal(0);
-		const input = new Proxy({}, {
-			get(_t, key) {
-				return inputSignal()[key];
-			},
-			has(_t, key) {
-				return key in inputSignal();
-			},
-			ownKeys() {
-				const prevSub = setActiveSub(void 0);
-				try {
-					return Reflect.ownKeys(inputSignal());
-				} finally {
-					setActiveSub(prevSub);
-				}
-			},
-			getOwnPropertyDescriptor(_t, key) {
-				const prevSub = setActiveSub(void 0);
-				try {
-					return Reflect.getOwnPropertyDescriptor(inputSignal(), key);
-				} finally {
-					setActiveSub(prevSub);
-				}
-			}
-		});
-		const snapshotRaw = host.getAttribute(STATE_ATTR);
-		const snapshot = snapshotRaw ? parseStateSnapshot(snapshotRaw) : void 0;
-		const hydrated = snapshot != null;
-		const shouldSkipOnce = snapshot?.skipOnce === true;
-		const cleanups = [];
-		const unmountController = new AbortController();
-		cleanups.push(() => unmountController.abort());
-		const errorSlots = [];
-		const reportError = (err, source) => {
-			const error = err instanceof Error ? err : new Error(String(err));
-			if (errorSlots.length === 0) {
-				if (!reportToGlobal(error, source)) console.error(error);
-				return;
-			}
-			for (const slot of errorSlots) try {
-				slot.fn({
-					error,
-					source,
-					host
-				});
-			} catch (handlerErr) {
-				console.error(handlerErr);
-			}
-		};
-		const instance = {
-			host,
-			inputSignal,
-			input,
-			unmountController,
-			cleanups,
-			reportError,
-			actionIds: /* @__PURE__ */ new Map(),
-			stateSnapshot: snapshot ? {
-				s: snapshot.s,
-				d: snapshot.d
-			} : void 0,
-			hydrated,
-			disposed: false,
-			frame: null
-		};
-		cleanups.push(() => {
-			instance.disposed = true;
-		});
-		const frame = freshFrame({
-			ssr: false,
-			instance
-		});
-		instance.frame = frame;
-		const mountedSlots = /* @__PURE__ */ new Map();
-		function teardownMountedSlot(id, entry) {
-			mountedSlots.delete(id);
-			entry.el.remove();
-			entry.unmount();
-		}
-		function slotBelongsToHost(candidate) {
-			let el = candidate.parentElement;
-			while (el && el !== host) {
-				if (el.hasAttribute(SLOT_ATTR) || el.hasAttribute("data-ilha")) return false;
-				el = el.parentElement;
-			}
-			return el === host;
-		}
-		function buildSlotIndex() {
-			const index = /* @__PURE__ */ new Map();
-			for (const candidate of host.querySelectorAll(`[${SLOT_ATTR}]`)) {
-				const id = candidate.getAttribute(SLOT_ATTR);
-				if (id === null || index.has(id)) continue;
-				if (slotBelongsToHost(candidate)) index.set(id, candidate);
-			}
-			return index;
-		}
-		function pushUpdatedProps(nextSlots) {
-			for (const [id, entry] of mountedSlots) {
-				const next = nextSlots.get(id);
-				if (next) entry.updateProps(next.props);
-			}
-		}
-		function mountSlots(slotMap) {
-			for (const [id, entry] of mountedSlots) if (!slotMap.has(id)) teardownMountedSlot(id, entry);
-			for (const [id, entry] of mountedSlots) {
-				const next = slotMap.get(id);
-				if (next && next.island !== entry.island) teardownMountedSlot(id, entry);
-			}
-			let slotIndex = null;
-			for (const [id, { island: childIsland, props: childProps }] of slotMap) {
-				const existing = mountedSlots.get(id);
-				if (existing) {
-					existing.updateProps(childProps);
-					continue;
-				}
-				if (slotIndex === null) slotIndex = buildSlotIndex();
-				const slotEl = slotIndex.get(id) ?? null;
-				if (!slotEl) continue;
-				let slotProps = childProps;
-				if (slotProps === void 0) {
-					const rawProps = slotEl.getAttribute(PROPS_ATTR) ?? slotEl.getAttribute("data-props");
-					if (rawProps) {
-						const parsed = safeParseSnapshot(rawProps, `props on [${SLOT_ATTR}="${id}"]`);
-						if (parsed !== void 0) slotProps = reviveSlotProps(parsed);
-					}
-				}
-				const prevSub = setActiveSub(void 0);
-				let handle;
-				try {
-					const internal = childIsland[ISLAND_MOUNT_INTERNAL];
-					handle = internal ? internal(slotEl, slotProps) : {
-						unmount: childIsland.mount(slotEl, slotProps),
-						updateProps: () => {}
-					};
-				} finally {
-					setActiveSub(prevSub);
-				}
-				mountedSlots.set(id, {
-					el: slotEl,
-					island: childIsland,
-					...handle
-				});
-			}
+			closeFiber(child);
 		}
-		const nativeOnceFired = /* @__PURE__ */ new WeakMap();
-		let stopJsxEvents = () => {};
-		let stopBindings = () => {};
-		/** Register derived scopes before the render effect so source updates
-		* settle derived envelopes before a render can consume them. */
-		function startDerivedScopes() {
-			for (const slot of frame.slots) if (slot.kind === "derived") startDerivedScope(slot);
-		}
-		/** Register side-effecting scopes after the render effect so prop-change
-		* renders refresh their closures before those scopes execute. */
-		function startEffectScopes() {
-			for (const slot of frame.slots) if (slot.kind === "effect") startEffectScope(slot);
-			else if (slot.kind === "once") startOnceScope(slot);
-			else if (slot.kind === "error") errorSlots.push(slot);
-		}
-		function startDerivedScope(slot) {
-			let ac = new AbortController();
-			let skipFirst = slot.fromSnapshot;
-			const stopScope = effect$1(() => {
-				ac.abort();
-				ac = new AbortController();
-				const currentAc = ac;
-				derivedPropsVersion();
-				let result;
-				try {
-					result = slot.fn({ signal: currentAc.signal });
-				} catch (err) {
-					if (skipFirst) {
-						skipFirst = false;
-						return;
-					}
-					writeEnvelope(currentAc, {
-						loading: false,
-						value: void 0,
-						error: err instanceof Error ? err : new Error(String(err))
-					});
-					return;
-				}
-				if (skipFirst) {
-					skipFirst = false;
-					if (result instanceof Promise) result.catch(() => {});
-					return;
-				}
-				if (!(result instanceof Promise)) {
-					if (isAsyncIterable(result)) {
-						const iterable = result;
-						writeEnvelope(currentAc, {
-							loading: true,
-							value: readEnv().value,
-							error: void 0
-						});
-						(async () => {
-							try {
-								for await (const value of iterable) if (writeEnvelope(currentAc, {
-									loading: false,
-									value,
-									error: void 0
-								})) break;
-							} catch (err) {
-								writeEnvelope(currentAc, {
-									loading: false,
-									value: void 0,
-									error: err instanceof Error ? err : new Error(String(err))
-								});
-							}
-						})();
-						return;
-					}
-					writeEnvelope(currentAc, {
-						loading: false,
-						value: result,
-						error: void 0
-					});
-					return;
-				}
-				writeEnvelope(currentAc, {
-					loading: true,
-					value: readEnv().value,
-					error: void 0
-				});
-				result.then((value) => {
-					writeEnvelope(currentAc, {
-						loading: false,
-						value,
-						error: void 0
-					});
-				}).catch((err) => {
-					writeEnvelope(currentAc, {
-						loading: false,
-						value: void 0,
-						error: err instanceof Error ? err : new Error(String(err))
-					});
-				});
-			});
-			cleanups.push(() => {
-				stopScope();
-				ac.abort();
-			});
-			function readEnv() {
-				const prevSub = setActiveSub(void 0);
-				try {
-					return slot.env();
-				} finally {
-					setActiveSub(prevSub);
-				}
-			}
-			function writeEnvelope(ac, patch) {
-				if (ac.signal.aborted) return true;
-				const prevSub = setActiveSub(void 0);
-				try {
-					slot.env(patch);
-				} finally {
-					setActiveSub(prevSub);
-				}
-				return false;
-			}
-		}
-		function startEffectScope(slot) {
-			let userCleanup;
-			let runController = null;
-			const stopScope = effect$1(() => {
-				if (userCleanup) {
-					try {
-						userCleanup();
-					} catch (err) {
-						reportError(err, "effect");
-					}
-					userCleanup = void 0;
-				}
-				if (runController) runController.abort();
-				runController = new AbortController();
-				const runSignal = AbortSignal.any([unmountController.signal, runController.signal]);
-				inputSignal();
-				startBatch();
-				try {
-					userCleanup = slot.fn({ signal: runSignal });
-				} catch (err) {
-					reportError(err, "effect");
-				} finally {
-					endBatch();
-				}
-			});
-			cleanups.push(() => {
-				stopScope();
-				if (userCleanup) try {
-					userCleanup();
-				} catch (err) {
-					reportError(err, "effect");
-				}
-				if (runController) runController.abort();
-			});
-		}
-		function startOnceScope(slot) {
-			if (shouldSkipOnce) return;
-			const prevSub = setActiveSub(void 0);
-			let userCleanup;
-			try {
-				userCleanup = slot.fn({
-					host,
-					hydrated,
-					signal: unmountController.signal
-				});
-			} catch (err) {
-				reportError(err, "once");
-			} finally {
-				setActiveSub(prevSub);
-			}
-			if (userCleanup) {
-				const teardown = userCleanup;
-				cleanups.push(() => {
-					try {
-						teardown();
-					} catch (err) {
-						reportError(err, "once");
-					}
-				});
-			}
-		}
-		const preserveSSRDom = hydrated && host.childNodes.length > 0;
-		const initial = renderWithCtx({
-			render: runInFrame(frame, input),
-			liveHost: preserveSSRDom ? host : void 0
-		});
-		if (!preserveSSRDom) host.innerHTML = initial.html;
-		const stopInitialBindingReflection = applyTemplateBindings(host, initial.binds, "reflect");
-		let stopInitialBindingListeners = null;
-		stopBindings = stopInitialBindingReflection;
-		cleanups.push(() => stopBindings());
-		stopJsxEvents = applyJsxEvents({
-			host,
-			records: initial.events,
-			reportError: (error) => reportError(error, "event"),
-			unmountSignal: unmountController.signal,
-			onceFired: nativeOnceFired
-		});
-		cleanups.push(() => stopJsxEvents());
-		mountSlots(initial.slots);
-		cleanups.push(() => mountedSlots.forEach((entry) => entry.unmount()));
-		stopInitialBindingListeners = applyTemplateBindings(host, initial.binds, "listen");
-		stopBindings = () => {
-			stopInitialBindingListeners();
-			stopInitialBindingReflection();
-		};
-		let initialized = false;
-		const initialRenderedHtml = initial.html;
-		let lastRendered = null;
-		let renderEpoch = 0;
-		const renderReactive = () => {
-			const epoch = ++renderEpoch;
-			frame.creating = false;
-			frame.cursor = 0;
-			const { html: rendered, slots: newSlotMap, binds: newBinds, events: newEvents } = renderWithCtx({
-				render: runInFrame(frame, input),
-				liveHost: host
-			});
-			stopJsxEvents();
-			stopJsxEvents = applyJsxEvents({
-				host,
-				records: newEvents,
-				reportError: (error) => reportError(error, "event"),
-				unmountSignal: unmountController.signal,
-				onceFired: nativeOnceFired
-			});
-			if (!initialized) {
-				initialized = true;
-				if (preserveSSRDom) {
-					pushUpdatedProps(newSlotMap);
-					if (rendered === initialRenderedHtml) {
-						lastRendered = rendered;
-						return;
-					}
-				}
-				if (rendered === initialRenderedHtml) {
-					lastRendered = rendered;
-					return;
-				}
-				if (mountedSlots.size > 0 && mountedSlots.size === newSlotMap.size && [...newSlotMap.keys()].every((id) => mountedSlots.has(id)) && isStableInlineSlotMount({
-					initialHtml: initialRenderedHtml,
-					renderedHtml: rendered,
-					slotIds: newSlotMap.keys()
-				})) {
-					pushUpdatedProps(newSlotMap);
-					return;
-				}
-			}
-			if (rendered === lastRendered && mountedSlots.size === newSlotMap.size && [...newSlotMap].every(([id, next]) => mountedSlots.get(id)?.island === next.island)) {
-				pushUpdatedProps(newSlotMap);
-				return;
-			}
-			stopBindings();
-			stopJsxEvents();
-			const prevMountedCount = mountedSlots.size;
-			for (const [id, entry] of mountedSlots) if (!newSlotMap.has(id)) teardownMountedSlot(id, entry);
-			for (const [id, entry] of mountedSlots) {
-				const next = newSlotMap.get(id);
-				if (next && next.island !== entry.island) teardownMountedSlot(id, entry);
-			}
-			const applyMorph = () => {
-				if (epoch !== renderEpoch) return;
-				if (newSlotMap.size < prevMountedCount) {
-					let divergeFrom = Infinity;
-					for (const [id, entry] of mountedSlots) {
-						if (!id.startsWith("p:")) continue;
-						const next = newSlotMap.get(id);
-						if (!next) continue;
-						const index = Number(id.slice(2));
-						if (Number.isNaN(index) || index >= divergeFrom) continue;
-						if (serializeSlotProps(next.props) !== (entry.el.getAttribute(PROPS_ATTR) ?? "")) divergeFrom = index;
-					}
-					for (const [id, entry] of mountedSlots) {
-						if (!newSlotMap.has(id)) continue;
-						if (!entry.el.isConnected) continue;
-						if (id.startsWith("p:") && Number(id.slice(2)) >= divergeFrom) teardownMountedSlot(id, entry);
-					}
-				}
-				const tpl = document.createElement("template");
-				const morphRootTag = host.tagName.toLowerCase();
-				tpl.innerHTML = `<${morphRootTag}>${rendered}</${morphRootTag}>`;
-				morphInner(host, tpl.content.firstElementChild);
-				lastRendered = rendered;
-				let rehomeIndex = null;
-				for (const [id, entry] of mountedSlots) {
-					if (!newSlotMap.has(id) || entry.el.isConnected) continue;
-					rehomeIndex ??= buildSlotIndex();
-					const stub = rehomeIndex.get(id);
-					if (stub && stub !== entry.el) stub.replaceWith(entry.el);
-				}
-				stopBindings = applyTemplateBindings(host, newBinds);
-				stopJsxEvents = applyJsxEvents({
-					host,
-					records: newEvents,
-					reportError: (error) => reportError(error, "event"),
-					unmountSignal: unmountController.signal,
-					onceFired: nativeOnceFired
-				});
-				mountSlots(newSlotMap);
-			};
-			applyMorph();
-		};
-		let stopRender = effect$1(renderReactive);
-		startDerivedScopes();
-		stopRender();
-		stopRender = effect$1(renderReactive);
-		startEffectScopes();
-		let tornDown = false;
-		const unmount = () => {
-			if (tornDown) return;
-			tornDown = true;
-			instance.disposed = true;
-			unmountController.abort();
-			ISLAND_MOUNT_HANDLES.delete(host);
-			stopRender();
-			for (const [, entry] of mountedSlots) entry.unmount();
-			for (const c of cleanups) c();
-		};
-		const updateProps = (nextProps) => {
-			if (tornDown) return;
-			const next = resolveInput(nextProps);
-			if (shallowEqualInput(inputSignal(), next)) return;
-			inputSignal(next);
-			derivedPropsVersion(derivedPropsVersion() + 1);
-		};
-		const handle = {
-			unmount,
-			updateProps
-		};
-		ISLAND_MOUNT_HANDLES.set(host, handle);
-		return handle;
-	}
-	const island = ((props) => ({
-		[ISLAND_CALL]: true,
-		island,
-		props,
-		key: void 0
 	}));
-	island.toString = (props) => renderToString(props, true);
-	island.toStringAsync = (props) => Promise.resolve(renderToString(props, false));
-	island.mount = (host, props) => mountIsland(host, props);
-	island[ISLAND_MOUNT_INTERNAL] = (host, props) => mountIslandInternal(host, props);
-	island[ISLAND_SLOT_TAG] = configuredSlotTag;
-	island[ISLAND_RENDER_STATE] = async (props) => {
-		const manifest = /* @__PURE__ */ new Map();
-		const html = await renderToString(props ?? void 0, false, manifest, true);
-		return serializeServerManifest(manifest) + html;
-	};
-	island[ISLAND_SSR_MANIFEST] = (props, eventsOut) => renderToString(props, false, eventsOut, true);
-	island.key = (key) => {
-		if (typeof key !== "string" || key.trim().length === 0) throw new Error("island.key() requires a non-empty string.");
-		if (key.includes(":")) throw new Error(`island.key() key cannot contain the slot separator ":" (got "${key}").`);
-		const keyed = ((props) => ({
-			[ISLAND_CALL]: true,
-			island,
-			props,
-			key
-		}));
-		keyed[ISLAND_CALL] = true;
-		return keyed;
-	};
-	island[ISLAND] = true;
-	const astroRendererName = globalThis[ASTRO_RENDERER_GLOBAL];
-	if (typeof astroRendererName === "string") island[Symbol.for("astro:renderer")] = astroRendererName;
-	island.define = (tagName, options) => {
-		if (typeof customElements === "undefined" || typeof HTMLElement === "undefined") {
-			`${tagName}`;
-			return;
-		}
-		const CE_RESERVED = /* @__PURE__ */ new Set([
-			"annotation-xml",
-			"color-profile",
-			"font-face",
-			"font-face-src",
-			"font-face-uri",
-			"font-face-format",
-			"font-face-name",
-			"missing-glyph"
-		]);
-		if (typeof tagName !== "string" || !/^[a-z][a-z0-9._-]*-[a-z0-9._-]*$/.test(tagName) || CE_RESERVED.has(tagName)) {
-			`${tagName}`;
-			return;
-		}
-		if (customElements.get(tagName)) {
-			`${tagName}`;
-			return;
-		}
-		const observe = options?.observe ?? [];
-		class IlhaIslandElement extends HTMLElement {
-			static observedAttributes = observe;
-			_handle = null;
-			_props;
-			_unmounting = false;
-			_reconnect = false;
-			get props() {
-				return this._props;
-			}
-			set props(p) {
-				this._props = p;
-				if (this._handle && !this._unmounting) this._handle.updateProps(this._mergedProps());
-			}
-			_mergedProps() {
-				const attrProps = {};
-				let hasAttrs = false;
-				for (const name of observe) {
-					const v = this.getAttribute(name);
-					if (v !== null) {
-						attrProps[name] = v;
-						hasAttrs = true;
-					}
-				}
-				if (!hasAttrs && this._props === void 0) return void 0;
-				return {
-					...attrProps,
-					...this._props
-				};
-			}
-			connectedCallback() {
-				if (this._unmounting) {
-					this._reconnect = true;
-					return;
-				}
-				if (this._handle) return;
-				this._handle = mountIslandInternal(this, this._mergedProps());
-			}
-			disconnectedCallback() {
-				if (!this._handle || this._unmounting) return;
-				this._unmounting = true;
-				this._reconnect = false;
-				Promise.resolve(this._handle.unmount()).finally(() => {
-					this._handle = null;
-					this._unmounting = false;
-					if (this._reconnect) {
-						this._reconnect = false;
-						if (this.isConnected) this._handle = mountIslandInternal(this, this._mergedProps());
-					}
-				});
-			}
-			attributeChangedCallback() {
-				if (this._handle && !this._unmounting) this._handle.updateProps(this._mergedProps());
-			}
-		}
-		customElements.define(tagName, IlhaIslandElement);
-	};
-	island.hydratable = async (props, opts) => {
-		const { name, as: rawTag = "div", snapshot = false, skipOnMount: explicitSkipOnMount } = opts;
-		const tag = assertValidSlotTagName(rawTag);
-		const resolvedProps = props ?? {};
-		const innerPromise = renderToString(resolvedProps, false, void 0, true);
-		let stateAttr = "";
-		if (snapshot !== false) {
-			const doState = snapshot === true || snapshot.state !== false;
-			const doDerived = snapshot === true || snapshot.derived !== false;
-			const doSkipOnMount = explicitSkipOnMount ?? false;
-			const snapshotData = { v: 2 };
-			const input = resolveInput(resolvedProps);
-			const probeFrame = freshFrame({ ssr: true });
-			withFrame(probeFrame, () => {
-				component(input);
-			});
-			if (doState) {
-				const states = [];
-				for (const slot of probeFrame.slots) {
-					if (slot.kind !== "state") continue;
-					const prevSub = setActiveSub(void 0);
-					try {
-						states.push(slot.acc());
-					} finally {
-						setActiveSub(prevSub);
-					}
-				}
-				snapshotData["s"] = states;
-			}
-			if (doDerived) {
-				const probePendings = probeFrame.pendingDerived ?? [];
-				if (probePendings.length > 0) {
-					await Promise.all(probePendings.map((p) => p.promise));
-					probeFrame.creating = false;
-					probeFrame.cursor = 0;
-					withFrame(probeFrame, () => {
-						component(input);
-					});
-				}
-				const derivedEntries = [];
-				for (const slot of probeFrame.slots) {
-					if (slot.kind !== "derived") continue;
-					const prevSub = setActiveSub(void 0);
-					let envelope;
-					try {
-						envelope = { ...slot.env() };
-					} finally {
-						setActiveSub(prevSub);
-					}
-					const entry = {
-						loading: false,
-						value: envelope.value
-					};
-					if (envelope.error) entry["error"] = envelope.error.message;
-					derivedEntries.push(entry);
-				}
-				snapshotData["d"] = derivedEntries;
-			}
-			if (doSkipOnMount) snapshotData["_skipOnMount"] = true;
-			stateAttr = ` ${STATE_ATTR}='${escapeHtml(JSON.stringify(snapshotData))}'`;
-		}
-		const inner = await innerPromise;
-		return `<${tag} data-ilha="${escapeHtml(name)}" ${PROPS_ATTR}='${escapeHtml(JSON.stringify(resolvedProps))}'${stateAttr}>${inner}</${tag}>`;
-	};
-	return island;
-});
-function mountAll(registry, options = {}) {
-	const root = options.root ?? document.body;
-	const lazy = options.lazy ?? false;
-	const unmounts = [];
-	function activateEl(host) {
-		const name = host.getAttribute("data-ilha");
-		if (!name) return;
-		const island = registry[name];
-		if (!island) {
-			`${name}${Object.keys(registry).join(", ")}`;
-			return;
-		}
-		let props = {};
-		const rawProps = host.getAttribute(PROPS_ATTR);
-		if (rawProps) {
-			const parsed = safeParseSnapshot(rawProps, `${PROPS_ATTR} on [data-ilha="${name}"]`);
-			if (parsed !== void 0) props = reviveSlotProps(parsed);
-		}
-		unmounts.push(island.mount(host, props));
-	}
-	const els = Array.from(root.querySelectorAll("[data-ilha]"));
-	if (lazy && typeof IntersectionObserver !== "undefined") {
-		let disposed = false;
-		const io = new IntersectionObserver((entries) => {
-			if (disposed) return;
-			for (const entry of entries) if (entry.isIntersecting) {
-				activateEl(entry.target);
-				io.unobserve(entry.target);
-			}
-		});
-		els.forEach((el) => io.observe(el));
-		unmounts.push(() => {
-			disposed = true;
-			io.disconnect();
-		});
-	} else els.forEach(activateEl);
-	return { unmount: () => {
-		const pending = [];
-		for (const u of unmounts) {
-			const result = u();
-			if (result instanceof Promise) pending.push(result);
-		}
-		if (pending.length > 0) return Promise.all(pending).then(() => {});
-	} };
-}
-setJsxRuntimeBridge({
-	registerEvent({ type, handler, modifier }) {
-		const ctx = currentRenderCtx();
-		if (!ctx) return void 0;
-		SSR_ACTION_STUB in handler;
-		const index = ctx.events.length;
-		ctx.events.push({
-			type,
-			handler,
-			modifier
-		});
-		return index;
-	},
-	slot({ island, props, key }) {
-		return ilhaRaw(emitIslandSlot({
-			island,
-			props,
-			key
-		}));
-	}
-});
-/**
-* Morph an element's children toward `html`, patching in place: surviving
-* elements keep their identity, listeners, and focus (see the morph engine).
-* Falls back to an innerHTML write when the root tags don't match.
-*/
-function morph(host, html) {
-	if (typeof document === "undefined") return;
-	const openTag = host.localName ?? "div";
-	const tpl = document.createElement("template");
-	tpl.innerHTML = `<${openTag}>${html}</${openTag}>`;
-	const next = tpl.content.firstElementChild;
-	if (!next || next.localName !== host.localName) {
-		host.innerHTML = html;
-		return;
-	}
-	try {
-		morphInner(host, next);
-	} catch {
-		host.innerHTML = html;
-	}
 }
-const html = ilhaHtml;
-const raw = ilhaRaw;
-const mount = mountAll;
-const context = ilhaContext;
 
 //#endregion
-export { action, batch, context, css, derived, each, effect, html, ilha, ilhaSignal, isSafeUrl, isSafeUrlAttrValue, isUrlAttributeName, json, morph, mount, onError, onUncaughtError, persist, raw, serializeStyle, state, untrack };
+export { Fragment, atom, h, mount, renderToString, wait, watch, when };