@calmdown/pyxis 1.0.0-rc.2 → 1.0.0-rc.4

package/dist/core-dev.js

@@ -1,3 +1,17 @@
+//#region src/support/common.ts
+function invoke(callback) {
+	return callback.fn(callback.a0, callback.a1, callback.a2);
+}
+function noop() {}
+function rethrow(errors) {
+	if (errors) {
+		if (errors.length > 1) throw new AggregateError(errors);
+		if (errors.length === 1) throw errors[0];
+	}
+}
+const UNIQUE_VALUE = Object.create(null);
+
+//#endregion
 //#region src/dev/ComponentRegistry.ts
 var ComponentRegistry = class {
 	components = /* @__PURE__ */ new Map();
@@ -5,19 +19,29 @@ var ComponentRegistry = class {
 	on(id, fn) {
 		const entry = this.components.get(id);
 		if (!entry) throw new Error(`no component was registered under "${id}"`);
+		fn(entry.component);
 		const listener = {
 			fn,
-			entry
+			entry,
+			isActive: true
 		};
 		if (entry.lt) {
 			entry.lt.ln = listener;
 			listener.lp = entry.lt;
 		} else entry.lh = listener;
 		entry.lt = listener;
-		fn(entry.component);
 		return listener;
 	}
 	off(listener) {
+		if (!listener.isActive) return;
+		listener.isActive = false;
+		if (listener.entry.isDispatching) {
+			listener.entry.needsCleanup = true;
+			return;
+		}
+		this.unlink(listener);
+	}
+	unlink(listener) {
 		const { entry } = listener;
 		if (listener.lp) listener.lp.ln = listener.ln;
 		else if (entry.lh === listener) entry.lh = listener.ln;
@@ -35,7 +59,9 @@ var ComponentRegistry = class {
 		if (!entry) {
 			this.components.set(id, {
 				component,
-				dirty: false
+				dirty: false,
+				isDispatching: false,
+				needsCleanup: false
 			});
 			return;
 		}
@@ -47,18 +73,40 @@ var ComponentRegistry = class {
 		}
 	}
 	update = () => {
+		let errors;
 		this.isPendingUpdate = false;
 		this.components.forEach((entry) => {
 			if (!entry.dirty) return;
+			entry.dirty = false;
+			entry.isDispatching = true;
+			const component = entry.component;
+			const last = entry.lt;
 			let current = entry.lh;
 			let next;
-			while (current) {
-				next = current.ln;
-				current.fn(entry.component);
-				current = next;
+			try {
+				while (current) {
+					if (current.isActive) try {
+						current.fn(component);
+					} catch (ex) {
+						(errors ??= []).push(ex);
+					}
+					if (current === last) break;
+					current = current.ln;
+				}
+			} finally {
+				entry.isDispatching = false;
+				if (entry.needsCleanup) {
+					current = entry.lh;
+					while (current) {
+						next = current.ln;
+						if (!current.isActive) this.unlink(current);
+						current = next;
+					}
+					entry.needsCleanup = false;
+				}
 			}
-			entry.dirty = false;
 		});
+		rethrow(errors);
 	};
 };
 
@@ -81,87 +129,30 @@ var StateRegistry = class {
 };
 
 //#endregion
-//#region src/dev/PyxisHotReload.ts
-globalThis.__PYXIS_HMR__ = {
-	component: new ComponentRegistry(),
-	state: new StateRegistry()
-};
-
-//#endregion
-//#region src/support/common.ts
-function invoke(callback) {
-	return callback.$fn(callback.$a0, callback.$a1);
-}
+//#region src/symbols.ts
+const S_ATOM = Symbol.for("pyxis:atom");
+const S_COMPONENT = Symbol.for("pyxis:component");
+const S_TAG_NAME = Symbol.for("pyxis:tagName");
+const S_DEV_INFO = Symbol.for("pyxis:devInfo");
+const S_RUNTIME = Symbol.for("pyxis:runtime");
 
 //#endregion
-//#region src/data/Lifecycle.ts
-/**
-* Registers a callback to run just after the current Component has mounted.
-*
-* If a teardown callback is returned, it will be run just before the Component unmounts (equivalent
-* to adding a separate `unmounted` block).
-* @see {@link unmounted}
-*/
-function mounted(block, lifecycle = getLifecycle()) {
-	onMounted(lifecycle, {
-		$fn: invokeMountedCallback,
-		$a0: lifecycle,
-		$a1: block
-	});
-}
-/** @internal */
-function onMounted(lifecycle, callback) {
-	(lifecycle.$onMount ??= []).push(callback);
-}
-function invokeMountedCallback(lifecycle, block) {
-	const dispose = block();
-	if (dispose) onUnmounted(lifecycle, { $fn: dispose });
-}
-/**
-* Registers a callback to run once the current Component is just about to unmount.
-* @see {@link mounted}
-*/
-function unmounted(block, lifecycle = getLifecycle()) {
-	onUnmounted(lifecycle, { $fn: block });
-}
-/** @internal */
-function onUnmounted(lifecycle, callback) {
-	(lifecycle.$onUnmount ??= []).push(callback);
-}
-let $currentLifecycle = null;
-/**
-* Gets the Lifecycle of the calling component.
-*/
-function getLifecycle() {
-	if (!$currentLifecycle) throw new Error("Cannot get current lifecycle. Are you creating an Atom outside of a Component?");
-	return $currentLifecycle;
-}
-/** @internal */
-function setLifecycle(lifecycle) {
-	const previous = $currentLifecycle;
-	$currentLifecycle = lifecycle;
-	return previous;
-}
-function withLifecycle(lifecycle, block, arg) {
-	const previousLifecycle = $currentLifecycle;
-	$currentLifecycle = lifecycle;
-	try {
-		return block(arg);
-	} finally {
-		$currentLifecycle = previousLifecycle;
-	}
-}
+//#region src/Runtime.ts
+const runtime = globalThis[S_RUNTIME] ??= {
+	x: {},
+	$extIndex: 0,
+	$currentLifecycle: null,
+	$currentEffect: null,
+	$currentContext: null,
+	$currentContextNew: false
+};
 
 //#endregion
 //#region src/data/Dependency.ts
-function bind(lifecycle, target, block) {
-	link(lifecycle, target, { $fn: block });
-	block();
-}
-/**
-* Links a Dependency to an Atom and Lifecycle.
-* @internal
-*/
+function bind(lifecycle, target, dependency) {
+	link(lifecycle, target, dependency);
+	return invoke(dependency);
+}
 function link(lifecycle, target, dep) {
 	if (target.$dt) {
 		target.$dt.$an = dep;
@@ -175,14 +166,18 @@ function link(lifecycle, target, dep) {
 	} else lifecycle.$dh = dep;
 	dep.$lifecycle = lifecycle;
 	lifecycle.$dt = dep;
+	if (target.$xa && !target.$xn) target.$xn = dep;
+	let update;
+	do {
+		update = target.$notify;
+		if (update && update.$se === update.$lifecycle.$scheduler.$epoch) target.$force = true;
+		target = target.$upstream;
+	} while (target);
 }
-/**
-* Unlinks a Dependency from the Atom and Lifecycle it has been linked to.
-* @internal
-*/
 function unlink(dep) {
 	const target = dep.$target;
 	if (!target) return;
+	if (target.$xa && target.$xn === dep) target.$xn = dep.$an;
 	if (dep.$ap) dep.$ap.$an = dep.$an;
 	else if (target.$dh === dep) target.$dh = dep.$an;
 	if (dep.$an) dep.$an.$ap = dep.$ap;
@@ -199,20 +194,17 @@ function unlink(dep) {
 	dep.$lp = null;
 	dep.$ln = null;
 }
-/**
-* Unlinks all Dependencies managed by the given Lifecycle.
-* @internal
-*/
-function unlinkAll(lifecycle) {
+function teardown(lifecycle) {
 	let dep = lifecycle.$dh;
-	let atom;
+	let target;
 	let next;
 	while (dep) {
-		atom = dep.$target;
+		target = dep.$target;
+		if (target.$xa && target.$xn === dep) target.$xn = dep.$an;
 		if (dep.$ap) dep.$ap.$an = dep.$an;
-		else if (atom.$dh === dep) atom.$dh = dep.$an;
+		else if (target.$dh === dep) target.$dh = dep.$an;
 		if (dep.$an) dep.$an.$ap = dep.$ap;
-		else if (atom.$dt === dep) atom.$dt = dep.$ap;
+		else if (target.$dt === dep) target.$dt = dep.$ap;
 		next = dep.$ln;
 		dep.$lifecycle = null;
 		dep.$target = null;
@@ -224,17 +216,141 @@ function unlinkAll(lifecycle) {
 	}
 	lifecycle.$dh = null;
 	lifecycle.$dt = null;
+	lifecycle.$life += 1;
+	let callbacks;
+	if (callbacks = lifecycle.$onMount) callbacks.length = 0;
+	if (callbacks = lifecycle.$onUnmount) callbacks.length = 0;
+}
+function notify(list) {
+	list.$xa = true;
+	list.$xn = list.$dh;
+	let errors;
+	let current;
+	while (current = list.$xn) {
+		list.$xn = current.$an;
+		try {
+			invoke(current);
+		} catch (ex) {
+			(errors ??= []).push(ex);
+		}
+	}
+	list.$xa = false;
+	list.$xn = null;
+	rethrow(errors);
+}
+
+//#endregion
+//#region src/Component.ts
+/*@__NO_SIDE_EFFECTS__*/
+function component(block) {
+	let devId;
+	devId = arguments[1];
+	devId && runtime.$hmrComponent.upsert(devId, block);
+	return (props, hParent, hBefore, nUsedParent, nRealParent, isBatch) => {
+		const capturedContext = runtime.$currentContext;
+		const capturedContextNew = runtime.$currentContextNew;
+		try {
+			{
+				if (!import.meta.hot || !devId) {
+					mountJsx(__DEV__evalComponent(block, props), hParent, hBefore, nUsedParent, nRealParent, isBatch);
+					return;
+				}
+				const hGroup = fork(hParent, hBefore);
+				let hMarker = hBefore;
+				const unsubscribe = runtime.$hmrComponent.subscribe(devId, (impl) => {
+					unmount(hGroup);
+					mount({
+						...props,
+						[S_COMPONENT]: (() => mountJsx(__DEV__evalComponent(impl, props), hGroup, hMarker, nUsedParent, nRealParent, isBatch))
+					}, hGroup, hMarker, nUsedParent, nRealParent, isBatch);
+				});
+				onceUnmounted(hParent.$ng, { fn: unsubscribe });
+				hMarker = insert(hGroup.adapter.marker(`/${devId}`), null, hParent, hBefore, nUsedParent, isBatch, true);
+				nUsedParent = nRealParent;
+				isBatch = false;
+			}
+		} finally {
+			runtime.$currentContext = capturedContext;
+			runtime.$currentContextNew = capturedContextNew;
+		}
+	};
+}
+function __DEV__evalComponent(block, props) {
+	const prevLifecycle = runtime.$componentEvalLifecycle ?? null;
+	const prevEffect = runtime.$componentEvalEffect ?? null;
+	runtime.$componentEvalLifecycle = runtime.$currentLifecycle;
+	runtime.$componentEvalEffect = runtime.$currentEffect;
+	runtime.$currentContextNew = false;
+	try {
+		return block(props);
+	} finally {
+		runtime.$componentEvalLifecycle = prevLifecycle;
+		runtime.$componentEvalEffect = prevEffect;
+	}
+}
+function __DEV__assertIsDirectComponentCode(fn) {
+	if (!runtime.$componentEvalLifecycle || runtime.$componentEvalLifecycle !== runtime.$currentLifecycle) throw new Error(`"${fn}" can only be used directly within components.`);
+	if (runtime.$componentEvalEffect !== runtime.$currentEffect) throw new Error(`"${fn}" cannot be used within effects or derivations.`);
+}
+
+//#endregion
+//#region src/data/Lifecycle.ts
+function mounted(block, lifecycle) {
+	if (lifecycle === void 0) __DEV__assertIsDirectComponentCode(mounted.name);
+	lifecycle ??= getLifecycle();
+	onceMounted(lifecycle, {
+		fn: invokeMountedCallback,
+		a0: lifecycle,
+		a1: block
+	});
+}
+function onceMounted(lifecycle, callback) {
+	(lifecycle.$onMount ??= []).push(callback);
+}
+function invokeMountedCallback(lifecycle, block, arg) {
+	const life = lifecycle.$life;
+	const dispose = block(arg);
+	if (dispose) {
+		if (lifecycle.$life > life) {
+			dispose();
+			return;
+		}
+		onceUnmounted(lifecycle, { fn: dispose });
+	}
+}
+function unmounted(block, lifecycle) {
+	if (lifecycle === void 0) __DEV__assertIsDirectComponentCode(unmounted.name);
+	onceUnmounted(lifecycle ?? getLifecycle(), { fn: block });
+}
+function onceUnmounted(lifecycle, callback) {
+	(lifecycle.$onUnmount ??= []).push(callback);
+}
+function getLifecycle() {
+	if (!runtime.$currentLifecycle) throw new Error("Cannot get current lifecycle. Are you creating an Atom outside of a Component?");
+	return runtime.$currentLifecycle;
+}
+function withLifecycle(lifecycle, block, a0, a1, a2) {
+	const prevLifecycle = runtime.$currentLifecycle;
+	runtime.$currentLifecycle = lifecycle;
+	try {
+		return block(a0, a1, a2);
+	} finally {
+		runtime.$currentLifecycle = prevLifecycle;
+	}
 }
 
 //#endregion
 //#region src/data/Scheduler.ts
-/** @internal */
+/*@__NO_SIDE_EFFECTS__*/
 function createScheduler(tick) {
-	let isPending = false;
+	const effects = [];
 	const ticks = [];
-	const tocks = [];
+	let tocks = [];
+	let tocksParked = [];
+	let isPending = false;
 	const scheduler = {
 		$epoch: 1,
+		$onEffect: effects,
 		$onTick: ticks,
 		$onTock: tocks,
 		$scheduleTick: () => {
@@ -244,179 +360,227 @@ function createScheduler(tick) {
 		}
 	};
 	const update = () => {
-		try {
-			let index = 0;
-			let callback;
-			for (; index < ticks.length; index += 1) {
-				callback = ticks[index];
-				if (callback.$life === callback.$lifecycle.$life) {
-					callback.$re = scheduler.$epoch;
+		const prevLifecycle = runtime.$currentLifecycle;
+		const epoch = scheduler.$epoch;
+		let errors;
+		let effectIndex = 0;
+		let tickIndex = 0;
+		let callback;
+		do {
+			while (tickIndex < ticks.length) {
+				callback = ticks[tickIndex++];
+				callback.$se = 0;
+				if (callback.$life === callback.$lifecycle.$life) try {
+					runtime.$currentLifecycle = callback.$lifecycle;
 					invoke(callback);
+				} catch (ex) {
+					(errors ??= []).push(ex);
 				}
 			}
-			for (index = 0; index < tocks.length; index += 1) {
-				callback = tocks[index];
-				if (callback.$life === callback.$lifecycle.$life) {
-					callback.$re = scheduler.$epoch;
+			if (effectIndex < effects.length) {
+				callback = effects[effectIndex++];
+				callback.$se = 0;
+				if (callback.$life === callback.$lifecycle.$life) try {
+					runtime.$currentLifecycle = callback.$lifecycle;
 					invoke(callback);
+				} catch (ex) {
+					(errors ??= []).push(ex);
 				}
 			}
-		} finally {
-			isPending = false;
-			ticks.length = 0;
-			tocks.length = 0;
-			scheduler.$epoch += 1;
+		} while (tickIndex < ticks.length || effectIndex < effects.length);
+		effects.length = 0;
+		ticks.length = 0;
+		scheduler.$onTock = tocksParked;
+		scheduler.$epoch = epoch + 1;
+		const { length } = tocks;
+		let tockIndex = 0;
+		for (; tockIndex < length; tockIndex += 1) {
+			callback = tocks[tockIndex];
+			if (callback.$se === epoch) callback.$se = 0;
+			if (callback.$life === callback.$lifecycle.$life) try {
+				runtime.$currentLifecycle = callback.$lifecycle;
+				invoke(callback);
+			} catch (ex) {
+				(errors ??= []).push(ex);
+			}
 		}
+		const tmp = tocksParked;
+		tocksParked = tocks;
+		tocks = tmp;
+		tocksParked.length = 0;
+		isPending = false;
+		if (ticks.length || tocks.length) scheduler.$scheduleTick();
+		runtime.$currentLifecycle = prevLifecycle;
+		rethrow(errors);
 	};
 	return scheduler;
 }
 function schedule(lifecycle, queue, callback) {
-	const scheduler = lifecycle.$scheduler;
-	if (callback.$se === scheduler.$epoch) {
-		if (callback.$re === scheduler.$epoch) throw new Error("Refusing to re-schedule an update after it already executed, as it may cause an infinite loop. Are you mutating an Atom inside an effect that observes it?");
-		return;
-	}
 	callback.$lifecycle = lifecycle;
 	callback.$life = lifecycle.$life;
+	const scheduler = lifecycle.$scheduler;
+	if (callback.$se === scheduler.$epoch) return;
 	callback.$se = scheduler.$epoch;
 	queue.push(callback);
 	scheduler.$scheduleTick();
 }
-/** @internal */
+function scheduleEffect(lifecycle, callback) {
+	schedule(lifecycle, lifecycle.$scheduler.$onEffect, callback);
+}
+function tick(block, lifecycle = getLifecycle()) {
+	schedule(lifecycle, lifecycle.$scheduler.$onTick, { fn: block });
+}
 function scheduleTick(lifecycle, callback) {
 	schedule(lifecycle, lifecycle.$scheduler.$onTick, callback);
 }
-/**
-* Runs a block of code on the next tick of the scheduler, synchronized with other updates. If a
-* tick is not currently pending, a new one is scheduled.
-*/
-function tick(block, lifecycle = getLifecycle()) {
-	schedule(lifecycle, lifecycle.$scheduler.$onTick, { $fn: block });
+function tock(block, lifecycle = getLifecycle()) {
+	schedule(lifecycle, lifecycle.$scheduler.$onTock, { fn: block });
 }
-/** @internal */
 function scheduleTock(lifecycle, callback) {
 	schedule(lifecycle, lifecycle.$scheduler.$onTock, callback);
 }
-/**
-* Runs a block of code after the next tick of the scheduler, once all regular updates finished.
-* If a tick is not currently pending, a new one is scheduled.
-*/
-function tock(block, lifecycle = getLifecycle()) {
-	schedule(lifecycle, lifecycle.$scheduler.$onTock, { $fn: block });
-}
 
 //#endregion
 //#region src/data/Effect.ts
-/**
-* Creates an Effect - a block of logic executed each time any of the Atoms accessed within it
-* change. The block is first synchronously executed when the Effect is created.
-*
-* If a teardown callback is returned, it will be run before the next effect re-run, or on component
-* unmount.
-*/
 function effect(block, lifecycle = getLifecycle()) {
 	runEffect({
 		$lifecycle: lifecycle,
 		$life: lifecycle.$life,
 		$block: block,
-		$react: scheduleEffect,
+		$react: scheduleReaction$1,
 		$cycle: 0
 	});
 }
-function scheduleEffect(effect, cycle) {
+function scheduleReaction$1(effect, cycle) {
 	if (effect.$cycle > cycle) {
-		unlink(this);
+		unlinkEffectDep(effect, this);
 		return;
 	}
-	scheduleTick(effect.$lifecycle, effect.$resolve ??= {
-		$fn: runEffect,
-		$a0: effect
+	scheduleEffect(effect.$lifecycle, effect.$resolve ??= {
+		fn: runEffect,
+		a0: effect
 	});
 }
 function runEffect(effect) {
-	if (effect.$life !== effect.$lifecycle.$life) return;
-	effect.$dispose?.();
+	const lifecycle = effect.$lifecycle;
+	if (effect.$life !== lifecycle.$life) return;
+	teardownEffect(effect);
+	if (effect.$life !== lifecycle.$life) return;
 	effect.$dispose = resolve(effect);
+	if (effect.$life !== lifecycle.$life) {
+		teardownEffect(effect);
+		return;
+	}
 	if (!effect.$tracksUnmount && effect.$dispose) {
 		effect.$tracksUnmount = true;
-		onUnmounted(effect.$lifecycle, {
-			$fn: teardownEffect,
-			$a0: effect
+		onceUnmounted(lifecycle, {
+			fn: teardownEffect,
+			a0: effect
 		});
 	}
 }
 function teardownEffect(effect) {
-	effect.$dispose?.();
+	const fn = effect.$dispose;
+	if (!fn) return;
+	const prevLifecycle = runtime.$currentLifecycle;
+	runtime.$currentLifecycle = effect.$lifecycle;
 	effect.$dispose = null;
+	try {
+		fn();
+	} finally {
+		runtime.$currentLifecycle = prevLifecycle;
+	}
 }
-let $currentEffect = null;
-/**
-* Resolves an Effect: runs user logic tracking accessed Atoms and updating dependency links.
-* Returned value is forwarded.
-* @internal
-*/
 function resolve(effect) {
-	effect.$deps ??= /* @__PURE__ */ new WeakMap();
-	effect.$cycle += 1;
-	const previousEffect = $currentEffect;
-	const previousLifecycle = setLifecycle(effect.$lifecycle);
-	$currentEffect = effect;
+	effect.$rc = 0;
+	const cycle = effect.$cycle += 1;
+	const prevLifecycle = runtime.$currentLifecycle;
+	const prevEffect = runtime.$currentEffect;
+	const prevTail = effect.$et;
+	runtime.$currentLifecycle = effect.$lifecycle;
+	runtime.$currentEffect = effect;
 	try {
 		return effect.$block();
 	} finally {
-		setLifecycle(previousLifecycle);
-		$currentEffect = previousEffect;
+		runtime.$currentLifecycle = prevLifecycle;
+		runtime.$currentEffect = prevEffect;
+		if (cycle > 1 && effect.$rc > 0 && prevTail) {
+			let current = effect.$eh;
+			let next;
+			while (current) {
+				next = current.$en;
+				if (current.a1 < cycle) unlinkEffectDep(effect, current);
+				if (current === prevTail) break;
+				current = next;
+			}
+		}
 	}
 }
-/**
-* Reports an Atom has been accessed. Does nothing if not within an Effect.
-* @internal
-*/
+function unlinkEffectDep(effect, dep) {
+	if (dep.$ep) dep.$ep.$en = dep.$en;
+	else if (effect.$eh === dep) effect.$eh = dep.$en;
+	if (dep.$en) dep.$en.$ep = dep.$ep;
+	else if (effect.$et === dep) effect.$et = dep.$ep;
+	dep.$ep = null;
+	dep.$en = null;
+	effect.$deps?.delete(dep.$target);
+	unlink(dep);
+}
 function reportAccess(atom) {
-	if (!$currentEffect || $currentEffect.$life !== $currentEffect.$lifecycle.$life) return;
-	let dep = $currentEffect.$deps.get(atom);
+	const currentEffect = runtime.$currentEffect;
+	if (!currentEffect || currentEffect.$life !== currentEffect.$lifecycle.$life) return;
+	const deps = currentEffect.$deps;
+	let dep;
+	let count = 0;
+	if (deps) dep = deps.get(atom);
+	else {
+		dep = currentEffect.$eh;
+		while (dep) {
+			count += 1;
+			if (dep.$target === atom) break;
+			dep = dep.$en;
+		}
+	}
 	if (dep) {
-		dep.$a1 = $currentEffect.$cycle;
-		if (!dep.$lifecycle) link($currentEffect.$lifecycle, atom, dep);
+		dep.a1 = currentEffect.$cycle;
+		if (!dep.$lifecycle) link(currentEffect.$lifecycle, atom, dep);
 	} else {
-		link($currentEffect.$lifecycle, atom, dep = {
-			$fn: $currentEffect.$react,
-			$a0: $currentEffect,
-			$a1: $currentEffect.$cycle
+		link(currentEffect.$lifecycle, atom, dep = {
+			fn: currentEffect.$react,
+			a0: currentEffect,
+			a1: currentEffect.$cycle
 		});
-		$currentEffect.$deps.set(atom, dep);
+		if (deps) deps.set(atom, dep);
+		else if (count >= 5) {
+			const map = currentEffect.$deps = /* @__PURE__ */ new WeakMap();
+			let current = currentEffect.$eh;
+			do
+				map.set(current.$target, current);
+			while (current = current.$en);
+			map.set(atom, dep);
+		}
+		if (currentEffect.$et) {
+			currentEffect.$et.$en = dep;
+			dep.$ep = currentEffect.$et;
+		} else currentEffect.$eh = dep;
+		currentEffect.$et = dep;
+		currentEffect.$rc += 1;
 	}
 }
-/**
-* Runs a block of code removed from any effects. Accessing atoms within this block will be ignored
-* by any effect that may otherwise be observing this code.
-*/
-function noEffect(block) {
-	const previousEffect = $currentEffect;
-	$currentEffect = null;
+function noEffect(block, a0, a1, a2) {
+	const prevEffect = runtime.$currentEffect;
+	runtime.$currentEffect = null;
 	try {
-		return block();
+		return block(a0, a1, a2);
 	} finally {
-		$currentEffect = previousEffect;
+		runtime.$currentEffect = prevEffect;
 	}
 }
-/**
-* Asserts that the current code is not running within an effect block.
-* Only used in development; In production, this function should be removed by the bundler.
-*/
-function __DEV__assertNotEffect() {
-	if ($currentEffect && $currentEffect.$lifecycle === getLifecycle() && $currentEffect.$life === $currentEffect.$lifecycle.$life) throw new Error("Attempt to create an Atom inside an effect block.");
-}
 
 //#endregion
 //#region src/data/Atom.ts
-/**
-* Pyxis Atom type guard marker.
-*/
-const S_ATOM = Symbol.for("pyxis:atom");
 function atomOf(initialValue, lifecycle = getLifecycle()) {
-	__DEV__assertNotEffect();
-	if (isAtom(initialValue)) return initialValue;
+	if (isAtom(initialValue)) initialValue = initialValue.get();
 	const atom = {
 		[S_ATOM]: true,
 		$value: initialValue,
@@ -424,13 +588,14 @@ function atomOf(initialValue, lifecycle = getLifecycle()) {
 		$lifecycle: lifecycle,
 		$lastValue: initialValue,
 		get: getValue$1,
-		set: setValue$2
+		set: setValue$1
 	};
 	{
 		const devId = arguments[2];
 		atom.$devId = devId;
-		globalThis.__PYXIS_HMR__.state.restore(lifecycle, devId, (value) => {
+		runtime.$hmrState.restore(lifecycle, devId, (value) => {
 			atom.$value = value;
+			atom.$lastValue = value;
 		});
 	}
 	return atom;
@@ -438,10 +603,10 @@ function atomOf(initialValue, lifecycle = getLifecycle()) {
 function getValue$1() {
 	return this.$value;
 }
-function setValue$2(value) {
+function setValue$1(value) {
 	if (Object.is(this.$value, value)) return false;
 	this.$value = value;
-	globalThis.__PYXIS_HMR__.state.preserve(this.$lifecycle, this.$devId, value);
+	runtime.$hmrState.preserve(this.$lifecycle, this.$devId, value);
 	return true;
 }
 function isAtom(input) {
@@ -459,96 +624,88 @@ function peek(input) {
 	return input;
 }
 function write(input, value, force = false) {
-	if (isAtom(input)) {
-		if (input.set(value) || force) {
+	if (!isAtom(input)) return input;
+	if (input.set(value) || force) {
+		if (input.$dh) {
 			input.$force ||= force;
-			scheduleTick(input.$lifecycle, input.$notify ??= {
-				$fn: notify$1,
-				$a0: input
-			});
-		}
-		return input.get();
+			scheduleAtomNotification(input);
+		} else if (input.$tracksValue) return input.$lastValue = input.get();
 	}
-	return input;
+	return input.get();
 }
 function update(input, transform, force = false) {
-	if (isAtom(input)) {
-		if (input.set(transform(input.get())) || force) {
+	if (!isAtom(input)) return input;
+	const value = transform(input.get());
+	if (input.set(value) || force) {
+		if (input.$dh) {
 			input.$force ||= force;
-			scheduleTick(input.$lifecycle, input.$notify ??= {
-				$fn: notify$1,
-				$a0: input
-			});
-		}
-		return input.get();
-	}
-	return input;
-}
-/**
-* Notifies the dependencies of an Atom.
-* @internal
-*/
-function notify$1(input) {
-	if (input.$tracksValue) {
-		const newValue = input.get();
-		if (Object.is(input.$lastValue, newValue) && !input.$force) return;
-		input.$lastValue = newValue;
-	}
-	input.$force = false;
-	let current = input.$dh;
-	let next;
-	while (current) {
-		next = current.$an;
-		invoke(current);
-		current = next;
+			scheduleAtomNotification(input);
+		} else if (input.$tracksValue) return input.$lastValue = input.get();
 	}
+	return input.get();
 }
-
-//#endregion
-//#region src/component/Text.ts
-function Text(jsx, hParent, nUsedParent, _nRealParent, nBefore, isBatch) {
-	const { adapter } = hParent.$ng;
-	let node = null;
-	if (isAtom(jsx)) bind(hParent.$ng, jsx, () => {
-		node = adapter.text(jsx.get()?.toString() ?? "", node);
+function scheduleAtomNotification(atom) {
+	scheduleTick(atom.$lifecycle, atom.$notify ??= {
+		fn: notifyAtomObservers,
+		a0: atom
 	});
-	else node = adapter.text(jsx.toString(), null);
-	insert(node, null, hParent, nUsedParent, nBefore, isBatch);
+}
+function notifyAtomObservers(atom) {
+	if (atom.$tracksValue) {
+		const newValue = atom.get();
+		if (!atom.$force && Object.is(atom.$lastValue, newValue)) return;
+		atom.$lastValue = newValue;
+	}
+	atom.$force = false;
+	notify(atom);
 }
 
 //#endregion
 //#region src/Renderer.ts
-/** @internal */
-const S_COMPONENT = Symbol.for("pyxis:component");
-/** @internal */
+/*@__NO_SIDE_EFFECTS__*/
 function createRenderer(adapter, extensions) {
-	const hGroup = {
+	const hRoot = {
 		adapter,
-		mounted: false,
+		mounted: true,
 		$isGroup: true,
-		$scheduler: createScheduler(adapter.tick),
+		$scheduler: /* @__PURE__ */ createScheduler(adapter.tick),
 		$extensions: extensions,
+		$context: null,
+		$depth: 0,
 		$life: 1,
-		$pg: null,
 		$ng: null,
-		unmount: () => unmount(hGroup),
+		$ph: null,
+		unmount: destroy,
 		mount: (nRoot, jsx) => {
-			hGroup.$nn = nRoot;
-			const isBatch = Boolean(adapter.batch);
-			const nParent = isBatch ? adapter.batch() : nRoot;
-			mount(jsx, hGroup, nParent, nRoot, null, isBatch);
-			if (isBatch) adapter.insert(nParent, nRoot, null);
+			const hGroup = fork(hRoot, null, null);
+			try {
+				willMount(hGroup, () => {
+					const isBatch = !!adapter.batch;
+					const nParent = isBatch ? adapter.batch() : nRoot;
+					mount(jsx, hGroup, null, nParent, nRoot, isBatch);
+					if (isBatch) {
+						adapter.insert(nParent, nRoot, null);
+						flush(hGroup);
+					}
+				})();
+				return hGroup;
+			} catch (ex) {
+				destroy(hGroup, [ex]);
+			}
 		}
 	};
-	hGroup.$ng = hGroup;
-	globalThis.__PYXIS_ROOT__ ??= hGroup;
-	return hGroup;
+	hRoot.$ng = hRoot;
+	return hRoot;
+}
+function destroy(hGroup, errors) {
+	if (!hGroup.$isUnmounting && !deferUnmount(hGroup, true)) {
+		errors = doUnmount(hGroup, errors);
+		untrack(hGroup);
+		hGroup.$ph = null;
+	}
+	rethrow(errors);
 }
-/**
-* Creates a sub-group within the provided MountingGroup. Needed whenever a subtree needs to mount
-* or unmount dynamically.
-*/
-function fork(hParent, hBefore = null) {
+function fork(hParent, hBefore = null, context = runtime.$currentContext) {
 	const ng = hParent.$ng;
 	const hGroup = {
 		adapter: ng.adapter,
@@ -556,20 +713,19 @@ function fork(hParent, hBefore = null) {
 		$isGroup: true,
 		$scheduler: ng.$scheduler,
 		$extensions: ng.$extensions,
+		$context: context,
+		$depth: 0,
 		$life: 1,
-		$pg: ng,
-		$ng: null
+		$ng: null,
+		$ph: hParent
 	};
 	hGroup.$ng = hGroup;
 	hGroup.$nn = hParent.$nn;
 	track(hGroup, hParent, hBefore);
 	return hGroup;
 }
-/**
-* Adds a HNode to the hierarchy.
-*/
 function track(hNode, hParent, hBefore = null) {
-	if (hBefore?.$pg === hParent) if (hBefore.$hp) {
+	if (hBefore?.$ph === hParent) if (hBefore.$hp) {
 		hNode.$hp = hBefore.$hp;
 		hNode.$hn = hBefore;
 		hBefore.$hp.$hn = hNode;
@@ -587,293 +743,309 @@ function track(hNode, hParent, hBefore = null) {
 		} else hParent.$hh = hNode;
 		hParent.$ht = hNode;
 	}
+	hNode.$ph = hParent;
 }
-/**
-* Removes a HNode from the tracking hierarchy.
-*/
 function untrack(hNode) {
 	if (hNode.$hp) hNode.$hp.$hn = hNode.$hn;
-	else if (hNode.$pg?.$hh === hNode) hNode.$pg.$hh = hNode.$hn;
+	else if (hNode.$ph?.$hh === hNode) hNode.$ph.$hh = hNode.$hn;
 	if (hNode.$hn) hNode.$hn.$hp = hNode.$hp;
-	else if (hNode.$pg?.$ht === hNode) hNode.$pg.$ht = hNode.$hp;
+	else if (hNode.$ph?.$ht === hNode) hNode.$ph.$ht = hNode.$hp;
 	hNode.$hp = null;
 	hNode.$hn = null;
 }
-/**
-* Mounts a MountingGroup to the specified location in the node tree. If the group is already
-* mounted (i.e. its native nodes are already rendered somewhere), it is moved to the new location
-* without re-mounting Pyxis components.
-*
-* Note that for successfully moving a group within the tree, you should first `untrack` the group,
-* then re-`track` it to the new location and only then call `mount` to commit the move.
-* @see {@link track}
-* @see {@link untrack}
-*/
-function mount(jsx, hGroup, nUsedParent, nRealParent, nBefore, isBatch) {
-	if (hGroup.mounted) {
-		reinsertNodes(hGroup, nUsedParent, nBefore);
-		return;
-	}
-	const previousLifecycle = setLifecycle(hGroup);
+function willMount(hGroup, block) {
+	return (a0, a1, a2) => {
+		const mounts = runtime.$mounts ??= [];
+		if (++hGroup.$depth === 1) mounts.push(hGroup);
+		let errors;
+		try {
+			return block(a0, a1, a2);
+		} catch (ex) {
+			(errors ??= []).push(ex);
+		} finally {
+			if (--hGroup.$depth === 0) mounts.pop();
+			finishMount(errors);
+		}
+	};
+}
+function mount(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch) {
+	if (hParent.mounted) return;
+	const mounts = runtime.$mounts ??= [];
+	if (++hParent.$depth === 1) mounts.push(hParent);
+	const prevLifecycle = runtime.$currentLifecycle;
+	const prevEffect = runtime.$currentEffect;
+	const prevContext = runtime.$currentContext;
+	const prevContextNew = runtime.$currentContextNew;
+	runtime.$currentLifecycle = hParent;
+	runtime.$currentContext = hParent.$context;
+	runtime.$currentContextNew = false;
+	runtime.$currentEffect = null;
+	let errors;
 	try {
-		mountJsx(jsx, hGroup, nUsedParent, nRealParent, nBefore, isBatch);
-	} finally {
-		setLifecycle(previousLifecycle);
-		hGroup.mounted = true;
-		if (hGroup.$pg?.mounted !== false) notifyMounted(hGroup);
-	}
-}
-/**
-* Only used by `mount`, do not call directly.
-*
-* Recursively (dept-first) runs components' `mounted` callbacks.
-* @see {@link mount}
-* @internal
-*/
-function notifyMounted(hNode) {
+		mountJsx(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch);
+		hParent.$canMount = true;
+		if (!isBatch) flush(hParent);
+	} catch (ex) {
+		(errors ??= []).push(ex);
+	}
+	runtime.$currentLifecycle = prevLifecycle;
+	runtime.$currentEffect = prevEffect;
+	runtime.$currentContext = prevContext;
+	runtime.$currentContextNew = prevContextNew;
+	if (--hParent.$depth === 0) mounts.pop();
+	if (errors?.length && !deferUnmount(hParent)) errors = doUnmount(hParent, errors);
+	finishMount(errors);
+}
+function finishMount(errors) {
+	if (!runtime.$mounts.length) {
+		const pending = runtime.$unmounts;
+		runtime.$unmounts = null;
+		if (pending) {
+			const { length } = pending;
+			let index = 0;
+			let request;
+			for (; index < length; index += 1) {
+				request = pending[index];
+				if (request.$life !== request.$group.$life) continue;
+				errors = doUnmount(request.$group, errors);
+				if (request.$destroy) {
+					untrack(request.$group);
+					request.$group.$ph = null;
+				}
+			}
+		}
+	}
+	rethrow(errors);
+}
+function deferUnmount(hGroup, isDestroy = false) {
+	const mounts = runtime.$mounts;
+	if (!mounts?.length) return false;
+	const lifecycle = runtime.$currentLifecycle;
+	const { length } = mounts;
+	let index = 0;
+	let active;
+	for (; index < length; index += 1) {
+		active = mounts[index];
+		if (ancestorContainsNode(hGroup, active) || lifecycle?.$isGroup && ancestorContainsNode(active, lifecycle) && ancestorContainsNode(hGroup, lifecycle)) break;
+	}
+	if (index === length) return false;
+	const pending = runtime.$unmounts ??= [];
+	const pendingLength = pending.length;
+	let pendingIndex = 0;
+	let request;
+	for (; pendingIndex < pendingLength; pendingIndex += 1) {
+		request = pending[pendingIndex];
+		if (request.$group === hGroup && request.$life === hGroup.$life) {
+			request.$destroy ||= isDestroy;
+			return true;
+		}
+	}
+	pending.push({
+		$group: hGroup,
+		$life: hGroup.$life,
+		$destroy: isDestroy
+	});
+	return true;
+}
+function ancestorContainsNode(hAncestor, hNode) {
+	while (hNode) {
+		if (hNode === hAncestor) return true;
+		hNode = hNode.$ph;
+	}
+	return false;
+}
+function flush(hGroup) {
+	if (hGroup.$ph?.$ng.mounted !== false) {
+		const prevLifecycle = runtime.$currentLifecycle;
+		const prevEffect = runtime.$currentEffect;
+		runtime.$currentEffect = null;
+		const mounts = runtime.$mounts ??= [];
+		if (++hGroup.$depth === 1) mounts.push(hGroup);
+		const errors = doFlush(hGroup, void 0);
+		runtime.$currentLifecycle = prevLifecycle;
+		runtime.$currentEffect = prevEffect;
+		if (--hGroup.$depth === 0) mounts.pop();
+		finishMount(errors);
+	}
+}
+function doFlush(hNode, errors) {
 	let current = hNode.$hh;
 	while (current) {
-		notifyMounted(current);
+		errors = doFlush(current, errors);
 		current = current.$hn;
 	}
-	let callbacks;
-	if (hNode.$isGroup && hNode.mounted && (callbacks = hNode.$onMount)) {
-		const previousLifecycle = setLifecycle(hNode);
-		try {
-			callbacks.forEach(invoke);
-		} finally {
+	if (hNode.$isGroup && hNode.$canMount && !hNode.mounted) {
+		hNode.mounted = true;
+		if (hNode.$onMount?.length) {
+			const callbacks = hNode.$onMount;
+			let index = 0;
+			runtime.$currentLifecycle = hNode;
+			for (; index < callbacks.length; index += 1) try {
+				invoke(callbacks[index]);
+			} catch (ex) {
+				(errors ??= []).push(ex);
+			}
 			callbacks.length = 0;
-			setLifecycle(previousLifecycle);
 		}
 	}
+	return errors;
 }
-/**
-* Only used by `mount`, do not call directly.
-*
-* Re-inserts native nodes of the given group to the specified location in the native tree. Only
-* moves the uppermost nodes - any children should move implicitly with them.
-* @see {@link mount}
-* @internal
-*/
-function reinsertNodes(hGroup, nParent, nBefore) {
-	const { adapter } = hGroup;
-	let current = hGroup.$hh;
+function reinsertNodes(hParent, hBefore, nParent) {
+	if (!hParent.mounted) return;
+	const { adapter } = hParent;
+	const nAnchor = hBefore?.$nn ?? null;
+	let current = hParent.$hh;
 	while (current) {
-		if (current.$isNative) adapter.insert(current.$nn, nParent, nBefore);
-		else reinsertNodes(current, nParent, nBefore);
+		if (current.$isNative) adapter.insert(current.$nn, nParent, nAnchor);
+		else reinsertNodes(current, hBefore, nParent);
 		current = current.$hn;
 	}
 }
-function unmount(hNode, top = true) {
+function unmount(hGroup, errors) {
+	if (deferUnmount(hGroup)) {
+		rethrow(errors);
+		return;
+	}
+	errors = doUnmount(hGroup, errors);
+	rethrow(errors);
+}
+function doUnmount(hGroup, errors) {
+	const prevLifecycle = runtime.$currentLifecycle;
+	const prevEffect = runtime.$currentEffect;
+	runtime.$currentEffect = null;
+	errors = unmountNode(hGroup, errors, true);
+	runtime.$currentLifecycle = prevLifecycle;
+	runtime.$currentEffect = prevEffect;
+	return errors;
+}
+function unmountNode(hNode, errors, top) {
+	if (hNode.$isUnmounting) return errors;
+	hNode.$isUnmounting = true;
 	if (hNode.$isGroup) {
-		if (hNode.mounted) {
-			let callbacks;
-			if (callbacks = hNode.$onUnmount) {
-				const previousLifecycle = setLifecycle(hNode);
-				try {
-					callbacks.forEach(invoke);
-				} finally {
-					callbacks.length = 0;
-					setLifecycle(previousLifecycle);
-				}
+		if (hNode.$onUnmount?.length) {
+			const callbacks = hNode.$onUnmount;
+			let index = 0;
+			runtime.$currentLifecycle = hNode;
+			for (; index < callbacks.length; index += 1) try {
+				invoke(callbacks[index]);
+			} catch (ex) {
+				(errors ??= []).push(ex);
 			}
-			hNode.mounted = false;
-			hNode.$life += 1;
 		}
-		unlinkAll(hNode);
+		teardown(hNode);
+		hNode.mounted = false;
+		hNode.$canMount = false;
 	}
 	const { adapter } = hNode.$ng;
 	let current = hNode.$hh;
 	let next;
 	while (current) {
 		if (current.$isNative && top) {
-			adapter.remove(current.$nn);
-			unmount(current, false);
-		} else unmount(current, top);
+			try {
+				adapter.remove(current.$nn);
+			} catch (ex) {
+				(errors ??= []).push(ex);
+			}
+			errors = unmountNode(current, errors, false);
+		} else errors = unmountNode(current, errors, top);
 		next = current.$hn;
 		current.$hp = null;
 		current.$hn = null;
+		current.$ph = null;
 		current = next;
 	}
 	hNode.$hh = null;
 	hNode.$ht = null;
+	hNode.$isUnmounting = false;
+	return errors;
 }
-/**
-* Mounts components described by the JsxResult to the specified location in the node tree.
-*/
-function mountJsx(jsx, hParent, nUsedParent, nRealParent, nBefore, isBatch) {
+function mountJsx(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch) {
 	switch (typeof jsx) {
 		case "object":
 			if (jsx === null) break;
 			if (Array.isArray(jsx)) {
-				const { length } = jsx;
-				let index = 0;
-				for (; index < length; index += 1) mountJsx(jsx[index], hParent, nUsedParent, nRealParent, nBefore, isBatch);
+				const text = mountJsxArray(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch);
+				if (text) mountStaticText(text, hParent, hBefore, nUsedParent, isBatch);
 				break;
 			}
-			if (!isAtom(jsx)) {
-				jsx[S_COMPONENT]?.(jsx, hParent, nUsedParent, nRealParent, nBefore, isBatch);
-				break;
-			}
-		case "string":
+			if (isAtom(jsx)) mountDynamicText(jsx, hParent, hBefore, nUsedParent, isBatch);
+			else jsx[S_COMPONENT]?.(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch);
+			break;
+		case "string": if (jsx === "") break;
 		case "number":
-		case "boolean":
 		case "bigint":
-			Text(jsx, hParent, nUsedParent, nRealParent, nBefore, isBatch);
+			mountStaticText("" + jsx, hParent, hBefore, nUsedParent, isBatch);
 			break;
 	}
 }
-/**
-* Inserts a native node and adds it to the tracking hierarchy. Necessary to preserve render order.
-* Should only be called by component handlers!
-*/
-function insert(nNode, children, hParent, nUsedParent, nBefore, isBatch) {
-	let hNative = hParent;
-	if (hNative.$isGroup) {
-		let hBefore = null;
-		if (nBefore) {
-			let current = hParent.$ht;
-			while (current) {
-				if (current.$isNative && current.$nn === nBefore) {
-					hBefore = current;
+function mountJsxArray(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch, text = "") {
+	const { length } = jsx;
+	let index = 0;
+	let item;
+	for (; index < length; index += 1) {
+		item = jsx[index];
+		switch (typeof item) {
+			case "string":
+			case "number":
+			case "bigint":
+				text += item;
+				break;
+			case "boolean": break;
+			default:
+				if (item === null || item === void 0) break;
+				if (Array.isArray(item)) {
+					text = mountJsxArray(item, hParent, hBefore, nUsedParent, nRealParent, isBatch, text);
 					break;
 				}
-				current = current.$hp;
-			}
+				if (text) {
+					mountStaticText(text, hParent, hBefore, nUsedParent, isBatch);
+					text = "";
+				}
+				mountJsx(item, hParent, hBefore, nUsedParent, nRealParent, isBatch);
+				break;
 		}
-		track(hNative = {
-			$isNative: true,
-			$pg: hNative,
-			$ng: hNative,
-			$nn: nNode
-		}, hParent, hBefore);
 	}
-	mountJsx(children, hNative, nNode, nNode, null, isBatch);
-	hParent.$ng.adapter.insert(nNode, nUsedParent, nBefore);
+	return text;
 }
-
-//#endregion
-//#region src/component/Fragment.ts
-function Fragment(jsx, hParent, nUsedParent, nRealParent, nBefore, isBatch) {
-	mountJsx(jsx.children, hParent, nUsedParent, nRealParent, nBefore, isBatch);
+function mountStaticText(text, hParent, hBefore, nUsedParent, isBatch) {
+	insert(hParent.$ng.adapter.text(text, null), null, hParent, hBefore, nUsedParent, isBatch);
 }
-
-//#endregion
-//#region src/data/Context.ts
-function createContext() {
-	let $symbol = Symbol();
-	{
-		const devId = arguments[0];
-		$symbol = globalThis.__PYXIS_HMR__.state.restore(createContext, devId) ?? $symbol;
-		globalThis.__PYXIS_HMR__.state.preserve(createContext, devId, $symbol);
-	}
-	return { $symbol };
-}
-let $currentContainer = null;
-let $isNewContainer = false;
-/** @internal */
-function getContextContainer() {
-	return $currentContainer;
-}
-/** @internal */
-function setContextContainer(container) {
-	$currentContainer = container;
-	$isNewContainer = false;
-}
-/**
-* Gets a consumer Atom for the given Context. This atom will be read-only.
-* @see {@link host}
-*/
-function consumerOf(context) {
-	__DEV__assertNotEffect();
-	const { $symbol } = context;
-	let ptr = $currentContainer;
-	let atom;
-	while (ptr && !(atom = ptr[$symbol])) ptr = ptr.$parent;
-	return atom ?? null;
+function mountDynamicText(atom, hParent, hBefore, nUsedParent, isBatch) {
+	insert(bind(hParent.$ng, atom, {
+		fn: setBoundText,
+		a0: hParent.$ng.adapter,
+		a1: null
+	}), null, hParent, hBefore, nUsedParent, isBatch);
 }
-function host(context, defaultValue) {
-	__DEV__assertNotEffect();
-	if (!$isNewContainer || !$currentContainer) {
-		$isNewContainer = true;
-		$currentContainer = { $parent: $currentContainer };
-	}
-	const lifecycle = getLifecycle();
-	{
-		const devId = arguments[2];
-		globalThis.__PYXIS_HMR__.state.restore(lifecycle, devId, (value) => {
-			defaultValue = value;
-		});
-	}
-	const localAtom = {
-		[S_ATOM]: true,
-		$lifecycle: lifecycle,
-		$tracksValue: true,
-		$value: defaultValue,
-		get: getLocalValue,
-		set: setValue$1
-	};
-	if (defaultValue === void 0) {
-		const ancestorAtom = consumerOf(context);
-		if (ancestorAtom) {
-			localAtom.get = getAncestorValue;
-			localAtom.$ancestor = ancestorAtom;
-			link(lifecycle, ancestorAtom, localAtom.$dep = {
-				$fn: notify$1,
-				$a0: localAtom
-			});
-		}
-	}
-	localAtom.$devId = arguments[2];
-	if (Object.hasOwn($currentContainer, context.$symbol)) throw new Error("Component declares multiple hosts of the same Context.");
-	$currentContainer[context.$symbol] = localAtom;
-	return localAtom;
-}
-function getAncestorValue() {
-	return this.$ancestor.get();
+function setBoundText(adapter, node) {
+	const value = this.$target.get();
+	return this.a1 = adapter.text(value === null || value === void 0 || typeof value === "boolean" ? "" : "" + value, node);
 }
-function getLocalValue() {
-	return this.$value;
+function insert(nNode, children, hParent, hBefore, nUsedParent, isBatch, forceTrack = false) {
+	let hNative = hParent;
+	if (hNative.$isGroup || forceTrack) track(hNative = {
+		$isNative: true,
+		$ng: hParent.$ng,
+		$nn: nNode,
+		$ph: hParent
+	}, hParent, hBefore);
+	mountJsx(children, hNative, null, nNode, nNode, isBatch);
+	hParent.$ng.adapter.insert(nNode, nUsedParent, isBatch ? null : hBefore?.$nn ?? null);
+	return hNative === hParent ? null : hNative;
 }
-function setValue$1(value) {
-	let oldValue;
-	if (this.$ancestor) {
-		oldValue = this.$ancestor.get();
-		unlink(this.$dep);
-		this.$dep = null;
-		this.$ancestor = null;
-		this.get = getLocalValue;
-	} else oldValue = this.$value;
-	this.$value = value;
-	globalThis.__PYXIS_HMR__.state.preserve(this.$lifecycle, this.$devId, value);
-	return !Object.is(oldValue, value);
+
+//#endregion
+//#region src/component/Fragment.ts
+function Fragment(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch) {
+	mountJsx(jsx.children, hParent, hBefore, nUsedParent, nRealParent, isBatch);
 }
 
 //#endregion
 //#region src/data/ListDelta.ts
-/** @internal */
 const LC_CHANGE = 1;
-/** @internal */
 const LC_INSERT = 2;
-/** @internal */
 const LC_REMOVE = 3;
-/** @internal */
 const LC_CLEAR = 4;
-let ChangeKind = /* @__PURE__ */ function(ChangeKind) {
-	ChangeKind[ChangeKind["Change"] = 1] = "Change";
-	ChangeKind[ChangeKind["Insert"] = 2] = "Insert";
-	ChangeKind[ChangeKind["Remove"] = 3] = "Remove";
-	ChangeKind[ChangeKind["Clear"] = 4] = "Clear";
-	return ChangeKind;
-}({});
-/** @internal */
-function createDelta() {
-	return {
-		changes: [],
-		lengthChange: 0
-	};
-}
-/** @internal */
 function itemChanged({ changes: $changes }, at, oldItem, newItem) {
 	const ci = binarySearch($changes, at, latest);
 	if (ci < 0) $changes.splice(~ci, 0, {
@@ -900,7 +1072,6 @@ function itemChanged({ changes: $changes }, at, oldItem, newItem) {
 		}
 	}
 }
-/** @internal */
 function itemInserted(delta, at, item) {
 	const { changes: $changes } = delta;
 	let ci = binarySearch($changes, at, earliest);
@@ -923,16 +1094,18 @@ function itemInserted(delta, at, item) {
 				});
 				break;
 			case 3:
-				current.kind = 1;
-				current.newItem = item;
+				if (Object.is(current.oldItem, item)) $changes.splice(ci--, 1);
+				else {
+					current.kind = 1;
+					current.newItem = item;
+				}
 				break;
 		}
 	}
 	const { length } = $changes;
 	while (++ci < length) $changes[ci].index += 1;
-	delta.lengthChange += 1;
+	delta.relSize += 1;
 }
-/** @internal */
 function itemRemoved(delta, at, item) {
 	const { changes: $changes } = delta;
 	let ci = binarySearch($changes, at, latest);
@@ -964,29 +1137,29 @@ function itemRemoved(delta, at, item) {
 	}
 	const { length } = $changes;
 	while (++ci < length) $changes[ci].index -= 1;
-	delta.lengthChange -= 1;
+	delta.relSize -= 1;
 }
-/** @internal */
 function listCleared(delta, count) {
-	const { changes: $changes } = delta;
-	$changes.length = 0;
-	$changes.push({
+	delta.changes.length = 0;
+	delta.relSize -= count;
+	if (delta.relSize === 0) return;
+	delta.changes.push({
 		kind: 4,
 		index: -1
 	});
-	delta.lengthChange -= count;
 }
-/** @internal */
 function listSynced(delta, oldState, newState, eq) {
 	let index = 0;
 	let N = oldState.length;
 	let M = newState.length;
 	while (index < N && index < M && eq(oldState[index], newState[index])) index += 1;
-	if (index === N && index === M) return;
+	if (index === N && index === M) return false;
 	while (N > index && M > index && eq(oldState[N - 1], newState[M - 1])) {
 		N -= 1;
 		M -= 1;
 	}
+	N -= index;
+	M -= index;
 	const Z = (Math.min(N, M) + 1) * 2;
 	const L = N + M;
 	const state = {
@@ -1012,6 +1185,7 @@ function listSynced(delta, oldState, newState, eq) {
 		$oye: -1
 	};
 	let offset = 0;
+	let hasChanges = false;
 	let rs, re, is, ie, r, i;
 	do {
 		myersDiff(state);
@@ -1026,13 +1200,18 @@ function listSynced(delta, oldState, newState, eq) {
 			is = state.$pys;
 			ie = state.$pye;
 		} else break;
-		for (r = rs; r < re; r += 1) itemRemoved(delta, rs + offset, oldState[r]);
+		for (r = rs; r < re; r += 1) {
+			itemRemoved(delta, rs + offset, oldState[r]);
+			hasChanges = true;
+		}
 		for (i = is; i < ie; i += 1) {
 			itemInserted(delta, rs + offset, newState[i]);
+			hasChanges = true;
 			offset += 1;
 		}
 		offset -= re - rs;
 	} while (state.$c < 2);
+	return hasChanges;
 }
 const latest = (changes, index, mid, _min, max) => {
 	let i = mid;
@@ -1176,53 +1355,54 @@ function myersDiff(state) {
 
 //#endregion
 //#region src/data/ProxyAtom.ts
-/**
-* Creates a ProxyAtom bound to the provided initial value. If it is an Atom, the proxy will mirror
-* it, otherwise it will be a read-only atom with a static value until rebound.
-*/
 function proxyOf(initialValue, lifecycle = getLifecycle()) {
-	__DEV__assertNotEffect();
 	const self = {
 		[S_ATOM]: true,
 		$lifecycle: lifecycle,
-		use,
-		get: getStaticValue
+		use
 	};
-	self.use(initialValue, false);
+	self.use(initialValue, true);
 	return self;
 }
-function use(value, canNotify = true) {
-	if (this.$dep) unlink(this.$dep);
-	const oldValue = this.get();
+function use(value, isInit = false) {
+	if (value === this) throw new Error("ProxyAtom cannot proxy itself");
+	const upstream = this.$upstream;
+	if (upstream && upstream === value) return;
+	let shouldNotify = true;
 	if (isAtom(value)) {
-		this.$bound = value;
-		this.$value = null;
-		this.get = getBoundValue;
-		this.set = setBoundValue;
+		if (!upstream || isInit) {
+			this.$value = null;
+			this.$tracksValue = false;
+			this.$lastValue = null;
+			this.get = getUpstreamValue$1;
+			this.set = setUpstreamValue;
+		} else unlink(this.$dep);
+		this.$upstream = value;
 		link(this.$lifecycle, value, this.$dep ??= {
-			$fn: notify$1,
-			$a0: this
+			fn: scheduleAtomNotification,
+			a0: this
 		});
 	} else {
-		this.$bound = null;
+		if (upstream || isInit) {
+			this.$upstream = null;
+			this.$tracksValue = true;
+			this.$lastValue = UNIQUE_VALUE;
+			this.get = getStaticValue;
+			this.set = setStaticValue;
+			if (!isInit) unlink(this.$dep);
+		} else shouldNotify = !Object.is(this.$value, value);
 		this.$value = value;
-		this.get = getStaticValue;
-		this.set = setStaticValue;
 	}
-	if (canNotify && !Object.is(oldValue, this.get())) scheduleTick(this.$lifecycle, this.$notify ??= {
-		$fn: notify$1,
-		$a0: this
-	});
+	if (this.$dh) {
+		if (shouldNotify) scheduleAtomNotification(this);
+	} else if (this.$tracksValue) this.$lastValue = value;
 }
-function getBoundValue() {
-	return this.$bound.get();
+function getUpstreamValue$1() {
+	return this.$upstream.get();
 }
-function setBoundValue(value) {
-	const atom = this.$bound;
-	if (atom.set(value)) scheduleTick(atom.$lifecycle, atom.$notify ??= {
-		$fn: notify$1,
-		$a0: atom
-	});
+function setUpstreamValue(value) {
+	const atom = this.$upstream;
+	if (atom.set(value) && atom.$dh) scheduleAtomNotification(atom);
 	return false;
 }
 function getStaticValue() {
@@ -1231,16 +1411,9 @@ function getStaticValue() {
 function setStaticValue() {
 	return false;
 }
-const EMPTY_SOURCE = {};
-/**
-* Copies select keys from a data object into a new object where values are all wrapped in
-* ProxyAtoms and can be updated later.
-* @see {@link updateProxy}
-* @internal
-**/
 function createProxy(lifecycle, data, keys) {
-	const source = isObject(data) ? data : EMPTY_SOURCE;
-	const proxy = {};
+	const source = isObject(data) ? data : UNIQUE_VALUE;
+	const proxy = Object.create(null);
 	const { length } = keys;
 	let index = 0;
 	let key;
@@ -1251,14 +1424,8 @@ function createProxy(lifecycle, data, keys) {
 	proxy.proxied = data;
 	return proxy;
 }
-/**
-* Updates the values proxied by a previously created proxy object. The keys array must be the same
-* as was used during creation (or a subset).
-* @see {@link createProxy}
-* @internal
-**/
 function updateProxy(proxy, data, keys) {
-	const source = isObject(data) ? data : EMPTY_SOURCE;
+	const source = isObject(data) ? data : UNIQUE_VALUE;
 	const { length } = keys;
 	proxy.proxied = data;
 	let index = 0;
@@ -1272,31 +1439,69 @@ function isObject(value) {
 	return value !== null && typeof value === "object";
 }
 
+//#endregion
+//#region src/support/template.ts
+function Template(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch) {
+	mountJsx(jsx.t?.(jsx.d), hParent, hBefore, nUsedParent, nRealParent, isBatch);
+}
+const REUSED_JSX = { [S_COMPONENT]: Template };
+function mountTemplate(template, data, hParent, hBefore, nUsedParent, nRealParent, isBatch) {
+	REUSED_JSX.t = template;
+	REUSED_JSX.d = data;
+	try {
+		mount(REUSED_JSX, hParent, hBefore, nUsedParent, nRealParent, isBatch);
+	} finally {
+		REUSED_JSX.t = null;
+		REUSED_JSX.d = null;
+	}
+}
+
 //#endregion
 //#region src/component/Iterator.ts
-function Iterator(jsx, hParent, nUsedParent, nRealParent, nBefore, isBatch) {
+function Iterator(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch) {
 	const source = jsx.source;
 	const proxyKeys = jsx.proxy;
 	const isProxy = proxyKeys !== void 0;
 	const template = jsx.children[0];
-	const hGroup = fork(hParent);
-	const context = getContextContainer();
+	const hGroup = fork(hParent, hBefore);
 	const { adapter } = hGroup;
-	const shouldBatch = Boolean(adapter.batch);
+	const shouldBatch = !!adapter.batch;
 	const nListEndMarker = adapter.marker("/Iterator");
-	let items;
-	let skipDelta = Boolean(source.$delta);
-	const onDelta = () => {
-		if (skipDelta) {
-			skipDelta = false;
+	let renderedItems;
+	let hListEndMarker = null;
+	const renderInitialItems = (initItems, hInitBefore, nInitParent, initIsBatch) => {
+		let nBatchParent = nInitParent;
+		const isLocalBatch = shouldBatch && !initIsBatch && initItems.length > 0;
+		const isAnyBatch = isLocalBatch || initIsBatch;
+		if (isLocalBatch) nBatchParent = adapter.batch();
+		let errors;
+		renderedItems = initItems.map((data) => {
+			const item = createItem(hGroup, hListEndMarker ?? hInitBefore, nBatchParent, isAnyBatch, data, proxyKeys);
+			try {
+				mountTemplate(template, item.$data, item, hInitBefore, nBatchParent, nRealParent, isAnyBatch);
+			} catch (ex) {
+				(errors ??= []).push(ex);
+			}
+			return item;
+		});
+		if (isLocalBatch) {
+			adapter.insert(nBatchParent, nInitParent, hInitBefore?.$nn ?? null);
+			errors = flushItems(renderedItems, 0, renderedItems.length, errors);
+		}
+		rethrow(errors);
+	};
+	source.delta(willMount(hGroup, (delta) => {
+		if (!renderedItems) {
+			renderInitialItems(delta.snapshot, hListEndMarker, nRealParent, false);
 			return;
 		}
-		const { changes, lengthChange } = source.$delta;
+		const { changes, relSize } = delta;
 		const cMax = changes.length;
-		const iMax = items.length + lengthChange;
-		const newItems = new Array(iMax);
-		const pending = [];
-		let recycled = [];
+		const iMax = renderedItems.length + relSize;
+		let newItems = renderedItems;
+		let errors;
+		let pending;
+		let recycled;
 		let item;
 		let inserted = 0;
 		let ci = 0;
@@ -1307,196 +1512,348 @@ function Iterator(jsx, hParent, nUsedParent, nRealParent, nBefore, isBatch) {
 		let tmp;
 		let isLocalBatch = false;
 		let nBatchParent = nRealParent;
-		let nBatchBefore = null;
+		let batchStart = 0;
 		for (; ci < cMax; ci += 1) {
 			change = changes[ci];
-			while (ni < change.index) newItems[ni++] = items[oi++];
+			if (newItems === renderedItems) if (change.kind === 1) oi = ni = change.index;
+			else {
+				newItems = new Array(iMax);
+				oi = ni = 0;
+			}
+			while (ni < change.index) newItems[ni++] = renderedItems[oi++];
 			switch (change.kind) {
 				case 1:
-					item = newItems[ni++] = items[oi++];
+					item = newItems[ni++] = renderedItems[oi++];
 					if (isProxy) updateProxy(item.$data, change.newItem, proxyKeys);
 					else {
-						unmount(item);
-						ref = items[oi]?.$marker ?? nListEndMarker;
-						insert(item.$marker, null, item, nRealParent, ref, false);
-						setContextContainer(context);
-						mount(withLifecycle(item, template, item.$data = change.newItem), item, nRealParent, nRealParent, ref, false);
+						try {
+							unmount(item);
+						} catch (ex) {
+							(errors ??= []).push(ex);
+						}
+						ref = renderedItems[oi]?.$marker ?? hListEndMarker;
+						try {
+							mountTemplate(template, item.$data = change.newItem, item, ref, nRealParent, nRealParent, false);
+						} catch (ex) {
+							(errors ??= []).push(ex);
+						}
 					}
 					break;
 				case 2:
-					if (!isProxy || inserted < lengthChange) {
-						item = newItems[ni++] = fork(hGroup, items[oi]);
-						item.$marker = adapter.marker("IteratorItem");
-						item.$data = isProxy ? createProxy(item, change.newItem, proxyKeys) : change.newItem;
+					if (!isProxy || inserted < relSize) {
+						ref = renderedItems[oi]?.$marker ?? hListEndMarker;
+						if (!isLocalBatch) {
+							if (shouldBatch) {
+								isLocalBatch = true;
+								batchStart = ni;
+								nBatchParent = adapter.batch();
+							}
+						}
 						inserted += 1;
-						ref = items[oi]?.$marker ?? nListEndMarker;
-						if (!isLocalBatch) if (shouldBatch) {
-							isLocalBatch = true;
-							nBatchParent = adapter.batch();
-							nBatchBefore = null;
-						} else nBatchBefore = ref;
-						insert(item.$marker, null, item, nBatchParent, nBatchBefore, isLocalBatch);
-						setContextContainer(context);
-						mount(withLifecycle(item, template, item.$data), item, nBatchParent, nRealParent, nBatchBefore, isLocalBatch);
-						if (isLocalBatch && (inserted >= lengthChange || !(tmp = changes[ci + 1]) || tmp.kind !== 2 || tmp.index !== ni)) {
-							adapter.insert(nBatchParent, nRealParent, ref);
+						item = newItems[ni++] = createItem(hGroup, renderedItems[oi]?.$marker ?? hListEndMarker, nBatchParent, isLocalBatch, change.newItem, proxyKeys);
+						try {
+							mountTemplate(template, item.$data, item, ref, nBatchParent, nRealParent, isLocalBatch);
+						} catch (ex) {
+							(errors ??= []).push(ex);
+						}
+						if (isLocalBatch && (inserted >= relSize || !(tmp = changes[ci + 1]) || tmp.kind !== 2 || tmp.index !== ni)) {
+							adapter.insert(nBatchParent, nRealParent, ref.$nn);
+							errors = flushItems(newItems, batchStart, ni, errors);
 							nBatchParent = nRealParent;
 							isLocalBatch = false;
 						}
-					} else pending.push({
-						$index: ni++,
-						$item: change.newItem
-					});
+					} else {
+						(pending ??= []).push(ci);
+						ni += 1;
+					}
 					break;
 				case 3:
-					item = items[oi++];
-					if (isProxy) recycled.push(item);
-					else unmount(item);
-					untrack(item);
+					item = renderedItems[oi++];
+					if (isProxy) {
+						(recycled ??= []).push(item);
+						untrackItem(item);
+					} else try {
+						destroyItem(item);
+					} catch (ex) {
+						(errors ??= []).push(ex);
+					}
 					break;
 				case 4:
 					if (isProxy) {
-						recycled = items;
-						recycled.forEach(untrack);
-						oi = items.length;
-					} else while (oi < items.length) {
-						item = items[oi++];
-						unmount(item);
-						untrack(item);
+						recycled = renderedItems;
+						recycled.forEach(untrackItem);
+						oi = renderedItems.length;
+					} else while (oi < renderedItems.length) {
+						item = renderedItems[oi++];
+						try {
+							destroyItem(item);
+						} catch (ex) {
+							(errors ??= []).push(ex);
+						}
 					}
 					break;
 			}
 		}
-		while (ni < iMax) newItems[ni++] = items[oi++];
-		let pi = pending.length - 1;
-		let ri = recycled.length - 1;
+		if (newItems !== renderedItems) while (ni < iMax) newItems[ni++] = renderedItems[oi++];
+		let pi = pending ? pending.length - 1 : -1;
+		let ri = recycled ? recycled.length - 1 : -1;
 		while (pi >= 0) {
-			tmp = pending[pi--];
-			item = newItems[tmp.$index] = recycled[ri--];
-			updateProxy(item.$data, tmp.$item, proxyKeys);
-			track(item, hGroup, ref = newItems[tmp.$index + 1]);
-			setContextContainer(context);
-			mount(withLifecycle(item, template, item.$data), item, nRealParent, nRealParent, ref?.$marker ?? nListEndMarker, false);
+			tmp = changes[pending[pi--]];
+			item = newItems[tmp.index] = recycled[ri--];
+			updateProxy(item.$data, tmp.newItem, proxyKeys);
+			ref = newItems[tmp.index + 1];
+			track(item.$marker, hGroup, ref?.$marker ?? hListEndMarker);
+			track(item, hGroup, ref?.$marker ?? hListEndMarker);
+			adapter.insert(item.$marker.$nn, nRealParent, ref?.$marker.$nn ?? nListEndMarker);
+			reinsertNodes(item, ref?.$marker ?? hListEndMarker, nRealParent);
 		}
 		while (ri >= 0) {
 			item = recycled[ri--];
-			unmount(item);
-			untrack(item);
-		}
-		items = newItems;
-	};
-	link(hGroup, source, { $fn: onDelta });
-	{
-		let nBatchParent = nUsedParent;
-		let nBatchBefore = nBefore;
-		const isLocalBatch = shouldBatch && !isBatch && source.$items.length > 0;
-		if (isLocalBatch) {
-			nBatchParent = adapter.batch();
-			nBatchBefore = null;
+			try {
+				destroyItem(item);
+			} catch (ex) {
+				(errors ??= []).push(ex);
+			}
 		}
-		const isAnyBatch = isLocalBatch || isBatch;
-		items = source.$items.map((data) => {
-			const item = fork(hGroup);
-			item.$marker = adapter.marker("IteratorItem");
-			item.$data = isProxy ? createProxy(item, data, proxyKeys) : data;
-			insert(item.$marker, null, item, nBatchParent, nBatchBefore, isAnyBatch);
-			mount(withLifecycle(item, template, item.$data), item, nBatchParent, nRealParent, nBatchBefore, isAnyBatch);
-			return item;
-		});
-		insert(nListEndMarker, null, hGroup, nBatchParent, nBatchBefore, isAnyBatch);
-		if (isLocalBatch) adapter.insert(nBatchParent, nUsedParent, nBefore);
+		renderedItems = newItems;
+		rethrow(errors);
+	}), hGroup);
+	if (!source.dirty()) source.stable((snapshot) => {
+		renderInitialItems(snapshot, hBefore, nUsedParent, isBatch);
+	});
+	hListEndMarker = insert(nListEndMarker, null, hGroup, hBefore, nUsedParent, isBatch, true);
+	mount(null, hGroup, hBefore, nUsedParent, nRealParent, isBatch);
+}
+function flushItems(items, start, end, errors) {
+	let index = start;
+	for (; index < end; index += 1) try {
+		flush(items[index]);
+	} catch (ex) {
+		(errors ??= []).push(ex);
+	}
+	return errors;
+}
+function createItem(hParent, hBefore, nParent, isBatch, data, proxyKeys) {
+	const marker = insert(hParent.adapter.marker("IteratorItem"), null, hParent, hBefore, nParent, isBatch, true);
+	const item = fork(hParent, hBefore, hParent.$context);
+	item.$marker = marker;
+	item.$data = proxyKeys !== void 0 ? createProxy(item, data, proxyKeys) : data;
+	return item;
+}
+function untrackItem(item) {
+	untrack(item.$marker);
+	untrack(item);
+}
+function destroyItem(item) {
+	try {
+		destroy(item);
+	} finally {
+		const marker = item.$marker;
+		item.adapter.remove(marker.$nn);
+		untrack(marker);
+		marker.$ph = null;
 	}
-	mount(null, hGroup, nUsedParent, nRealParent, nBefore, isBatch);
 }
 
 //#endregion
 //#region src/component/Native.ts
-const RE_EXT = /^([^:]+?):(.+)$/;
-/** @internal */
-const S_TAG_NAME = Symbol.for("pyxis:tagName");
-function Native(jsx, hParent, nUsedParent, _nRealParent, nBefore, isBatch) {
+function Native(jsx, hParent, hBefore, nUsedParent, _nRealParent, isBatch) {
 	const hGroup = hParent.$ng;
 	const { adapter, $extensions } = hGroup;
 	const nNode = adapter.element(jsx[S_TAG_NAME]);
 	let name;
-	let match;
+	let index;
 	let value;
+	let target;
 	for (name in jsx) {
-		match = RE_EXT.exec(name);
+		index = name.indexOf(":");
 		value = jsx[name];
-		if (match) $extensions[match[1]]?.set(nNode, match[2], value, hGroup);
-		else if (name !== "children") if (isAtom(value)) {
-			const prop = name;
-			const atom = value;
-			bind(hGroup, atom, () => {
-				adapter.set(nNode, prop, atom.get());
-			});
-		} else adapter.set(nNode, name, value);
+		if (index === 0) if (target = runtime.x[name]) target.$ext.set(nNode, target.$prop, value, hGroup);
+		else throw new Error(`invalid reserved prop "${name}"`);
+		else if (index > 0) $extensions[name.slice(0, index)]?.set(nNode, name.slice(index + 1), value, hGroup);
+		else if (name !== "children") {
+			if (isAtom(value)) {
+				link(hGroup, value, {
+					fn: setBoundProp,
+					a0: adapter,
+					a1: nNode,
+					a2: name
+				});
+				value = value.get();
+			}
+			adapter.set(nNode, name, value);
+		}
 	}
-	insert(nNode, jsx.children, hParent, nUsedParent, nBefore, isBatch);
+	insert(nNode, jsx.children, hParent, hBefore, nUsedParent, isBatch);
+	return nNode;
+}
+function setBoundProp(adapter, node, prop) {
+	adapter.set(node, prop, this.$target.get());
 }
 
 //#endregion
 //#region src/component/Show.ts
-function Show(jsx, hParent, nUsedParent, nRealParent, nBefore, isBatch) {
-	const when = jsx.when;
+function Show(props, hParent, hBefore, nUsedParent, nRealParent, isBatch) {
+	const when = props.when;
 	if (!isAtom(when) && when === false) return;
-	const { children, data } = jsx;
-	const proxyKeys = jsx.proxy;
-	const template = Object.hasOwn(jsx, "data") ? children[0] : () => children;
+	const { children, data } = props;
+	const proxyKeys = props.proxy;
+	const template = Object.hasOwn(props, "data") ? children[0] : () => children;
 	let dataOrProxy = data;
 	if (proxyKeys) if (isAtom(data)) {
 		dataOrProxy = createProxy(hParent.$ng, data.get(), proxyKeys);
-		link(hParent.$ng, data, { $fn: () => {
-			updateProxy(dataOrProxy, data.get(), proxyKeys);
-		} });
+		link(hParent.$ng, data, {
+			fn: updateShowProxy,
+			a0: dataOrProxy,
+			a1: data,
+			a2: proxyKeys
+		});
 	} else dataOrProxy = createProxy(hParent.$ng, data, proxyKeys);
 	const adapter = hParent.$ng.adapter;
-	const shouldBatch = Boolean(adapter.batch);
+	const shouldBatch = !!adapter.batch;
 	if (!(isAtom(when) || isAtom(template) || !proxyKeys && isAtom(data))) {
 		const isLocalBatch = shouldBatch && !isBatch;
 		let nBatchParent = nUsedParent;
-		let nBatchBefore = nBefore;
-		if (isLocalBatch) {
-			nBatchParent = adapter.batch();
-			nBatchBefore = null;
-		}
-		mountJsx(template(dataOrProxy), hParent, nBatchParent, nRealParent, nBatchBefore, isLocalBatch || isBatch);
-		if (isLocalBatch) adapter.insert(nBatchParent, nUsedParent, nBefore);
+		if (isLocalBatch) nBatchParent = adapter.batch();
+		mountJsx(template(dataOrProxy), hParent, hBefore, nBatchParent, nRealParent, isLocalBatch || isBatch);
+		if (isLocalBatch) adapter.insert(nBatchParent, nUsedParent, hBefore?.$nn ?? null);
 		return;
 	}
-	const hGroup = fork(hParent);
-	const context = getContextContainer();
-	let nMarker = nBefore;
-	effect(() => {
+	const hGroup = fork(hParent, hBefore);
+	const dispose = () => unmount(hGroup);
+	let hMarker = hBefore;
+	effect(willMount(hGroup, () => {
 		if (read(when) === false) return;
 		const isLocalBatch = shouldBatch && !isBatch;
 		let nBatchParent = nUsedParent;
-		let nBatchBefore = nMarker;
+		if (isLocalBatch) nBatchParent = adapter.batch();
+		mountTemplate(read(template), read(dataOrProxy), hGroup, hMarker, nBatchParent, nRealParent, isLocalBatch || isBatch);
 		if (isLocalBatch) {
-			nBatchParent = adapter.batch();
-			nBatchBefore = null;
+			adapter.insert(nBatchParent, nUsedParent, hMarker?.$nn ?? null);
+			try {
+				flush(hGroup);
+			} catch (ex) {
+				unmount(hGroup, [ex]);
+			}
 		}
-		setContextContainer(context);
-		mount(withLifecycle(hGroup, read(template), read(dataOrProxy)), hGroup, nBatchParent, nRealParent, nBatchBefore, isLocalBatch || isBatch);
-		if (isLocalBatch) adapter.insert(nBatchParent, nUsedParent, nMarker);
-		return () => unmount(hGroup);
-	}, hParent.$ng);
-	nMarker = adapter.marker("/Show");
-	insert(nMarker, null, hParent, nUsedParent, nBefore, isBatch);
+		return dispose;
+	}), hParent.$ng);
+	hMarker = insert(adapter.marker("/Show"), null, hParent, hBefore, nUsedParent, isBatch, true);
 	isBatch = false;
 	nUsedParent = nRealParent;
 }
+function updateShowProxy(proxy, source, keys) {
+	updateProxy(proxy, source.get(), keys);
+}
+
+//#endregion
+//#region src/data/Context.ts
+/*@__NO_SIDE_EFFECTS__*/
+function contextOf() {
+	{
+		const devId = arguments[0];
+		const $symbol = runtime.$hmrState.restore(contextOf, devId) ?? Symbol();
+		runtime.$hmrState.preserve(contextOf, devId, $symbol);
+		return { $symbol };
+	}
+}
+function host(context, defaultValue, lifecycle = getLifecycle()) {
+	__DEV__assertIsDirectComponentCode(host.name);
+	if (!runtime.$currentContextNew || !runtime.$currentContext) {
+		runtime.$currentContextNew = true;
+		runtime.$currentContext = { $parent: runtime.$currentContext };
+	}
+	let isUndefined = defaultValue === void 0;
+	{
+		const devId = arguments[3];
+		runtime.$hmrState.restore(lifecycle, devId, (value) => {
+			defaultValue = value;
+			isUndefined = false;
+		});
+	}
+	const localAtom = {
+		[S_ATOM]: true,
+		$lifecycle: lifecycle,
+		$value: defaultValue,
+		get: getHostedValue,
+		set: setHostedValue
+	};
+	let upstream;
+	if (isUndefined && (upstream = lookupUpstream(context))) {
+		localAtom.get = getUpstreamValue;
+		localAtom.$upstream = upstream;
+		link(lifecycle, upstream, localAtom.$dep = {
+			fn: scheduleAtomNotification,
+			a0: localAtom
+		});
+	} else {
+		localAtom.$tracksValue = true;
+		localAtom.$lastValue = defaultValue;
+		localAtom.$defined = !isUndefined;
+	}
+	localAtom.$devId = arguments[3];
+	if (Object.hasOwn(runtime.$currentContext, context.$symbol)) throw new Error("Component declares multiple hosts of the same Context.");
+	runtime.$currentContext[context.$symbol] = localAtom;
+	return localAtom;
+}
+function contextual(context) {
+	__DEV__assertIsDirectComponentCode(contextual.name);
+	const atom = lookupUpstream(context);
+	{
+		if (!atom) throw new Error("No ancestor is hosting this Context.");
+		let consumer = atom.$consumer;
+		if (!consumer) {
+			consumer = atom.$consumer = {
+				[S_ATOM]: true,
+				$lifecycle: atom.$lifecycle,
+				$upstream: atom,
+				get: getUpstreamValue,
+				set: __DEV__setConsumerValue
+			};
+			link(atom.$lifecycle, atom, {
+				fn: scheduleAtomNotification,
+				a0: consumer
+			});
+		}
+		return consumer;
+	}
+}
+function lookupUpstream(context) {
+	const { $symbol } = context;
+	let ptr = runtime.$currentContext;
+	let atom;
+	while (ptr && !(atom = ptr[$symbol])) ptr = ptr.$parent;
+	return atom;
+}
+function getUpstreamValue() {
+	return this.$upstream.get();
+}
+function getHostedValue() {
+	if (!this.$defined) throw new Error("Cannot read Context before it has been initialized.");
+	return this.$value;
+}
+function setHostedValue(value) {
+	let didChange = true;
+	if (this.$upstream) {
+		unlink(this.$dep);
+		this.$upstream = null;
+		this.$dep = null;
+		this.$tracksValue = true;
+		this.$lastValue = UNIQUE_VALUE;
+		this.get = getHostedValue;
+	} else didChange = !Object.is(this.$value, value);
+	this.$value = value;
+	this.$defined = true;
+	runtime.$hmrState.preserve(this.$lifecycle, this.$devId, value);
+	return didChange;
+}
+function __DEV__setConsumerValue() {
+	throw new Error("Contextual Atoms cannot be written.");
+}
 
 //#endregion
 //#region src/data/Derivation.ts
-/**
-* Creates a Derivation - an Atom with its value computed from other Atoms. The block runs once
-* eagerly to compute the initial value, then re-runs within scheduler ticks whenever its source
-* Atoms change. Observers are only notified if the new value differs from the previous.
-*/
 function derived(block, lifecycle = getLifecycle()) {
-	__DEV__assertNotEffect();
 	const atom = {
 		[S_ATOM]: true,
 		$dirty: false,
@@ -1507,7 +1864,7 @@ function derived(block, lifecycle = getLifecycle()) {
 		$lastValue: null,
 		$cycle: 0,
 		$block: block,
-		$react: scheduleNotify,
+		$react: scheduleReaction,
 		get: getValue,
 		set: setValue
 	};
@@ -1516,16 +1873,13 @@ function derived(block, lifecycle = getLifecycle()) {
 	atom.$lastValue = value;
 	return atom;
 }
-function scheduleNotify(derivation, cycle) {
+function scheduleReaction(derivation, cycle) {
 	if (derivation.$life !== derivation.$lifecycle.$life || derivation.$cycle > cycle) {
-		unlink(this);
+		unlinkEffectDep(derivation, this);
 		return;
 	}
 	derivation.$dirty = true;
-	scheduleTick(derivation.$lifecycle, derivation.$notify ??= {
-		$fn: notify$1,
-		$a0: derivation
-	});
+	scheduleAtomNotification(derivation);
 }
 function getValue() {
 	if (this.$dirty && this.$life === this.$lifecycle.$life) {
@@ -1542,22 +1896,25 @@ function setValue() {
 //#region src/data/List.ts
 function listOf(source, lifecycle = getLifecycle()) {
 	{
-		__DEV__assertNotEffect();
 		const devId = arguments[2];
-		globalThis.__PYXIS_HMR__.state.restore(lifecycle, devId, (value) => {
+		runtime.$hmrState.restore(lifecycle, devId, (value) => {
 			if (Array.isArray(value)) source = value;
 		});
 	}
 	const list = {
-		$lifecycle: lifecycle,
 		$items: source ? Array.from(source) : [],
-		$delta: null,
+		$lifecycle: lifecycle,
+		$committedDelta: null,
+		$pendingDelta: null,
+		$lock: 0,
 		[Symbol.iterator]: getIterator,
 		size,
 		get,
+		dirty,
 		delta,
 		raw,
 		forEach,
+		stable,
 		set,
 		clear,
 		insertAt,
@@ -1571,19 +1928,17 @@ function listOf(source, lifecycle = getLifecycle()) {
 	list.$devId = arguments[2];
 	return list;
 }
-/**
-* Synchronizes the provided List with the given data source. After this operation, the list will
-* contain an exact copy of the source.
-*
-* Note: This function is separated instead of being a List method since the underlying diff
-* algorithm (Myers) is a relatively large chunk of code which would otherwise always get included
-* into bundled builds. This way, tools like Terser can eliminate the extra code when unused.
-*/
-function sync(list, source, eq = defaultEquals) {
-	const oldState = list.$items;
-	list.$items = source.slice();
-	listSynced(list.$delta ??= createDelta(), oldState, source, eq);
-	listMutated(list);
+function sync(list, source, eq = Object.is) {
+	const oldItems = list.$items;
+	const newItems = Array.from(source);
+	list.$items = newItems;
+	__DEV__preserveState(list);
+	if (!list.$dh && !list.$xa) return;
+	const delta = initDelta(list);
+	if (listSynced(delta, oldItems, newItems, eq)) {
+		list.$pendingDelta = delta;
+		scheduleListNotification(list);
+	}
 }
 function size() {
 	reportAccess(this);
@@ -1593,16 +1948,35 @@ function get(index) {
 	reportAccess(this);
 	return this.$items[index];
 }
-function delta() {
-	reportAccess(this);
-	return this.$delta;
+function dirty() {
+	if (this.$xa) return true;
+	const delta = this.$pendingDelta;
+	if (!delta) return false;
+	const pending = this.$notify;
+	return (!pending || pending.$life === pending.$lifecycle.$life) && delta.changes.length > 0;
+}
+function delta(block, lifecycle = getLifecycle()) {
+	link(lifecycle, this, {
+		fn: invokeDeltaBlock,
+		a0: this,
+		a1: lifecycle,
+		a2: block
+	});
 }
 function raw() {
 	return this.$items;
 }
-function forEach(callback, thisArg) {
+function forEach(callback) {
 	reportAccess(this);
-	this.$items.forEach(callback, thisArg);
+	this.$items.forEach(callback);
+}
+function stable(block) {
+	try {
+		this.$lock += 1;
+		return block(this.$items);
+	} finally {
+		this.$lock = Math.max(this.$lock - 1, 0);
+	}
 }
 function getIterator() {
 	reportAccess(this);
@@ -1612,30 +1986,39 @@ function set(index, newItem) {
 	assertIndex(this, index);
 	const oldItem = this.$items[index];
 	if (Object.is(newItem, oldItem)) return;
+	copyOnWrite(this);
 	this.$items[index] = newItem;
-	if (this.$dh) {
-		itemChanged(this.$delta ??= createDelta(), index, oldItem, newItem);
-		listMutated(this);
+	__DEV__preserveState(this);
+	if (this.$dh || this.$xa) {
+		itemChanged(this.$pendingDelta = initDelta(this), index, oldItem, newItem);
+		scheduleListNotification(this);
 	}
 }
 function clear() {
 	const count = this.$items.length;
-	this.$items.length = 0;
-	if (this.$dh) {
-		listCleared(this.$delta ??= createDelta(), count);
-		listMutated(this);
+	if (this.$lock > 0) {
+		this.$items = [];
+		this.$lock = 0;
+	} else this.$items.length = 0;
+	__DEV__preserveState(this);
+	if (this.$dh || this.$xa) {
+		listCleared(this.$pendingDelta = initDelta(this), count);
+		scheduleListNotification(this);
 	}
 }
 function insertAt(index, item) {
-	const { $items } = this;
-	if (index === $items.length) $items.push(item);
-	else {
+	if (index === this.$items.length) {
+		copyOnWrite(this);
+		this.$items.push(item);
+	} else {
 		assertIndex(this, index);
+		copyOnWrite(this);
 		this.$items.splice(index, 0, item);
 	}
-	if (this.$dh) {
-		itemInserted(this.$delta ??= createDelta(), index, item);
-		listMutated(this);
+	__DEV__preserveState(this);
+	if (this.$dh || this.$xa) {
+		itemInserted(this.$pendingDelta = initDelta(this), index, item);
+		scheduleListNotification(this);
 	}
 }
 function insertFirst(item) {
@@ -1652,10 +2035,12 @@ function remove(item) {
 }
 function removeAt(index) {
 	assertIndex(this, index);
+	copyOnWrite(this);
 	const item = this.$items.splice(index, 1)[0];
-	if (this.$dh) {
-		itemRemoved(this.$delta ??= createDelta(), index, item);
-		listMutated(this);
+	__DEV__preserveState(this);
+	if (this.$dh || this.$xa) {
+		itemRemoved(this.$pendingDelta = initDelta(this), index, item);
+		scheduleListNotification(this);
 	}
 	return item;
 }
@@ -1667,160 +2052,195 @@ function removeLast() {
 	return length > 0 ? this.removeAt(length - 1) : void 0;
 }
 function assertIndex(list, index) {
+	if (!Number.isInteger(index)) throw new TypeError("list index must be an integer");
 	if (index >= list.$items.length || index < 0) throw new RangeError("list index out of bounds");
 }
-function defaultEquals(item0, item1) {
-	return Object.is(item0, item1);
+function initDelta(list) {
+	if (list.$pendingDelta) {
+		const pending = list.$notify;
+		if (!pending || pending.$life === pending.$lifecycle.$life) return list.$pendingDelta;
+	}
+	return {
+		changes: [],
+		relSize: 0
+	};
 }
-function listMutated(list) {
-	globalThis.__PYXIS_HMR__.state.preserve(list.$lifecycle, list.$devId, list.$items);
+function copyOnWrite(list) {
+	if (list.$lock > 0) {
+		list.$items = list.$items.slice();
+		list.$lock = 0;
+	}
+}
+function scheduleListNotification(list) {
 	scheduleTick(list.$lifecycle, list.$notify ??= {
-		$fn: notify,
-		$a0: list
-	});
-	scheduleTock(list.$lifecycle, list.$cleanup ??= {
-		$fn: cleanup,
-		$a0: list
+		fn: notifyListObservers,
+		a0: list
 	});
 }
-function notify(list) {
-	let current = list.$dh;
-	let next;
-	while (current) {
-		next = current.$an;
-		invoke(current);
-		current = next;
+function notifyListObservers(list) {
+	const delta = list.$pendingDelta;
+	list.$pendingDelta = null;
+	if (list.$force || delta.changes.length > 0) {
+		delta.snapshot = list.$items;
+		list.$committedDelta = delta;
+		list.$lock += 1;
+		list.$force = false;
+		try {
+			notify(list);
+		} finally {
+			list.$committedDelta = null;
+			list.$lock = Math.max(list.$lock - 1, 0);
+		}
 	}
 }
-function cleanup(list) {
-	list.$delta = null;
+function invokeDeltaBlock(list, lifecycle, block) {
+	withLifecycle(lifecycle, block, list.$committedDelta);
+}
+function __DEV__preserveState(list) {
+	runtime.$hmrState.preserve(list.$lifecycle, list.$devId, list.$items);
+}
+
+//#endregion
+//#region src/Adapter.ts
+/*@__NO_SIDE_EFFECTS__*/
+function extension(propSetter) {
+	return {
+		$prefix: `:${(++runtime.$extIndex).toString(16)}:`,
+		set: propSetter
+	};
+}
+function ext(extension, extensionProps, targetPropsObject = {}) {
+	const prefix = extension.$prefix;
+	if (typeof prefix !== "string") throw new Error("the extension was not created through the `extension()` factory and cannot be used");
+	const routing = runtime.x;
+	let prop;
+	let route;
+	for (prop in extensionProps) {
+		route = prefix + prop;
+		routing[route] ??= {
+			$ext: extension,
+			$prop: prop
+		};
+		targetPropsObject[route] = extensionProps[prop];
+	}
+	return targetPropsObject;
 }
 
 //#endregion
 //#region src/extension/RefExtension.ts
-/**
-* Extension adding direct reference access to any element. Recommended prefix:
-* `"ref"`
-*
-* References can be stored into atoms:
-* ```tsx
-* const wrapperRef = atomOf<HTMLDivElement>();
-* <div ref:atom={wrapperRef} />
-* ```
-* or handled with a custom callback:
-* ```tsx
-* const onWrapperRef = (node: HTMLDivElement) => { ... };
-* <div ref:call={onWrapperRef} />
-* ```
-*/
-const RefExtension = { set: (node, kind, value) => {
-	let method;
-	switch (kind) {
+const RefExtension = /*@__PURE__*/ extension((node, prop, value, group) => {
+	switch (prop) {
 		case "atom":
-			if (!isAtom(value)) return;
-			method = refAtom;
+			if (isAtom(value)) {
+				onceMounted(group, {
+					fn: write,
+					a0: value,
+					a1: node
+				});
+				onceUnmounted(group, {
+					fn: write,
+					a0: value,
+					a1: null
+				});
+			}
 			break;
 		case "call":
-			if (typeof value !== "function") return;
-			method = refCall;
+			if (typeof value === "function") onceMounted(group, {
+				fn: invokeMountedCallback,
+				a0: group,
+				a1: value,
+				a2: node
+			});
 			break;
-		default: return;
 	}
-	const lifecycle = getLifecycle();
-	onMounted(lifecycle, {
-		$fn: method,
-		$a0: value,
-		$a1: node
-	});
-	onUnmounted(lifecycle, {
-		$fn: method,
-		$a0: value,
-		$a1: null
-	});
-} };
-function refAtom(atom, node) {
-	atom.set(node);
-}
-function refCall(setter, node) {
-	setter(node);
-}
+});
 
 //#endregion
-//#region src/support/text.ts
-function tag(access, strings, values) {
+//#region src/support/atoms.ts
+function text(strings, ...values) {
 	const { length } = values;
-	let index = 0;
-	let text = strings[0];
-	while (index < length) text += access(values[index]) + strings[++index];
-	return text;
-}
-/**
-* A template literal tag that automatically wraps each substitution in a `read` call.
-* @see {@link read}
-*/
-function reads(strings, ...values) {
-	return tag(read, strings, values);
-}
-/**
-* A template literal tag that automatically wraps each substitution in a `peek` call.
-* @see {@link peek}
-*/
-function peeks(strings, ...values) {
-	return tag(peek, strings, values);
-}
-
-//#endregion
-//#region src/Builder.ts
-function pyxis(adapter) {
-	const extensions = {};
-	const builder = {
-		build: () => createRenderer(adapter, extensions),
-		extend: (extensionKey, extension) => {
-			extensions[extensionKey] = extension;
-			return builder;
+	return derived(() => {
+		let result = strings[0];
+		let index = 0;
+		let value;
+		while (index < length) {
+			value = read(values[index]);
+			try {
+				value = String(value);
+			} catch {
+				value = "[error]";
+			}
+			result += value + strings[++index];
 		}
-	};
-	return builder;
+		return result;
+	});
 }
-
-//#endregion
-//#region src/Component.ts
-function component(block) {
-	let devId;
-	devId = arguments[1];
-	devId && globalThis.__PYXIS_HMR__.component.upsert(devId, block);
-	return (jsx, hParent, nUsedParent, nRealParent, nBefore, isBatch) => {
-		const context = getContextContainer();
-		try {
-			{
-				if (!import.meta.hot || !devId) {
-					setContextContainer(context);
-					mountJsx(block(jsx), hParent, nUsedParent, nRealParent, nBefore, isBatch);
-					return;
-				}
-				const hGroup = fork(hParent);
-				const nMarker = hGroup.adapter.marker(`/${devId}`);
-				insert(nMarker, null, hParent, nUsedParent, nBefore, isBatch);
-				unmounted(globalThis.__PYXIS_HMR__.component.subscribe(devId, (impl) => {
-					unmount(hGroup);
-					setContextContainer(context);
-					mount({
-						...jsx,
-						[S_COMPONENT]: (() => mountJsx(impl(jsx), hGroup, nUsedParent, nRealParent, nMarker, isBatch))
-					}, hGroup, nUsedParent, nRealParent, nMarker, isBatch);
-				}));
-				nUsedParent = nRealParent;
-				isBatch = false;
-			}
-		} finally {
-			setContextContainer(context);
+/*@__NO_SIDE_EFFECTS__*/
+function writes(input, value, force) {
+	return isAtom(input) ? () => void write(input, value, force) : noop;
+}
+/*@__NO_SIDE_EFFECTS__*/
+function updates(input, transform, force) {
+	return isAtom(input) ? () => void update(input, transform, force) : noop;
+}
+function atomsOf(data, keysOrLifecycle, maybeLifecycle) {
+	let keys;
+	let lifecycle;
+	if (keysOrLifecycle === void 0 || Array.isArray(keysOrLifecycle)) {
+		keys = keysOrLifecycle;
+		lifecycle = maybeLifecycle;
+	} else lifecycle = keysOrLifecycle;
+	lifecycle ??= getLifecycle();
+	const result = Object.create(null);
+	if (keys) {
+		const { length } = keys;
+		let index = 0;
+		let key;
+		for (; index < length; index += 1) {
+			key = keys[index];
+			result[key] = atomOf(data[key], lifecycle);
 		}
-	};
+		for (key in data) if (result[key] === void 0) result[key] = data[key];
+	} else {
+		let key;
+		for (key in data) result[key] = atomOf(data[key], lifecycle);
+	}
+	return result;
+}
+function assign(store, data, keysOrLifecycle, maybeLifecycle) {
+	let keys;
+	let lifecycle;
+	if (keysOrLifecycle === void 0 || Array.isArray(keysOrLifecycle)) {
+		keys = keysOrLifecycle;
+		lifecycle = maybeLifecycle;
+	} else lifecycle = keysOrLifecycle;
+	if (keys) {
+		const { length } = keys;
+		const visited = Object.create(null);
+		let index = 0;
+		let key;
+		for (; index < length; index += 1) {
+			key = keys[index];
+			write(store[key], peek(data[key]));
+			visited[key] = true;
+		}
+		for (key in data) if (!visited[key]) store[key] = data[key];
+	} else {
+		let key;
+		let atom;
+		for (key in store) {
+			atom = store[key];
+			if (isAtom(atom)) write(atom, peek(data[key]));
+			else store[key] = atomOf(data[key], lifecycle ??= getLifecycle());
+		}
+		for (key in data) if (!Object.hasOwn(store, key)) store[key] = atomOf(data[key], lifecycle ??= getLifecycle());
+	}
+	return store;
 }
 
 //#endregion
 //#region src/jsx.ts
-const EMPTY_ARRAY = Object.freeze([]);
+const EMPTY_ARRAY = [];
 function jsx(componentOrTagName, props, key) {
 	const { children } = props;
 	props.children = children === void 0 ? EMPTY_ARRAY : Array.isArray(children) ? children : [children];
@@ -1841,5 +2261,26 @@ function jsxs(componentOrTagName, props, key) {
 }
 
 //#endregion
-export { ChangeKind, Fragment, Iterator, Native, RefExtension, Show, atomOf, bind, component, consumerOf, createContext, derived, effect, fork, getLifecycle, host, insert, isAtom, jsx, jsxs, listOf, mount, mountJsx, mounted, noEffect, peek, peeks, proxyOf, pyxis, read, reads, sync, tick, tock, track, unmount, unmounted, untrack, update, withLifecycle, write };
+//#region src/RendererBuilder.ts
+/*@__NO_SIDE_EFFECTS__*/
+function renderer(adapter) {
+	const extensions = {};
+	const builder = {
+		create: () => /* @__PURE__ */ createRenderer(adapter, extensions),
+		extend: (extensionKey, extension) => {
+			if (!/^[a-z_$][a-z0-9_$-]*$/i.test(extensionKey)) throw new Error(`invalid extension key: "${extensionKey}"`);
+			extensions[extensionKey] = extension;
+			return builder;
+		}
+	};
+	return builder;
+}
+
+//#endregion
+//#region src/exports/core-dev.ts
+runtime.$hmrComponent ??= new ComponentRegistry();
+runtime.$hmrState ??= new StateRegistry();
+
+//#endregion
+export { Fragment, Iterator, LC_CHANGE, LC_CLEAR, LC_INSERT, LC_REMOVE, Native, RefExtension, S_ATOM, S_COMPONENT, S_DEV_INFO, S_TAG_NAME, Show, assign, atomOf, atomsOf, bind, component, contextOf, contextual, derived, destroy, effect, ext, extension, flush, fork, getLifecycle, host, insert, invoke, isAtom, jsx, jsxs, link, listOf, mount, mountJsx, mounted, noEffect, onceMounted, onceUnmounted, peek, proxyOf, read, renderer, scheduleTick, scheduleTock, sync, text, tick, tock, track, unlink, unmount, unmounted, untrack, update, updates, willMount, withLifecycle, write, writes };
 //# sourceMappingURL=core-dev.js.map