ilha 0.14.10 → 0.15.1

package/dist/define.d.ts

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

package/dist/define.js

@@ -1,4 +1,4 @@
-import { t as mount } from "./mount-BzNrfVW4.js";
+import { t as mount } from "./mount-DCu8b0hE.js";
 
 //#region src/define.ts
 const define = (name, component) => {

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { S as Yielded, b as WatchContext, c as EventSourceStatus, g as UnsafeHtml, h as ResourceOptions, i as Component, l as Fragment, m as ResourceFetcher, n as AtomHandle, o as EventSourceFeed, p as Resource, r as AtomOptions, s as EventSourceOptions, t as AtomEquality, u as Instruction, v as View, x as WatchOnceCleanup, y as WatchCallback } from "./types-CJF2qMK6.js";
-import { t as h } from "./vnode-CUTNGblA.js";
+import { C as WatchOnceCleanup, S as WatchContext, _ as ResourceOptions, b as View, c as EventSourceStatus, d as Instruction, g as ResourceFetcher, h as Resource, i as Component, l as Fragment, n as AtomHandle, o as EventSourceFeed, r as AtomOptions, s as EventSourceOptions, t as AtomEquality, v as UnsafeHtml, w as Yielded, x as WatchCallback } from "./types-DsdtZMhG.js";
+import { t as h } from "./vnode-CpSQZnLM.js";
+import { r as watch } from "./runtime-Baq7MtkE.js";
 import * as Atom from "effect/reactivity/Atom";
 import { Equal } from "effect";
 import * as Effect$1 from "effect/Effect";
 import * as Stream$1 from "effect/Stream";
 import { AtomRegistry } from "effect/reactivity/AtomRegistry";
-import "effect/Scope";
 //#region src/context.d.ts
 interface ContextProviderProps<A> {
   value: A;
@@ -34,18 +34,6 @@ interface ErrorBoundaryProps {
 /** Catch subtree failures and paint a fallback. Supports reset(). */
 export declare const ErrorBoundary: (props: ErrorBoundaryProps) => View;
 //#endregion
-//#region src/watch.d.ts
-/** Values delivered to watch callbacks. */
-type WatchValue = string | number | boolean | bigint | null | undefined | readonly WatchValue[] | WatchRecord;
-interface WatchRecord {
-  readonly [key: string]: WatchValue | undefined;
-}
-interface WatchFn {
-  <A extends WatchValue>(source: AtomHandle<A> | Atom.Atom<A> | Stream$1.Stream<A, unknown, unknown>, fn: WatchCallback<A>): Instruction<undefined>;
-  once: (fn: (ctx: WatchContext) => WatchOnceCleanup | undefined | Promise<WatchOnceCleanup | undefined>) => Instruction<undefined>;
-}
-export declare const watch: WatchFn;
-//#endregion
 //#region src/atom.d.ts
 /** Key-order-insensitive deep equality for JSON-shaped values. */
 export declare const structuralEqual: typeof Equal.equals;
@@ -90,7 +78,11 @@ interface RenderToStringOptions {
 }
 interface MountOptions {
   hydrate?: boolean;
-  onError?: <E>(error: E) => void;
+  /**
+   * Called with a failing root component, and with a nested component no
+   * `ErrorBoundary` caught, before the error view paints.
+   */
+  onError?: (error: Error) => void;
 }
 export declare const mount: (el: Element, fn: Component, opts?: MountOptions) => (() => void);
 export declare const renderToString: (fn: Component, opts?: RenderToStringOptions) => Promise<string>;
@@ -106,4 +98,4 @@ export declare const renderToString: (fn: Component, opts?: RenderToStringOption
  */
 export declare const unsafe: (html: string) => UnsafeHtml;
 //#endregion
-export { type AtomEquality, type AtomHandle, type AtomOptions, type Component, type ContextProviderProps, type ErrorBoundaryProps, type ErrorFallback, type ErrorFallbackProps, type EventSourceFeed, type EventSourceOptions, type EventSourceStatus, Fragment, type IlhaContext, type MountOptions, type RenderToStringOptions, type Resource, type ResourceFetcher, type ResourceOptions, type UnsafeHtml, type View, type WatchCallback, type WatchContext, type WatchOnceCleanup, h };
+export { type AtomEquality, type AtomHandle, type AtomOptions, type Component, type ContextProviderProps, type ErrorBoundaryProps, type ErrorFallback, type ErrorFallbackProps, type EventSourceFeed, type EventSourceOptions, type EventSourceStatus, Fragment, type IlhaContext, type MountOptions, type RenderToStringOptions, type Resource, type ResourceFetcher, type ResourceOptions, type UnsafeHtml, type View, type WatchCallback, type WatchContext, type WatchOnceCleanup, h, watch };

package/dist/index.js

@@ -1,5 +1,6 @@
-import { _ as makeFiber, a as interpret, c as handleOwner, d as structuralEqual, f as untrack, g as getFiber, h as closeFiber, i as runSetup, l as instr, m as clearFiberView, n as renderToString, o as atom, p as wrapHandle, r as unsafe, s as batch, t as mount, u as isAtomHandle } from "./mount-BzNrfVW4.js";
-import { d as errorView, g as isString, i as Fragment, p as isFunction, t as h } from "./vnode-M-oJMKcv.js";
+import { _ as isString, f as errorView, i as Fragment, m as isFunction, t as h } from "./vnode-BHUY61Rm.js";
+import { C as makeFiber, S as getFiber, _ as structuralEqual, b as clearFiberView, d as interpret, f as atom, g as isAtomHandle, h as instr, m as handleOwner, n as unsafe, p as batch, u as runSetup, v as untrack, x as closeFiber, y as wrapHandle } from "./paint-core-D9VO-oUM.js";
+import { n as renderToString, t as mount } from "./mount-DCu8b0hE.js";
 import * as Atom from "effect/reactivity/Atom";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";

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

@@ -1,4 +1,4 @@
-import { l as Fragment } from "./types-CJF2qMK6.js";
-import { n as JSX } from "./vnode-CUTNGblA.js";
+import { l as Fragment } from "./types-DsdtZMhG.js";
+import { n as JSX } from "./vnode-CpSQZnLM.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-M-oJMKcv.js";
+import { i as Fragment } from "./vnode-BHUY61Rm.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, d as JsxComponent, f as PropBag, l as Fragment, v as View } from "./types-CJF2qMK6.js";
-import { n as JSX, t as h } from "./vnode-CUTNGblA.js";
+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";
 //#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-M-oJMKcv.js";
+import { i as Fragment, t as h } from "./vnode-BHUY61Rm.js";
 
 //#region src/jsx-runtime.ts
 const jsx = (type, props, key) => h(type, key === void 0 ? props : {

package/dist/mount-DCu8b0hE.js

@@ -0,0 +1,482 @@
+import { _ as isString, c as KEEP, d as defer, g as isObject, m as isFunction, r as isVNode, u as SLOT_ATTR, y as unwrap } from "./vnode-BHUY61Rm.js";
+import { T as makeRuntime, a as morphInner, c as bindEvents, i as insertRendered, l as eventTypeFromProp, o as placeChildren, r as committedElement, s as standInFor, t as createPainter, u as runSetup, w as makeRootFiber, x as closeFiber } from "./paint-core-D9VO-oUM.js";
+
+//#region src/paint.ts
+const noopDisconnect = () => {};
+const core$1 = createPainter({
+	appendRoot: (root, node) => insertRendered(root, node, null),
+	asElement: (el) => el,
+	asNode: (host) => host,
+	asRoot: (el) => el,
+	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];
+	},
+	createSlotHost: (slotId) => {
+		const host = document.createElement("span");
+		if (slotId !== null) host.setAttribute(SLOT_ATTR, slotId);
+		host.style.display = "contents";
+		return host;
+	},
+	createText: (text) => document.createTextNode(text),
+	disconnect: noopDisconnect,
+	placeChildren: (root, nodes) => {
+		if (root instanceof Element) placeChildren(root, nodes);
+	},
+	reuseNode: (host) => host instanceof Element && host.isConnected ? standInFor(host) : host,
+	setFormControl: (el, key, v) => {
+		const node = el;
+		if (key === "value") {
+			if (v === null || v === void 0) {
+				el.removeAttribute("value");
+				node.value = "";
+			} else {
+				el.setAttribute("value", String(v));
+				node.value = String(v);
+			}
+		} else if (key === "checked") {
+			node.checked = Boolean(v);
+			if (v) el.setAttribute("checked", "");
+			else el.removeAttribute("checked");
+		} else {
+			node.selected = Boolean(v);
+			if (v) el.setAttribute("selected", "");
+			else el.removeAttribute("selected");
+		}
+	},
+	setStyle: (el, css) => {
+		el.style.cssText = css;
+	}
+});
+const refreshAtomHost = (fiber, atom, host, hole) => {
+	if (hole.closed || !host.isConnected) return;
+	const next = unwrap(fiber.registry.get(atom));
+	if (next === KEEP) return;
+	core$1.paintHole(hole, next);
+};
+const refreshAllAtomHosts = (fiber) => {
+	for (const h of fiber.holes) if (h.atom && h.host && h.holeFiber) refreshAtomHost(fiber, h.atom, h.host, h.holeFiber);
+};
+const pruneDisconnectedAtomHoles = (fiber) => {
+	fiber.holes = fiber.holes.filter((h) => {
+		if (!h.atom || !h.host || !h.holeFiber) return true;
+		if (h.host.isConnected) return true;
+		h.dispose();
+		return false;
+	});
+};
+const canHydrate = (fiber, view) => {
+	if (!isVNode(view) || !isString(view.type)) return false;
+	const el = fiber.root.firstElementChild;
+	return !!el && el.tagName === view.type.toUpperCase();
+};
+const paintHydrate = (fiber, view) => {
+	const el = fiber.root.firstElementChild;
+	if (!el) return;
+	fiber.hydrate = false;
+	fiber.liveEl = el;
+	core$1.applyProps(el, view.props, fiber);
+	const childFiber = {
+		...fiber,
+		holes: fiber.holes,
+		root: el
+	};
+	el.replaceChildren();
+	for (const c of view.children) for (const n of core$1.materialize(c, childFiber)) insertRendered(el, n, null);
+};
+const paintMorphLive = (fiber, view) => {
+	if (!fiber.liveEl) return;
+	core$1.disposeHoles(fiber, { morph: true });
+	core$1.applyProps(fiber.liveEl, view.props, fiber);
+	const liveNs = fiber.liveEl.namespaceURI;
+	const tmp = liveNs && liveNs !== "http://www.w3.org/1999/xhtml" ? document.createElementNS(liveNs, fiber.liveEl.localName) : document.createElement(fiber.liveEl.localName);
+	const childFiber = {
+		...fiber,
+		holes: fiber.holes,
+		root: tmp
+	};
+	for (const c of view.children) for (const n of core$1.materialize(c, childFiber)) tmp.append(n);
+	morphInner(fiber.liveEl, tmp);
+	refreshAllAtomHosts(fiber);
+	pruneDisconnectedAtomHoles(fiber);
+};
+const paintRoot = (fiber, view) => {
+	fiber.islandFrame ??= {
+		i: 0,
+		slots: []
+	};
+	if (fiber.hydrate) {
+		if (canHydrate(fiber, view)) {
+			paintHydrate(fiber, view);
+			return;
+		}
+		console.warn("[ilha] hydrate mismatch, full mount");
+		fiber.hydrate = false;
+		if (fiber.root instanceof Element) fiber.root.replaceChildren();
+	}
+	if (fiber.liveEl && isVNode(view) && isString(view.type) && fiber.liveEl.localName === view.type) {
+		paintMorphLive(fiber, view);
+		return;
+	}
+	core$1.disposeHoles(fiber, { morph: true });
+	if (fiber.root instanceof Element && fiber.root.childNodes.length > 0) {
+		const tmp = document.createElement("div");
+		for (const n of core$1.materialize(view, fiber)) tmp.append(n);
+		morphInner(fiber.root, tmp);
+		const first = fiber.root.firstElementChild;
+		if (first) fiber.liveEl = first;
+		return;
+	}
+	core$1.insert(fiber, core$1.materialize(view, fiber));
+	const first = fiber.root instanceof Element ? fiber.root.firstElementChild : null;
+	if (first) fiber.liveEl = first;
+};
+const paint$1 = (fiber, view) => {
+	core$1.commit(() => {
+		core$1.pass(fiber, () => {
+			paintRoot(fiber, view);
+		});
+	});
+};
+
+//#endregion
+//#region src/snapshot.ts
+const MAX_SNAPSHOT_CHARS = 262144;
+const MAX_SNAPSHOT_DEPTH = 32;
+const exceedsMaxDepth = (value, depth) => {
+	if (depth > MAX_SNAPSHOT_DEPTH) return true;
+	if (value === null || !isObject(value)) {
+		if (Array.isArray(value)) {
+			for (const item of value) if (exceedsMaxDepth(item, depth + 1)) return true;
+		}
+		return false;
+	}
+	const obj = value;
+	for (const key of Object.keys(obj)) if (exceedsMaxDepth(obj[key], depth + 1)) return true;
+	return false;
+};
+const deleteUnsafeKey = (obj, key) => {
+	if (Object.hasOwn(obj, key)) Reflect.deleteProperty(obj, key);
+};
+const stripUnsafeKeys = (value) => {
+	if (Array.isArray(value)) {
+		for (const item of value) stripUnsafeKeys(item);
+		return;
+	}
+	if (value === null || !isObject(value)) return;
+	const obj = value;
+	deleteUnsafeKey(obj, "__proto__");
+	deleteUnsafeKey(obj, "constructor");
+	deleteUnsafeKey(obj, "prototype");
+	for (const key of Object.getOwnPropertyNames(obj)) stripUnsafeKeys(obj[key]);
+};
+const safeParseSnapshot = (raw) => {
+	if (raw.length > MAX_SNAPSHOT_CHARS) return;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return;
+	}
+	if (exceedsMaxDepth(parsed, 1)) return;
+	if (!isObject(parsed) || Array.isArray(parsed)) return;
+	stripUnsafeKeys(parsed);
+	return parsed;
+};
+const encodeSnapshot = (values) => JSON.stringify({ v: values });
+const decodeSnapshot = (raw) => {
+	const values = safeParseSnapshot(raw)?.v;
+	return Array.isArray(values) ? values : void 0;
+};
+
+//#endregion
+//#region src/ssr-dom.ts
+const VOID = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+/** Tags whose children are raw text — do not HTML-escape content. */
+const RAW_TEXT = /* @__PURE__ */ new Set(["script", "style"]);
+const escapeText = (s) => s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+const escapeAttr = (s) => escapeText(s).replaceAll("\"", "&quot;");
+const createSsrRaw = (html) => ({
+	html,
+	kind: "raw"
+});
+const createSsrText = (text) => ({
+	kind: "text",
+	text
+});
+const serializeRawText = (tag, text) => {
+	if (new RegExp(`</${tag}\\b`, "iu").test(text)) throw new Error(`ilha: unsafe raw text in <${tag}> (contains "</${tag}")`);
+	return text;
+};
+const serializeNode = (node) => {
+	if (node.kind === "text") return escapeText(node.text);
+	if (node.kind === "raw") return node.html;
+	const parts = [];
+	for (const [name, value] of node.attrs) parts.push(`${name}="${escapeAttr(value)}"`);
+	const attr = parts.length > 0 ? ` ${parts.join(" ")}` : "";
+	const { tag } = node;
+	if (VOID.has(tag)) return `<${tag}${attr}>`;
+	if (RAW_TEXT.has(tag)) return `<${tag}${attr}>${serializeRawText(tag, node.textContent)}</${tag}>`;
+	return `<${tag}${attr}>${node.children.map(serializeNode).join("")}</${tag}>`;
+};
+const toDataAttr = (key) => `data-${key.replaceAll(/[A-Z]/gu, (ch) => `-${ch.toLowerCase()}`)}`;
+const isSymbolKey = (value) => Object.prototype.toString.call(value) === "[object Symbol]";
+const createSsrElement = (tag) => {
+	const lower = tag.toLowerCase();
+	const children = [];
+	const el = {
+		append: (...nodes) => {
+			children.push(...nodes);
+		},
+		appendChild: (node) => {
+			children.push(node);
+		},
+		attrs: /* @__PURE__ */ new Map(),
+		children,
+		dataset: new Proxy({}, {
+			get: (_t, prop) => {
+				if (prop === "undefined" || isSymbolKey(prop)) return;
+				return el.getAttribute(toDataAttr(prop)) ?? void 0;
+			},
+			set: (_t, prop, value) => {
+				if (isSymbolKey(prop)) return false;
+				const attr = toDataAttr(prop);
+				if (value === void 0 || value === null) el.removeAttribute(attr);
+				else el.setAttribute(attr, String(value));
+				return true;
+			}
+		}),
+		getAttribute: (name) => {
+			const value = el.attrs.get(name);
+			return value === void 0 ? null : value;
+		},
+		hasAttribute: (name) => el.attrs.has(name),
+		isConnected: true,
+		kind: "element",
+		localName: lower,
+		removeAttribute: (name) => {
+			el.attrs.delete(name);
+		},
+		replaceChildren: (...nodes) => {
+			children.length = 0;
+			children.push(...nodes);
+		},
+		setAttribute: (name, value) => {
+			el.attrs.set(name, value);
+		},
+		tag: lower,
+		tagName: lower.toUpperCase(),
+		get textContent() {
+			return children.map((n) => {
+				if (n.kind === "text") return n.text;
+				if (n.kind === "raw") return n.html;
+				return n.textContent;
+			}).join("");
+		},
+		set textContent(value) {
+			children.length = 0;
+			children.push(createSsrText(value));
+		}
+	};
+	return el;
+};
+const createSsrRoot = () => {
+	const children = [];
+	return {
+		append: (...nodes) => {
+			children.push(...nodes);
+		},
+		appendChild: (node) => {
+			children.push(node);
+		},
+		children,
+		get innerHTML() {
+			return children.map(serializeNode).join("");
+		},
+		kind: "root",
+		replaceChildren: () => {
+			children.length = 0;
+		}
+	};
+};
+
+//#endregion
+//#region src/ssr-paint.ts
+const ssrAs = (n) => n;
+const ACTION_CALL = Symbol.for("ilha.actionCall");
+const bindSsrEvents = (el, props, fiber) => {
+	const seen = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(props)) {
+		const type = eventTypeFromProp(key);
+		if (!type || seen.has(type)) continue;
+		seen.add(type);
+		const fn = props[key];
+		if (!isFunction(fn)) continue;
+		const branded = fn[ACTION_CALL];
+		const rec = branded?.k ? {
+			a: branded.a ?? [],
+			k: branded.k
+		} : void 0;
+		if (!rec) continue;
+		const id = `${type}:${fiber.runtime.ssrEventI}`;
+		fiber.runtime.ssrEventI += 1;
+		fiber.runtime.ssrActions[id] = rec;
+		const existing = el.dataset.ilhaOn;
+		el.dataset.ilhaOn = existing ? `${existing},${id}` : id;
+	}
+};
+const core = createPainter({
+	appendRoot: (root, node) => ssrAs(root).append(node),
+	asElement: (el) => ssrAs(el),
+	asNode: (host) => ssrAs(host),
+	asRoot: (el) => ssrAs(el),
+	bindEvents: bindSsrEvents,
+	committed: (el) => el,
+	createElement: createSsrElement,
+	createRaw: (html, _parent) => [createSsrRaw(html)],
+	createSlotHost: (slotId) => {
+		const host = createSsrElement("span");
+		if (slotId !== null) host.setAttribute(SLOT_ATTR, slotId);
+		host.setAttribute("style", "display:contents");
+		return host;
+	},
+	createText: createSsrText,
+	disconnect: (el) => {
+		el.isConnected = false;
+	},
+	placeChildren: (root, nodes) => {
+		const host = ssrAs(root);
+		host.replaceChildren();
+		for (const n of nodes) host.append(n);
+	},
+	reuseNode: (host) => ssrAs(host),
+	setFormControl: (el, key, v) => {
+		if (key === "value") el.setAttribute("value", String(v ?? ""));
+		else if (v) el.setAttribute(key, "");
+		else el.removeAttribute(key);
+	},
+	setStyle: (el, css) => el.setAttribute("style", css)
+});
+const paint = (fiber, view) => {
+	fiber.islandFrame ??= {
+		i: 0,
+		slots: []
+	};
+	core.pass(fiber, () => {
+		core.disposeHoles(fiber);
+		ssrAs(fiber.root).replaceChildren();
+		core.insert(fiber, core.materialize(view, fiber));
+	});
+};
+const attachSsr = (fn, opts) => {
+	const root = createSsrRoot();
+	const runtime = makeRuntime({
+		onError: opts?.onError,
+		ssr: true,
+		ssrCapture: opts?.ssrCapture === true
+	});
+	const { promise: ready, resolve } = defer();
+	const fiber = makeRootFiber({
+		paint,
+		root: ssrAs(root),
+		runtime,
+		settle: resolve
+	});
+	runtime.begin();
+	runtime.setIdle(resolve);
+	runSetup(fiber, fn);
+	runtime.end();
+	return {
+		ready,
+		root,
+		runtime,
+		unmount: () => {
+			closeFiber(fiber);
+			runtime.close();
+			root.replaceChildren();
+		}
+	};
+};
+
+//#endregion
+//#region src/mount.ts
+const readHydrate = (el) => {
+	const raw = (el.matches("[data-ilha]") ? el : el.querySelector("[data-ilha]"))?.dataset.ilhaState;
+	if (raw) return decodeSnapshot(raw);
+	const first = el.firstElementChild;
+	if (first?.tagName === "TEMPLATE" && first.matches("[data-ilha-state]")) {
+		const tplRaw = first.dataset.ilhaState;
+		first.remove();
+		return tplRaw ? decodeSnapshot(tplRaw) : void 0;
+	}
+};
+const delay = (ms) => {
+	const { promise, resolve } = defer();
+	setTimeout(resolve, ms);
+	return promise;
+};
+const attach = (el, fn, opts) => {
+	if (!opts?.hydrate) el.innerHTML = "";
+	const runtime = makeRuntime({
+		hydrate: opts?.hydrate ? readHydrate(el) : void 0,
+		onError: opts?.onError
+	});
+	const { promise: ready, resolve } = defer();
+	const fiber = makeRootFiber({
+		paint: paint$1,
+		root: el,
+		runtime,
+		settle: resolve
+	});
+	if (opts?.hydrate) fiber.hydrate = true;
+	runtime.begin();
+	runtime.setIdle(resolve);
+	runSetup(fiber, fn);
+	runtime.end();
+	return {
+		ready,
+		runtime,
+		unmount: () => {
+			closeFiber(fiber);
+			runtime.close();
+			if (!opts?.hydrate) el.innerHTML = "";
+		}
+	};
+};
+const mount = (el, fn, opts) => attach(el, fn, opts).unmount;
+const renderToString = async (fn, opts) => {
+	const snapshot = opts?.snapshot !== false;
+	const markers = opts?.markers !== false;
+	const { unmount, ready, runtime, root } = attachSsr(fn, { ssrCapture: opts?.captureActions === true });
+	const timeout = opts?.timeout;
+	await (timeout === void 0 ? ready : Promise.race([ready, delay(timeout)]));
+	let inner = root.innerHTML;
+	const actions = runtime.ssrActions;
+	if (Object.keys(actions).length > 0) inner = `<template data-ilha-actions="${escapeAttr(JSON.stringify(actions))}"></template>${inner}`;
+	const snap = snapshot ? encodeSnapshot(runtime.ssrValues) : void 0;
+	unmount();
+	if (!markers) return snap ? `<template data-ilha-state="${escapeAttr(snap)}"></template>${inner}` : inner;
+	return `<div data-ilha${snap ? ` data-ilha-state="${escapeAttr(snap)}"` : ""}>${inner}</div>`;
+};
+
+//#endregion
+export { renderToString as n, mount as t };