ilha 0.15.1 → 0.16.0

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

@@ -1,4 +1,4 @@
-import { l as Fragment } from "./types-DsdtZMhG.js";
-import { n as JSX } from "./vnode-CpSQZnLM.js";
+import { s as Fragment } from "./types-NhEiBvwy.js";
+import { n as JSX } from "./vnode-DskooLPD.js";
 import { jsx, jsxDEV, jsxs } from "./jsx-runtime.js";
 export { Fragment, type JSX, jsx, jsxDEV, jsxs };

package/dist/jsx-dev-runtime.js

@@ -1,4 +1,4 @@
-import { i as Fragment } from "./vnode-BHUY61Rm.js";
+import { r as Fragment } from "./vnode-DJ25Jn3D.js";
 import { jsx, jsxDEV, jsxs } from "./jsx-runtime.js";
 
 export { Fragment, jsx, jsxDEV, jsxs };

package/dist/jsx-runtime.d.ts

@@ -1,5 +1,5 @@
-import { a as ComponentFn, b as View, f as JsxComponent, l as Fragment, p as PropBag } from "./types-DsdtZMhG.js";
-import { n as JSX, t as h } from "./vnode-CpSQZnLM.js";
+import { _ as View, d as JsxComponent, o as ComponentFn, p as PropBag, s as Fragment } from "./types-NhEiBvwy.js";
+import { n as JSX, t as h } from "./vnode-DskooLPD.js";
 //#region src/jsx-runtime.d.ts
 export declare const jsx: (type: string | Fragment | ComponentFn | JsxComponent, props: PropBag | null, key?: string | number) => ReturnType<typeof h>;
 export declare const jsxs: typeof jsx;

package/dist/jsx-runtime.js

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

package/dist/mount-3Ggg67T0.d.ts

@@ -0,0 +1,14 @@
+import { a as Component, f as MountOptions } from "./types-NhEiBvwy.js";
+//#region src/mount.d.ts
+interface RenderToStringOptions {
+  /** Embed atom state for hydration. Default `true`. */
+  snapshot?: boolean;
+  /** Wrap the output in a `<div data-ilha>` host. Default `true`. */
+  markers?: boolean;
+  /** Serialize after this many ms even if work is still pending. */
+  timeout?: number;
+}
+declare const mount: (el: Element, fn: Component, opts?: MountOptions) => (() => void);
+declare const renderToString: (fn: Component, opts?: RenderToStringOptions) => Promise<string>;
+//#endregion
+export { mount as n, renderToString as r, RenderToStringOptions as t };

package/dist/mount-BwuJsiDH.js

@@ -0,0 +1,585 @@
+import { a as startRoot, v as ilhaError, y as ilhaWarn } from "./start-B-e1dG5U.js";
+import { c as isObject, n as KEY_ATTR, r as SLOT_ATTR } from "./shared-vpgYXytd.js";
+import { i as bindEvents, r as adoptEvents, t as createPainter } from "./paint-core-D1n4lbpF.js";
+
+//#region src/morph.ts
+const PRESERVE_ATTR = "data-morph-preserve";
+const STAND_IN_ATTR = "data-ilha-reuse";
+const FORM_ATTR = /^(?:value|checked|selected)$/u;
+const morphKeyOf = (el) => {
+	const k = el.getAttribute(KEY_ATTR);
+	if (k !== null) return `k:${k}`;
+	const s = el.getAttribute(SLOT_ATTR);
+	return s === null ? null : `s:${s}`;
+};
+/** Whether `data-morph-preserve` on `el` lists `token`. */
+const preserves = (el, token) => el.getAttribute(PRESERVE_ATTR)?.split(/\s+/u).includes(token) ?? false;
+/** Attributes the morph leaves to live state or to code outside the render. */
+const keepAttr = (el, name) => FORM_ATTR.test(name) || (name === PRESERVE_ATTR ? el.hasAttribute(name) : preserves(el, name));
+const syncAttributes = (from, to) => {
+	for (const { name, value } of to.attributes) if (!keepAttr(from, name) && from.getAttribute(name) !== value) from.setAttribute(name, value);
+	for (const name of from.getAttributeNames()) if (!to.hasAttribute(name) && name !== "open" && !keepAttr(from, name)) from.removeAttribute(name);
+};
+/** Deepest focused element, looking through open shadow roots. */
+const deepActiveElement = () => {
+	let active = document.activeElement;
+	while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement;
+	return active;
+};
+const snapshotFocus = () => {
+	if (globalThis.document === void 0) return;
+	const active = deepActiveElement();
+	if (!(active instanceof HTMLElement) || active === document.body) return;
+	const snap = { active };
+	try {
+		if ((active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement) && active.selectionStart !== null) snap.selection = {
+			dir: active.selectionDirection,
+			end: active.selectionEnd,
+			start: active.selectionStart
+		};
+	} catch {}
+	const sel = active.isContentEditable ? document.getSelection() : null;
+	if (sel) {
+		const ranges = [];
+		for (let i = 0; i < sel.rangeCount; i += 1) {
+			const range = sel.getRangeAt(i);
+			if (active.contains(range.startContainer)) ranges.push(range.cloneRange());
+		}
+		snap.ranges = ranges.length > 0 ? ranges : void 0;
+	}
+	return snap;
+};
+const restoreFocus = (snap) => {
+	if (!snap?.active.isConnected) return;
+	const { active, ranges, selection } = snap;
+	try {
+		if (deepActiveElement() !== active) {
+			active.focus({ preventScroll: true });
+			const sel = document.getSelection();
+			if (ranges && sel && ranges.every((r) => r.startContainer.isConnected)) {
+				sel.removeAllRanges();
+				for (const r of ranges) sel.addRange(r);
+			}
+		}
+		if (selection) {
+			const el = active;
+			if (el.selectionStart !== selection.start || el.selectionEnd !== selection.end) {
+				const dir = selection.dir ?? "none";
+				el.setSelectionRange(selection.start, selection.end, dir);
+			}
+		}
+	} catch {}
+};
+const standIns = /* @__PURE__ */ new WeakMap();
+/** Live nodes with an outstanding stand-in: the morph must not consume them. */
+const claimed = /* @__PURE__ */ new WeakSet();
+/** Placeholder for a connected live node inside a scratch render tree. */
+const standInFor = (live) => {
+	const el = document.createElementNS(live.namespaceURI, live.localName);
+	for (const name of [SLOT_ATTR, KEY_ATTR]) {
+		const v = live.getAttribute(name);
+		if (v !== null) el.setAttribute(name, v);
+	}
+	el.setAttribute(STAND_IN_ATTR, "");
+	standIns.set(el, live);
+	claimed.add(live);
+	return el;
+};
+const liveOf = (node) => {
+	const live = standIns.get(node);
+	if (!live) return node;
+	claimed.delete(live);
+	return live;
+};
+/**
+* Insert `node` before `ref`. Connected nodes move with `moveBefore` where the
+* browser has it, so they keep focus, iframe, dialog, and element state.
+*/
+const place = (parent, node, ref) => {
+	if (node === ref || node.parentNode === parent && node.nextSibling === ref) return;
+	const movable = parent;
+	if (node.isConnected && parent.isConnected && movable.moveBefore) try {
+		movable.moveBefore(node, ref);
+		return;
+	} catch {}
+	parent.insertBefore(node, ref);
+};
+/** Swap stand-ins nested in `node` (now in the document) for live nodes. */
+const resolveNested = (node) => {
+	if (!(node instanceof Element) || !node.firstElementChild) return;
+	for (const s of node.querySelectorAll(`[${STAND_IN_ATTR}]`)) {
+		const live = liveOf(s);
+		if (live !== s && s.parentNode) {
+			place(s.parentNode, live, s);
+			s.remove();
+		}
+	}
+};
+/**
+* Put a rendered node into the live tree: stand-ins become their live nodes,
+* and stand-ins nested in fresh subtrees resolve once the subtree is attached.
+*/
+const insertRendered = (parent, node, ref) => {
+	const live = liveOf(node);
+	place(parent, live, ref);
+	if (live === node) resolveNested(node);
+};
+/** Positions of the longest run of increasing old indexes: those never move. */
+const stableSet = (olds) => {
+	const tails = [];
+	const prev = [];
+	for (const [i, idx] of olds.entries()) {
+		if (idx === void 0) continue;
+		let lo = 0;
+		let hi = tails.length;
+		while (lo < hi) {
+			const mid = Math.floor((lo + hi) / 2);
+			if ((olds[tails[mid] ?? 0] ?? 0) < idx) lo = mid + 1;
+			else hi = mid;
+		}
+		prev[i] = tails[lo - 1] ?? -1;
+		tails[lo] = i;
+	}
+	const stable = /* @__PURE__ */ new Set();
+	for (let k = tails.at(-1) ?? -1; k >= 0; k = prev[k] ?? -1) stable.add(k);
+	return stable;
+};
+/**
+* Make `parent`'s children exactly `nodes` with the fewest moves. Nodes that
+* keep their relative order stay attached; removed nodes leave first.
+*/
+const placeChildren = (parent, rendered) => {
+	const focus = snapshotFocus();
+	const nodes = rendered.map(liveOf);
+	const wanted = new Set(nodes);
+	const oldIndex = /* @__PURE__ */ new Map();
+	for (let child = parent.firstChild; child;) {
+		const after = child.nextSibling;
+		if (wanted.has(child)) oldIndex.set(child, oldIndex.size);
+		else child.remove();
+		child = after;
+	}
+	const stable = stableSet(nodes.map((n) => oldIndex.get(n)));
+	let next = null;
+	for (let i = nodes.length - 1; i >= 0; i -= 1) {
+		const node = nodes[i] ?? null;
+		if (node && !stable.has(i)) {
+			place(parent, node, next);
+			if (!oldIndex.has(node)) resolveNested(node);
+		}
+		next = node;
+	}
+	restoreFocus(focus);
+};
+/** Late-bound: element morphs recurse into children morphed below. */
+const tree = {};
+const controlledBy = {
+	checked: /* @__PURE__ */ new WeakSet(),
+	selected: /* @__PURE__ */ new WeakSet(),
+	value: /* @__PURE__ */ new WeakSet()
+};
+/** Mark a rendered element controlled for `key`: the morph syncs it either way. */
+const markControlled = (el, key) => {
+	controlledBy[key].add(el);
+};
+const morphInput = (from, to) => {
+	const checked = to.hasAttribute("checked");
+	from.toggleAttribute("checked", checked);
+	if ((checked || controlledBy.checked.has(to)) && from.checked !== to.checked) from.checked = to.checked;
+	const value = to.getAttribute("value");
+	if (value === null) from.removeAttribute("value");
+	else {
+		if (from.getAttribute("value") !== value) from.setAttribute("value", value);
+		if (from.value !== to.value) from.value = to.value;
+	}
+};
+const morphTextarea = (from, to) => {
+	if (controlledBy.value.has(to) || to.textContent !== "" || from.textContent !== to.textContent) {
+		if (from.value !== to.value) from.value = to.value;
+		if (from.textContent !== to.textContent) from.textContent = to.textContent;
+	}
+};
+const morphSelect = (from, to) => {
+	const controlled = controlledBy.value.has(to) || [...to.options].some((o) => controlledBy.selected.has(o));
+	const before = new Map([...from.options].map((o) => [o, [o.hasAttribute("selected"), o.selected]]));
+	tree.morphChildren(from, to);
+	const options = [...from.options];
+	const attrsChanged = options.some((o) => o.hasAttribute("selected") !== (before.get(o)?.[0] ?? false));
+	for (const [i, o] of options.entries()) {
+		let want = before.get(o)?.[1] ?? o.selected;
+		if (controlled) want = to.options[i]?.selected ?? false;
+		else if (attrsChanged) want = o.hasAttribute("selected");
+		if (o.selected !== want) o.selected = want;
+	}
+};
+/** Rendered element → the live element the morph kept in its place. */
+const adoptedBy = /* @__PURE__ */ new WeakMap();
+/** The element a rendered element ended up as in the document. */
+const committedElement = (el) => adoptedBy.get(el) ?? el;
+/** Swap `fromNode` for a rendered node without ever detaching live nodes. */
+const replaceRendered = (fromNode, toNode) => {
+	if (fromNode.parentNode) {
+		insertRendered(fromNode.parentNode, toNode, fromNode);
+		fromNode.remove();
+	}
+};
+/**
+* While hydrating, server slot hosts are replaced by the freshly painted ones:
+* the new hole fibers are rooted in those, so their content must be installed.
+*/
+let hydrating = false;
+const morphElementPair = (from, to) => {
+	const toSlot = to.getAttribute(SLOT_ATTR);
+	if (from.localName !== to.localName || toSlot !== null && hydrating) {
+		replaceRendered(from, to);
+		return;
+	}
+	if (toSlot !== null) {
+		if (from.getAttribute("data-ilha-slot") !== toSlot) replaceRendered(from, to);
+		return;
+	}
+	adoptedBy.set(to, from);
+	adoptEvents(from, to);
+	const mode = to.getAttribute("contenteditable");
+	const keepChildren = preserves(from, "children") || preserves(to, "children") || mode !== null && mode !== "false" && !to.hasChildNodes() && from.getAttribute("contenteditable") === mode;
+	syncAttributes(from, to);
+	if (from instanceof HTMLInputElement) morphInput(from, to);
+	else if (from instanceof HTMLSelectElement) morphSelect(from, to);
+	else if (keepChildren) {} else if (from instanceof HTMLTextAreaElement) morphTextarea(from, to);
+	else tree.morphChildren(from, to);
+};
+const morphChild = (parent, from, to) => {
+	if (standIns.has(to) || !from || claimed.has(from)) insertRendered(parent, to, from ?? null);
+	else if (from.nodeType !== to.nodeType) replaceRendered(from, to);
+	else if (from instanceof Element) morphElementPair(from, to);
+	else if (from.nodeValue !== to.nodeValue) from.nodeValue = to.nodeValue;
+};
+const keyedIndex = (fromParent, toParent) => {
+	const from = /* @__PURE__ */ new Map();
+	for (const child of fromParent.children) {
+		const k = morphKeyOf(child);
+		if (k !== null && !from.has(k)) from.set(k, child);
+	}
+	if (from.size === 0) return;
+	const to = new Set(Array.from(toParent.children, morphKeyOf));
+	to.delete(null);
+	return {
+		from,
+		to
+	};
+};
+/** A keyed live node the new render drops and no stand-in still needs. */
+const isStale = (node, index) => {
+	const key = node instanceof Element && !claimed.has(node) ? morphKeyOf(node) : null;
+	return key !== null && !index.to.has(key);
+};
+/**
+* Bring the live node keyed like `to` into position `from`. Returns the node
+* to morph against, or `null` once `to` was inserted ahead of a keyed live
+* node that belongs further down.
+*/
+const alignKeyed = (parent, start, to, index) => {
+	let from = start;
+	const toKey = to instanceof Element ? morphKeyOf(to) : null;
+	const match = toKey === null ? void 0 : index.from.get(toKey);
+	if (toKey !== null && match) {
+		index.from.delete(toKey);
+		while (from && from !== match && isStale(from, index)) {
+			const next = from.nextSibling;
+			from.remove();
+			from = next ?? void 0;
+		}
+		if (match !== from) {
+			place(parent, match, from ?? null);
+			from = match;
+		}
+	}
+	const fromKey = from instanceof Element ? morphKeyOf(from) : null;
+	if (from && fromKey !== null && fromKey !== toKey && index.to.has(fromKey)) {
+		insertRendered(parent, to, from);
+		return null;
+	}
+	return from;
+};
+tree.morphChildren = (fromParent, toParent) => {
+	const toNodes = [...toParent.childNodes];
+	const index = keyedIndex(fromParent, toParent);
+	for (const [i, to] of toNodes.entries()) {
+		const at = fromParent.childNodes[i];
+		const from = index ? alignKeyed(fromParent, at, to, index) : at;
+		if (from !== null) morphChild(fromParent, from, to);
+	}
+	while (fromParent.childNodes.length > toNodes.length) fromParent.lastChild?.remove();
+};
+/** Morph `from`'s children into `to`'s, keeping focus and selection. */
+const morphInner = (from, to) => {
+	const focus = snapshotFocus();
+	tree.morphChildren(from, to);
+	restoreFocus(focus);
+};
+/** Morph the first client render into server markup, replacing slot hosts. */
+const hydrateInner = (from, to) => {
+	hydrating = true;
+	try {
+		morphInner(from, to);
+	} finally {
+		hydrating = false;
+	}
+};
+
+//#endregion
+//#region src/paint.ts
+const toggleAttr = (el, name, on) => {
+	if (on) el.setAttribute(name, "");
+	else el.removeAttribute(name);
+};
+/** The DOM painter: fresh renders morph into the live tree. */
+const { paint: paint$1 } = createPainter({
+	bindEvents,
+	committed: committedElement,
+	createElement: (tag, ns) => ns ? document.createElementNS(ns, tag) : document.createElement(tag),
+	createRaw: (html, parent) => {
+		const range = document.createRange();
+		range.selectNodeContents(parent);
+		return [...range.createContextualFragment(html).childNodes];
+	},
+	createText: (text) => document.createTextNode(text),
+	morph: (root, nodes, hydrate) => {
+		const el = root;
+		if (!el.hasChildNodes()) {
+			placeChildren(el, nodes);
+			return;
+		}
+		const tmp = document.createElement("div");
+		tmp.append(...nodes);
+		if (hydrate) {
+			const want = tmp.firstElementChild?.tagName;
+			if (want && el.firstElementChild?.tagName !== want) {
+				const found = el.firstElementChild?.tagName.toLowerCase();
+				ilhaWarn("ILHA006", `expected <${want.toLowerCase()}>, found <${found}>`);
+			}
+		}
+		(hydrate ? hydrateInner : morphInner)(el, tmp);
+	},
+	placeChildren: (root, nodes) => placeChildren(root, nodes),
+	reuseNode: (host) => host.isConnected ? standInFor(host) : host,
+	setFormControl: (el, key, v) => {
+		const node = el;
+		const set = v !== null && v !== void 0;
+		if (set) markControlled(el, key);
+		if (key !== "value") {
+			node[key] = Boolean(v);
+			toggleAttr(el, key, Boolean(v));
+			return;
+		}
+		const text = set ? String(v) : "";
+		if (el.localName === "textarea") node.defaultValue = text;
+		else if (el.localName !== "select") {
+			if (set) el.setAttribute("value", text);
+			else el.removeAttribute("value");
+		}
+		node.value = text;
+	},
+	setStyle: (el, css) => {
+		el.style.cssText = css;
+	}
+});
+
+//#endregion
+//#region src/snapshot.ts
+const MAX_SNAPSHOT_CHARS = 262144;
+const MAX_SNAPSHOT_DEPTH = 32;
+const UNSAFE_KEY = /^(?:__proto__|constructor|prototype)$/u;
+/** Container nesting depth of a parsed JSON value. */
+const depthOf = (value) => {
+	if (!Array.isArray(value) && !isObject(value)) return 0;
+	let max = 0;
+	for (const child of Object.values(value)) max = Math.max(max, depthOf(child));
+	return max + 1;
+};
+const encodeSnapshot = (values) => JSON.stringify({ v: values });
+/** Parse a snapshot; oversized, too deep, or malformed input yields `undefined`. */
+const decodeSnapshot = (raw) => {
+	if (raw.length > MAX_SNAPSHOT_CHARS) return;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw, (k, v) => UNSAFE_KEY.test(k) ? void 0 : v);
+	} catch {
+		return;
+	}
+	if (!isObject(parsed) || depthOf(parsed) > MAX_SNAPSHOT_DEPTH) return;
+	const values = "v" in parsed ? parsed.v : void 0;
+	return Array.isArray(values) ? values : void 0;
+};
+
+//#endregion
+//#region src/ssr-dom.ts
+const VOID = /^(?:area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)$/u;
+/** Tags whose children are raw text — content is not HTML-escaped. */
+const RAW_TEXT = /^(?:script|style)$/u;
+const escapeText = (s) => s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+const escapeAttr = (s) => escapeText(s).replaceAll("\"", "&quot;");
+/** Minimal element for string rendering; the root is an element without a tag. */
+var SsrEl = class {
+	kind = "element";
+	localName;
+	tagName;
+	attrs = /* @__PURE__ */ new Map();
+	children = [];
+	constructor(tag) {
+		this.localName = tag.toLowerCase();
+		this.tagName = this.localName.toUpperCase();
+	}
+	setAttribute(name, value) {
+		this.attrs.set(name, value);
+	}
+	getAttribute(name) {
+		return this.attrs.get(name) ?? null;
+	}
+	removeAttribute(name) {
+		this.attrs.delete(name);
+	}
+	append(...nodes) {
+		this.children.push(...nodes);
+	}
+	get textContent() {
+		return this.children.map((n) => {
+			if (n.kind === "text") return n.text;
+			return n.kind === "raw" ? n.html : n.textContent;
+		}).join("");
+	}
+	set textContent(text) {
+		this.children = [{
+			kind: "text",
+			text
+		}];
+	}
+};
+/**
+* Serialize a node. With `bare`, hole hosts (`data-ilha-slot`) vanish and only
+* their content remains: a render that never hydrates needs no hole markers.
+*/
+const serializeNode = (node, bare = false) => {
+	if (node.kind === "text") return escapeText(node.text);
+	if (node.kind === "raw") return node.html;
+	const inner = node.children.map((c) => serializeNode(c, bare)).join("");
+	const tag = node.localName;
+	if (!tag || bare && node.attrs.has("data-ilha-slot")) return inner;
+	let open = `<${tag}`;
+	for (const [name, value] of node.attrs) open += ` ${name}="${escapeAttr(value)}"`;
+	open += ">";
+	if (VOID.test(tag)) return open;
+	if (RAW_TEXT.test(tag)) {
+		const raw = node.textContent;
+		if (new RegExp(`</${tag}\\b`, "iu").test(raw)) throw ilhaError("ILHA007", `<${tag}> contains "</${tag}"`);
+		return `${open}${raw}</${tag}>`;
+	}
+	return `${open}${inner}</${tag}>`;
+};
+
+//#endregion
+//#region src/ssr-paint.ts
+const WHITESPACE_RUN = /\s+/gu;
+/**
+* Mark the first option whose value is `value` selected and clear the rest,
+* as setting a live select's `.value` does. Returns whether one matched.
+*/
+const selectOption = (parent, value, found) => {
+	let matched = found;
+	for (const child of parent.children) {
+		if (child.kind !== "element") continue;
+		if (child.localName === "optgroup") matched = selectOption(child, value, matched);
+		else if (child.localName === "option") {
+			const optionValue = child.getAttribute("value") ?? child.textContent.trim().replaceAll(WHITESPACE_RUN, " ");
+			if (!matched && optionValue === value) {
+				child.setAttribute("selected", "");
+				matched = true;
+			} else child.removeAttribute("selected");
+		}
+	}
+	return matched;
+};
+/** The string painter: every paint rebuilds the host's children. */
+const { paint } = createPainter({
+	createElement: (tag) => new SsrEl(tag),
+	createRaw: (html) => [{
+		html,
+		kind: "raw"
+	}],
+	createText: (text) => ({
+		kind: "text",
+		text
+	}),
+	placeChildren: (root, nodes) => {
+		const host = root;
+		host.children = nodes;
+	},
+	setFormControl: (el, key, v) => {
+		if (key !== "value") {
+			if (v) el.setAttribute(key, "");
+			else el.removeAttribute(key);
+			return;
+		}
+		const text = String(v ?? "");
+		if (el.localName === "textarea") el.textContent = text;
+		else if (el.localName !== "select") el.setAttribute("value", text);
+		else if (v !== null && v !== void 0) selectOption(el, text, false);
+	}
+});
+
+//#endregion
+//#region src/mount.ts
+const readSnapshot = (el) => {
+	const raw = (el.matches("[data-ilha]") ? el : el.querySelector("[data-ilha]"))?.getAttribute("data-ilha-state");
+	if (raw) return decodeSnapshot(raw);
+	const first = el.firstElementChild;
+	if (first?.matches("template[data-ilha-state]")) {
+		first.remove();
+		return decodeSnapshot(first.getAttribute("data-ilha-state") ?? "");
+	}
+};
+/** Mount with access to the root runtime; `ilha/test` uses it to see pending work. */
+const mountWithRuntime = (el, fn, opts, onRuntime) => {
+	const hydrate = opts?.hydrate === true;
+	if (!hydrate) el.innerHTML = "";
+	const { close } = startRoot({
+		fn,
+		hydrate,
+		onError: opts?.onError,
+		onIdle: opts?.onIdle,
+		onRuntime,
+		paint: paint$1,
+		root: el,
+		snapshot: hydrate ? readSnapshot(el) : void 0
+	});
+	return () => {
+		close();
+		if (!hydrate) el.innerHTML = "";
+	};
+};
+const mount = (el, fn, opts) => mountWithRuntime(el, fn, opts);
+const renderToString = async (fn, opts) => {
+	const root = new SsrEl("");
+	const { close, ready, runtime } = startRoot({
+		fn,
+		paint,
+		root,
+		ssr: true
+	});
+	const { timeout, snapshot = true, markers = true } = opts ?? {};
+	if (timeout === void 0) await ready;
+	else {
+		const late = Promise.withResolvers();
+		const timer = setTimeout(late.resolve, timeout, null);
+		await Promise.race([ready, late.promise]);
+		clearTimeout(timer);
+	}
+	const inner = serializeNode(root, !markers && !snapshot);
+	const state = snapshot ? ` data-ilha-state="${escapeAttr(encodeSnapshot(runtime.ssrValues))}"` : "";
+	close();
+	if (markers) return `<div data-ilha${state}>${inner}</div>`;
+	return state ? `<template${state}></template>${inner}` : inner;
+};
+
+//#endregion
+export { mountWithRuntime as n, renderToString as r, mount as t };