ilha 0.15.2 → 0.16.0

package/dist/{runtime-Baq7MtkE.d.ts → runtime-BCdKBqYp.d.ts}

@@ -1,4 +1,5 @@
-import { C as WatchOnceCleanup, S as WatchContext, a as ComponentFn, b as View, d as Instruction, l as Fragment, n as AtomHandle, p as PropBag, u as IlhaRuntime, x as WatchCallback } from "./types-DsdtZMhG.js";
+import { _ as View, b as WatchOnceCleanup, c as IlhaRuntime, l as Instruction, n as AtomHandle, p as PropBag, v as WatchCallback, y as WatchContext } from "./types-NhEiBvwy.js";
+import "./snapshot-BDC74QwI.js";
 import * as Atom from "effect/reactivity/Atom";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
@@ -10,48 +11,42 @@ type WatchValue = string | number | boolean | bigint | null | undefined | readon
 interface WatchRecord {
   readonly [key: string]: WatchValue | undefined;
 }
-declare const WATCH_ONCE: unique symbol;
-/** Discriminator for watch slot identity (atom/stream instance). */
-type WatchKey = Atom.Atom<WatchValue> | Stream.Stream<WatchValue, unknown, unknown> | AtomHandle<WatchValue> | typeof WATCH_ONCE;
+type WatchRun = (ctx: WatchContext) => WatchOnceCleanup | undefined | Promise<WatchOnceCleanup | undefined>;
+interface WatchRef {
+  /** Latest callback; a rerender swaps it without resubscribing. */
+  fn?: WatchCallback<never>;
+}
 interface WatchSlot {
+  /** Source identity: the watched atom or stream, or the `watch.once` marker. */
   key: WatchKey;
-  fnRef?: {
-    current: (value: WatchValue) => void;
-  };
+  ref: WatchRef;
   dispose: () => void;
 }
+declare const ONCE: unique symbol;
+type WatchKey = Atom.Atom<WatchValue> | Stream.Stream<WatchValue, unknown, unknown> | typeof ONCE;
 interface WatchFn {
-  <A extends WatchValue>(source: AtomHandle<A> | Atom.Atom<A> | Stream.Stream<A, unknown, unknown>, fn: WatchCallback<A>): Instruction<undefined>;
-  once: (fn: (ctx: WatchContext) => WatchOnceCleanup | undefined | Promise<WatchOnceCleanup | undefined>) => Instruction<undefined>;
+  /** Run `fn` with the current value of `source` now and on every change. */
+  <A extends WatchValue>(source: AtomHandle<A> | Atom.Atom<A> | Stream.Stream<A, unknown, unknown>, fn: WatchCallback<A>): Instruction<void>;
+  /** Run `fn` once on mount; its returned cleanup runs on unmount. */
+  once: (fn: WatchRun) => Instruction<void>;
 }
 declare const watch: WatchFn;
 //#endregion
 //#region src/runtime.d.ts
+/** A disposable a paint leaves behind: a child fiber, subscription, or ref. */
 interface Hole {
   dispose: () => void;
-  keepOnMorph?: boolean;
+  /** Survives repaints that reach it again (components, atom holes). */
+  keep?: boolean;
   atom?: Atom.Atom<unknown>;
-  host?: Element;
-  holeFiber?: FiberLocal;
-  islandSlot?: IslandSlot;
-}
-interface IslandSlot {
-  type: string | Fragment | ComponentFn;
-  host: Element;
-  updateProps?: (props?: PropBag) => void;
-  unmount?: () => void;
-}
-interface IslandFrame {
-  i: number;
-  slots: (IslandSlot | undefined)[];
-}
-interface ComponentSlot {
-  type: unknown;
-  hole: FiberLocal;
+  fiber?: FiberLocal;
 }
 interface ComponentFrame {
   i: number;
-  slots: ComponentSlot[];
+  slots: {
+    type: unknown;
+    hole: FiberLocal;
+  }[];
 }
 interface FiberLocal {
   root: ParentNode;
@@ -63,18 +58,16 @@ interface FiberLocal {
   closed: boolean;
   hydrate?: boolean;
   keyedHoles?: Map<string, FiberLocal>;
-  /** Counts this fiber's paints; a keyed hole records the last one it was in. */
-  keyedGen?: number;
-  /** On a keyed hole: the parent's `keyedGen` of the last paint that reached it. */
-  keyedSeen?: number;
-  liveEl?: Element;
+  /** Counts this fiber's paints. */
+  gen?: number;
+  /** On a hole: the parent's `gen` of the last paint that reached it. */
+  seen?: number;
   primitiveI?: number;
   primitives?: Atom.Atom<unknown>[];
   /** Releases for the state atoms this fiber keeps in the registry. */
   primitiveHolds?: (() => void)[];
   watchI?: number;
   watchSlots?: WatchSlot[];
-  islandFrame?: IslandFrame;
   componentFrame?: ComponentFrame;
   componentType?: unknown;
   renderSub?: () => void;
@@ -89,7 +82,8 @@ interface FiberLocal {
   handleError?: (error: Error) => void;
   paintFn: (fiber: FiberLocal, view: View) => void;
   paint: (view: View) => void;
-  run: <A, E>(effect: Effect.Effect<A, E, AtomRegistry>, onOk?: (a: A) => void, onErr?: (e: E) => void) => void;
+  /** Fork `effect` in this fiber's scope; returns an interruptor. */
+  run: <A, E>(effect: Effect.Effect<A, E, AtomRegistry>, onOk?: (a: A) => void, onErr?: (e: E) => void) => () => void;
   fail: <E>(e: E) => void;
 }
 declare const getFiber: () => FiberLocal;

package/dist/shared-vpgYXytd.js

@@ -0,0 +1,36 @@
+import * as AsyncResult from "effect/reactivity/AsyncResult";
+
+//#region src/shared.ts
+const KEY_ATTR = "data-ilha-key";
+const SLOT_ATTR = "data-ilha-slot";
+const isString = (value) => typeof value === "string";
+const isFunction = (value) => typeof value === "function";
+/** Non-null, non-array object. */
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Whether `value` carries ilha's runtime brand `key` (set to `1`). */
+const hasBrand = (value, key) => (isObject(value) || isFunction(value)) && Object.getOwnPropertyDescriptor(value, key)?.value === 1;
+/** Arrays and other iterable objects (not strings). */
+const isIterable = (value) => (Array.isArray(value) || isObject(value)) && Symbol.iterator in value;
+const noop = () => {};
+/** Views that paint nothing. */
+const skip = (x) => x === null || x === void 0 || x === true || x === false;
+const KEEP = Symbol("ilha.keep");
+/** Normalize any thrown value into an `Error`. */
+const toError = (e) => e instanceof Error ? e : new Error(String(e));
+/** Unwrap an atom value for painting; `AsyncResult` waits keep the last view. */
+const unwrap = (value, keep) => {
+	if (!AsyncResult.isAsyncResult(value)) return value;
+	if (AsyncResult.isWaiting(value) && keep !== void 0) return KEEP;
+	if (AsyncResult.isFailure(value)) return String(AsyncResult.error(value) ?? "error");
+	const v = AsyncResult.value(value);
+	return v._tag === "Some" ? v.value : "";
+};
+const errorView = (e) => ({
+	$$ilha: 1,
+	children: [toError(e).message],
+	props: { "data-ilha-error": "" },
+	type: "pre"
+});
+
+//#endregion
+export { hasBrand as a, isObject as c, skip as d, toError as f, errorView as i, isString as l, KEY_ATTR as n, isFunction as o, unwrap as p, SLOT_ATTR as r, isIterable as s, KEEP as t, noop as u };

package/dist/snapshot-BDC74QwI.d.ts

@@ -0,0 +1,9 @@
+import { u as JsonText } from "./types-NhEiBvwy.js";
+//#region src/snapshot.d.ts
+/** JSON values accepted in SSR hydrate snapshots. */
+type SnapshotValue = JsonText | SnapshotObject | readonly SnapshotValue[];
+interface SnapshotObject {
+  readonly [key: string]: SnapshotValue | undefined;
+}
+//#endregion
+export { SnapshotValue as t };

package/dist/start-B-e1dG5U.js

@@ -0,0 +1,515 @@
+import { a as hasBrand, f as toError, i as errorView, o as isFunction, u as noop } from "./shared-vpgYXytd.js";
+import * as Atom from "effect/reactivity/Atom";
+import * as Effect from "effect/Effect";
+import * as Equal from "effect/Equal";
+import * as Stream from "effect/Stream";
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import * as Exit from "effect/Exit";
+import * as Registry from "effect/reactivity/AtomRegistry";
+import * as Scope from "effect/Scope";
+
+//#region src/diagnostics.ts
+const DOCS_ORIGIN = "https://ilha.build/errors";
+const CATALOG = {
+	ILHA001: {
+		fix: "Call atom(), watch(), when() and context() at the top level of a component rendered through mount() or renderToString().",
+		message: "A primitive was called with no active component"
+	},
+	ILHA002: {
+		fix: "Call atom() and watch() unconditionally and in the same order on every render; move conditions inside the primitive.",
+		message: "The number of atom/watch slots changed between renders"
+	},
+	ILHA003: {
+		fix: "Pass the value or a prop to the other island, or share state with createContext() and context().",
+		message: "An atom handle was used from a different island"
+	},
+	ILHA004: {
+		fix: "Yield one instruction at a time and let it finish before the generator resumes.",
+		message: "A generator component resumed while an instruction was in flight"
+	},
+	ILHA005: {
+		fix: "Give every keyed component a unique key within its parent component.",
+		message: "Two sibling components use the same key"
+	},
+	ILHA006: {
+		fix: "Render the same component on the server and the client, and keep primitive order stable.",
+		message: "Hydration mismatch, falling back to a full mount"
+	},
+	ILHA007: {
+		fix: "Do not interpolate untrusted text into <script> or <style>; serialize data as JSON with the closing tag escaped.",
+		message: "Unsafe raw text in a <script> or <style> element"
+	}
+};
+/** Error thrown by ilha with a stable `code`, a `fix` hint and a `docs` URL. */
+var IlhaError = class extends Error {
+	code;
+	fix;
+	docs;
+	constructor(code, detail) {
+		const { message, fix } = CATALOG[code];
+		const docs = `${DOCS_ORIGIN}/${code}`;
+		const head = detail ? `${message} (${detail})` : message;
+		super(`[${code}] ${head}. Fix: ${fix} See ${docs}`);
+		this.name = "IlhaError";
+		this.code = code;
+		this.fix = fix;
+		this.docs = docs;
+	}
+};
+/** Build an {@link IlhaError} for `code`. */
+const ilhaError = (code, detail) => new IlhaError(code, detail);
+const warned = /* @__PURE__ */ new Set();
+/** Warn once per `code` + `detail` through `console.warn`. */
+const ilhaWarn = (code, detail) => {
+	const id = `${code}:${detail ?? ""}`;
+	if (warned.has(id)) return;
+	warned.add(id);
+	console.warn(ilhaError(code, detail).message);
+};
+
+//#endregion
+//#region src/runtime.ts
+const stack = [];
+const getActiveFiber = () => stack.findLast((x) => !x.closed);
+const getFiber = () => {
+	const f = getActiveFiber();
+	if (!f) throw ilhaError("ILHA001");
+	return f;
+};
+const withFiber = (fiber, fn) => {
+	stack.push(fiber);
+	try {
+		return fn();
+	} finally {
+		stack.pop();
+	}
+};
+/** Clear render subscriptions and child holes without closing the fiber scope. */
+const clearFiberView = (fiber) => {
+	fiber.renderSub?.();
+	fiber.renderSub = void 0;
+	for (const slot of fiber.watchSlots ?? []) slot?.dispose();
+	for (const release of fiber.primitiveHolds ?? []) release();
+	for (const h of fiber.holes) h.dispose();
+	fiber.watchSlots = [];
+	fiber.watchI = 0;
+	fiber.primitives = void 0;
+	fiber.primitiveI = 0;
+	fiber.primitiveHolds = void 0;
+	fiber.keyedHoles = void 0;
+	fiber.holes = [];
+};
+const closeFiber = (fiber) => {
+	if (fiber.closed) return;
+	fiber.closed = true;
+	fiber.trackRestore?.();
+	fiber.handleError = void 0;
+	clearFiberView(fiber);
+	Effect.runFork(Scope.close(fiber.scope, Exit.void));
+};
+const makeRuntime = (opts) => {
+	const registry = Registry.make();
+	const scope = Scope.makeUnsafe();
+	let pending = 0;
+	let onIdle;
+	const runtime = {
+		begin: () => {
+			pending += 1;
+		},
+		close: () => {
+			onIdle = void 0;
+			Effect.runFork(Scope.close(scope, Exit.void));
+			registry.dispose();
+		},
+		end: () => {
+			pending -= 1;
+			if (pending === 0) onIdle?.();
+		},
+		fork: Effect.runSyncWith(Context.make(Registry.AtomRegistry, registry)),
+		holeSeq: 0,
+		hydrateI: 0,
+		hydrateValues: opts?.hydrate,
+		later: (fn) => {
+			runtime.begin();
+			queueMicrotask(() => {
+				try {
+					fn();
+				} finally {
+					runtime.end();
+				}
+			});
+		},
+		onError: opts?.onError,
+		registry,
+		scope,
+		setIdle: (onReady) => {
+			onIdle = onReady;
+			if (pending === 0) onReady();
+		},
+		ssr: opts?.ssr === true,
+		ssrValues: []
+	};
+	return runtime;
+};
+/** Walk this fiber and ancestors for an error boundary handler. */
+const reportFiberError = (fiber, error) => {
+	for (let f = fiber; f; f = f.parent) if (f.handleError) {
+		f.handleError(error);
+		return true;
+	}
+	return false;
+};
+/**
+* Open a fiber. A failure reports to the nearest `ErrorBoundary`; uncaught,
+* it calls `runtime.onError`, paints the error view, then `onFail`.
+*/
+const makeFiber = (runtime, root, paint, opts) => {
+	const fiber = {
+		closed: false,
+		fail: (e) => {
+			const error = toError(e);
+			if (reportFiberError(fiber, error)) return;
+			runtime.onError?.(error);
+			console.error(error);
+			fiber.paint(errorView(error));
+			opts?.onFail?.();
+		},
+		holes: [],
+		inFlight: false,
+		paint: (view) => paint(fiber, view),
+		paintFn: paint,
+		parent: opts?.parent,
+		registry: runtime.registry,
+		root,
+		run: (effect, onOk, onErr) => {
+			if (fiber.closed) return noop;
+			if (onOk) runtime.begin();
+			const child = runtime.fork(Effect.forkIn(effect.pipe(Effect.onExit((exit) => Effect.sync(() => {
+				if (onOk) runtime.end();
+				if (fiber.closed) return;
+				if (Exit.isSuccess(exit)) {
+					if (onOk) withFiber(fiber, () => onOk(exit.value));
+				} else if (onErr && !Cause.hasInterruptsOnly(exit.cause)) withFiber(fiber, () => onErr(Cause.squash(exit.cause)));
+			}))), fiber.scope, { startImmediately: true }));
+			return () => child.interruptUnsafe();
+		},
+		runtime,
+		scope: Scope.forkUnsafe(runtime.scope)
+	};
+	return fiber;
+};
+
+//#endregion
+//#region src/atom.ts
+/** Wrap an effect as a `yield*`-able, awaitable instruction bound to the active fiber. */
+const instr = (effect) => {
+	const fiber = getFiber();
+	const out = {
+		$$ilhaOp: 1,
+		effect,
+		*[Symbol.iterator]() {
+			return yield out;
+		}
+	};
+	Object.defineProperty(out, "then", { value: async (onOk, onErr) => {
+		const { promise, resolve, reject } = Promise.withResolvers();
+		fiber.run(effect, resolve, reject);
+		let value;
+		try {
+			value = await promise;
+		} catch (error) {
+			if (onErr) return onErr(error);
+			throw error;
+		}
+		return onOk ? onOk(value) : value;
+	} });
+	return out;
+};
+const isInstruction = (x) => hasBrand(x, "$$ilhaOp");
+const isAtomHandle = (x) => hasBrand(x, "$$atom");
+const frames = [];
+let tracking = false;
+/** Read atoms inside `fn` without subscribing the active render. Sync only. */
+const untrack = (fn) => {
+	const prev = tracking;
+	tracking = false;
+	try {
+		return fn();
+	} finally {
+		tracking = prev;
+	}
+};
+const readTracked = (atom, registry) => {
+	if (!tracking) return registry.get(atom);
+	const active = getActiveFiber();
+	const frame = active ? frames.findLast((f) => f.fiber === active) : frames.at(-1);
+	return frame ? frame.get(atom) : registry.get(atom);
+};
+/** Reset per-render slot cursors; warn when the primitive count drifts. */
+const beginPrimitiveFrame = (fiber) => {
+	const used = fiber.primitiveI ?? 0;
+	const slots = fiber.primitives?.length ?? 0;
+	if (used > 0 && used !== slots) ilhaWarn("ILHA002", `${slots} → ${used}`);
+	fiber.primitiveI = 0;
+	fiber.watchI = 0;
+};
+/**
+* Run a render with atom reads tracked into `deps`. An async render keeps its
+* frame open until it settles, so reads after `await` still subscribe.
+*/
+const withTrackGetRun = (fiber, fn, onOk, onErr) => {
+	const deps = /* @__PURE__ */ new Set();
+	const frame = {
+		fiber,
+		get: (a) => {
+			deps.add(a);
+			return fiber.registry.get(a);
+		}
+	};
+	const restore = () => {
+		if (fiber.trackRestore !== restore) return;
+		frames.splice(frames.lastIndexOf(frame), 1);
+		tracking = frames.length > 0;
+		fiber.trackRestore = void 0;
+	};
+	frames.push(frame);
+	tracking = true;
+	fiber.trackRestore = restore;
+	const done = (value) => {
+		restore();
+		onOk({
+			deps,
+			value
+		});
+	};
+	const failed = (failure) => {
+		restore();
+		onErr(toError(failure));
+	};
+	try {
+		const result = withFiber(fiber, fn);
+		if (result instanceof Promise) {
+			const settle = async () => {
+				try {
+					const value = await result;
+					if (!fiber.closed) done(value);
+				} catch (error) {
+					if (!fiber.closed) failed(error);
+				}
+			};
+			settle();
+			return;
+		}
+		done(result);
+	} catch (error) {
+		failed(error);
+	}
+};
+/** Rerun `run` once per microtask when any of `deps` changes. */
+const subscribeRenderDeps = (fiber, deps, run) => {
+	let scheduled = false;
+	const schedule = () => {
+		if (scheduled) return;
+		scheduled = true;
+		const seen = fiber.renderGen;
+		fiber.runtime.later(() => {
+			scheduled = false;
+			if (fiber.renderGen === seen) run();
+		});
+	};
+	const unsubs = [...deps].map((dep) => fiber.registry.subscribe(dep, schedule));
+	return () => {
+		for (const unsub of unsubs) unsub();
+	};
+};
+/** Callable handle over `atom` that reads through the active render's tracking. */
+const wrapHandle = (atom, fiber) => {
+	const { registry } = fiber;
+	const guard = () => {
+		const active = getActiveFiber();
+		if (active && active.registry !== registry) throw ilhaError("ILHA003");
+	};
+	return Object.assign(() => {
+		guard();
+		return readTracked(atom, registry);
+	}, {
+		$$atom: 1,
+		atom,
+		set: (next) => {
+			guard();
+			if (Atom.isWritable(atom)) registry.set(atom, next);
+		},
+		update: (f) => {
+			guard();
+			if (Atom.isWritable(atom)) registry.update(atom, f);
+		}
+	});
+};
+/**
+* Claim the fiber's next primitive slot. A fresh slot is built by `make`,
+* seeded from the hydration snapshot when `snapshotted`; SSR records its
+* value so hydration can restore it in the same order.
+*/
+const useSlot = (snapshotted, make) => {
+	const fiber = getFiber();
+	const { runtime } = fiber;
+	const i = fiber.primitiveI ?? 0;
+	fiber.primitiveI = i + 1;
+	fiber.primitives ??= [];
+	let a = fiber.primitives[i];
+	if (!a) {
+		let hydrated;
+		if (snapshotted && runtime.hydrateValues) {
+			hydrated = runtime.hydrateValues[runtime.hydrateI];
+			runtime.hydrateI += 1;
+		}
+		a = make(fiber, hydrated);
+		fiber.primitives[i] = a;
+		if (snapshotted && runtime.ssr) runtime.ssrValues.push(fiber.registry.get(a));
+	}
+	return wrapHandle(a, fiber);
+};
+/**
+* Keep a component's own state atom in the registry while its fiber lives.
+* The registry drops an atom nothing subscribes to, so state a handler
+* writes and the view never reads would otherwise reset between events.
+*/
+const holdState = (fiber, atom) => {
+	if (!fiber.runtime.ssr) {
+		fiber.primitiveHolds ??= [];
+		fiber.primitiveHolds.push(fiber.registry.mount(atom));
+	}
+	return atom;
+};
+const atom = Object.assign((init, options) => {
+	const plain = !Atom.isAtom(init) && !Effect.isEffect(init) && !Stream.isStream(init);
+	return useSlot(plain && options?.snapshot !== false, (fiber, seed) => {
+		if (Atom.isAtom(init)) return init;
+		if (!plain) return Atom.make(init);
+		const made = Atom.make(seed === void 0 ? init : seed);
+		const eq = options?.equals;
+		return holdState(fiber, eq ? Atom.withEquality(made, eq === "structural" ? Equal.equals : eq) : made);
+	});
+}, { lazy: (init, options) => useSlot(options?.snapshot !== false, (fiber, seed) => holdState(fiber, Atom.make(seed === void 0 ? init() : seed))) });
+const { batch } = Atom;
+
+//#endregion
+//#region src/interpret.ts
+/** Drive a generator component: paint yielded views, run yielded effects. */
+const interpret = (gen, fiber) => {
+	const iter = gen();
+	const resume = (send, thrown) => {
+		if (fiber.closed) return;
+		withFiber(fiber, () => {
+			if (fiber.inFlight) throw ilhaError("ILHA004");
+			let step;
+			try {
+				step = thrown ? iter.throw(thrown) : iter.next(send);
+			} catch (error) {
+				fiber.fail(error);
+				return;
+			}
+			const { value } = step;
+			if (step.done) {
+				if (value !== void 0) fiber.paint(value);
+				return;
+			}
+			const effect = isInstruction(value) ? value.effect : value;
+			if (Effect.isEffect(effect)) {
+				fiber.inFlight = true;
+				fiber.run(effect, (a) => {
+					fiber.inFlight = false;
+					resume(a);
+				}, (e) => {
+					fiber.inFlight = false;
+					resume(void 0, toError(e));
+				});
+				return;
+			}
+			fiber.paint(value);
+			resume();
+		});
+	};
+	resume();
+};
+
+//#endregion
+//#region src/start.ts
+/** Render `fn` into `fiber` and rerender when an atom it read changes. */
+const runSetup = (fiber, fn) => {
+	const render = () => {
+		if (fiber.closed) return;
+		fiber.renderGen = (fiber.renderGen ?? 0) + 1;
+		fiber.runtime.begin();
+		beginPrimitiveFrame(fiber);
+		withTrackGetRun(fiber, fn, ({ value, deps }) => {
+			try {
+				fiber.renderSub?.();
+				fiber.renderSub = void 0;
+				const gen = value;
+				if (isFunction(gen?.next) && isFunction(gen?.throw)) {
+					interpret(() => gen, fiber);
+					return;
+				}
+				if (!fiber.runtime.ssr) fiber.renderSub = subscribeRenderDeps(fiber, deps, render);
+				if (value !== void 0 && !fiber.closed) withFiber(fiber, () => fiber.paint(value));
+			} catch (error) {
+				withFiber(fiber, () => fiber.fail(error));
+			} finally {
+				fiber.runtime.end();
+			}
+		}, (failure) => {
+			withFiber(fiber, () => fiber.fail(failure));
+			fiber.runtime.end();
+		});
+	};
+	try {
+		render();
+	} catch (error) {
+		fiber.fail(error);
+	}
+};
+/** Live root fibers, for `ilha/debug`. Costs one set add/delete per root. */
+const liveRoots = /* @__PURE__ */ new Set();
+/** Called after a paint, a root settling, or a root closing. `ilha/debug` fills it. */
+const rootListeners = /* @__PURE__ */ new Set();
+const notifyRoots = () => {
+	for (const listener of rootListeners) listener();
+};
+/** Open a runtime and root fiber, then run `fn` as the root component. */
+const startRoot = ({ fn, root, paint, ssr, hydrate, snapshot, onError, onIdle, onRuntime }) => {
+	const runtime = makeRuntime({
+		hydrate: snapshot,
+		onError,
+		ssr
+	});
+	onRuntime?.(runtime);
+	const { promise: ready, resolve } = Promise.withResolvers();
+	const settle = () => resolve(null);
+	const fiber = makeFiber(runtime, root, paint, { onFail: settle });
+	fiber.hydrate = hydrate;
+	fiber.componentType = fn;
+	liveRoots.add(fiber);
+	runtime.begin();
+	runtime.setIdle(() => {
+		settle();
+		onIdle?.();
+		notifyRoots();
+	});
+	runSetup(fiber, fn);
+	runtime.end();
+	return {
+		close: () => {
+			closeFiber(fiber);
+			runtime.close();
+			if (liveRoots.delete(fiber)) notifyRoots();
+		},
+		fiber,
+		ready,
+		runtime
+	};
+};
+
+//#endregion
+export { IlhaError as _, startRoot as a, batch as c, untrack as d, wrapHandle as f, makeFiber as g, getFiber as h, runSetup as i, instr as l, closeFiber as m, notifyRoots as n, interpret as o, clearFiberView as p, rootListeners as r, atom as s, liveRoots as t, isAtomHandle as u, ilhaError as v, ilhaWarn as y };