@askrjs/askr 0.3.0 → 0.4.0

package/dist/boot-DaoTYoCw.js

@@ -0,0 +1,3989 @@
+import { C as schedule, F as logger, I as isDevelopmentEnvironment, L as isProductionEnvironment, M as getOwner, N as runWithOwner, S as queueTask, _ as batch, c as setRenderHost, d as recordUndo, f as rewindJournal, g as outsideRendering, i as getContextEpoch, j as Owner, l as createRenderJournal, m as withRenderJournal, n as HookOrderChangeError, p as settleJournal, t as ComponentInstance, u as journalMark, v as effectScheduler, w as Computation, y as flushSync } from "./instance-BAnfmXOR.js";
+import { n as readValue } from "./readable-DFWOsTac.js";
+import { n as Fragment, t as ELEMENT_TYPE } from "./jsx-DRS-qjiN.js";
+import { _ as RenderDepthError, b as reportUncaughtErrorLater, g as routeError, h as noteErrorOrigin, i as currentComponent, l as provideAppRuntime, m as deliverToBoundary, p as clarifyRenderError, v as clarifyRenderOverflow, y as reportUncaughtError } from "./hooks-BimKStr4.js";
+import { r as validateCspNonce, t as CspNonceScope } from "./csp-nonce-DwGw1A6Q.js";
+import { d as startHydrationRenderPhase, p as stopHydrationRenderPhase, x as pageRenderEnvelope } from "./render-context-DGHnEveC.js";
+import { a as descriptorType, o as functionChildOutput, s as normalizeChildren } from "./error-boundary-Bpwofwps.js";
+import { D as clearStagedAppRenderRouteLocation, E as configureRootUpdateHost, O as createAppRenderRuntime, S as unregisterAppInstance, T as setServerLocation, _ as registerAppInstance, c as reconcileRouteMeta, d as configureScrollRestoration, k as stageAppRenderRouteLocation, l as resolveRouteMeta, o as readHistoryIndex, s as loadDocument, t as initializeNavigation } from "./navigate-CP_0Zy5U.js";
+import { t as assertSyncComponentResult } from "./promise-Dz8iIHAm.js";
+import { a as hydrateDataRuntime, m as reviveDeferredValue } from "./query-registry-WMCN0BJL.js";
+import { A as clearRouteState, D as _setActiveRouteAuthOptions, Y as lockRouteRegistration, a as resolveRouteRequest, gt as withoutRouteHydrationMetadata, i as hasRouteRenderData, m as withoutHydratedAuth, n as getRouteRenderContext, p as readHydratedAuth, q as hasRegisteredRoutes, r as getRouteRenderData } from "./resolution-Cx82-xjW.js";
+import { c as isSSRPortalHydrationAnchor, i as provideDefaultPortal, l as isSSRPortalWriterAnchor, t as DefaultPortal } from "./portal-DuOKfnLa.js";
+import { r as assertExecutionModel, t as _applyManifest } from "./manifest-CW9gyNBY.js";
+import { a as getDefaultDataRuntime } from "./data-runtime-C1bFAlba.js";
+import { c as resolveNavigationUrl, d as isCustomElementName, l as attributeNamespace, n as UNSAFE_URL_SCHEME_ATTRIBUTES, s as rejectUnsafeUrlAttribute, t as SCRIPT_URL_RESOURCE_ATTRIBUTES, u as getPublicAttributeName } from "./url-CnbfpX0K.js";
+import { a as PROPERTY_PROP_PREFIX, c as isKnownBooleanProperty, d as booleanAttributeValue, f as isSkippedProp, h as styleValueText, i as ATTRIBUTE_PROP_PREFIX, m as normalizeStylePropertyName, o as domPropertyValue, p as keepsFalseValue, r as sanitizeCssValue, s as getDomPropertyName, u as propertyReflectsAttribute } from "./ssr-DoV-vJ-5.js";
+//#region src/boot/root-handler.ts
+const AUTO_PORTAL = {
+	$$typeof: ELEMENT_TYPE,
+	type: DefaultPortal,
+	props: { __askrAutoDefaultPortal: true },
+	key: "__default_portal"
+};
+/**
+* Wrap a root's component: its output is followed by the automatic default
+* portal host, and the CSP nonce (if any) is provided to everything below.
+*/
+function wrapRootRouteHandler(componentFn, cspNonce) {
+	const wrappedFn = (props, ctx) => {
+		const out = componentFn(props, ctx);
+		assertSyncComponentResult(out);
+		const root = {
+			$$typeof: ELEMENT_TYPE,
+			type: Fragment,
+			props: { children: out === void 0 || out === null ? [AUTO_PORTAL] : [out, AUTO_PORTAL] }
+		};
+		return cspNonce === void 0 ? root : CspNonceScope({
+			value: cspNonce,
+			children: root
+		});
+	};
+	Object.defineProperty(wrappedFn, "name", { value: componentFn.name || "Component" });
+	return wrappedFn;
+}
+//#endregion
+//#region src/boot/root-update.ts
+/**
+* Route updates for application roots.
+*
+* `apply()` renders the destination (render phase only); `publish()` commits
+* it; `rollback()` discards it and restores the root's previous route state.
+* A navigation applies every root first and publishes only if all succeeded.
+*/
+function prepare(root, input) {
+	const app = root;
+	const current = app.appRuntime;
+	const runtime = createAppRenderRuntime({
+		framework: withoutRouteHydrationMetadata(current?.framework),
+		dataRuntime: current?.dataRuntime,
+		routeRegistry: current?.routeRegistry,
+		routeAuth: current?.routeAuth,
+		route: input.routeData,
+		hasRoute: input.hasRouteData,
+		lifetime: current?.lifetime
+	});
+	const previous = {
+		appRuntime: app.appRuntime,
+		component: app.component,
+		handler: app.handler,
+		generation: app.generation
+	};
+	let prepared = null;
+	let settled = false;
+	const restore = () => {
+		app.appRuntime = previous.appRuntime;
+		app.component = previous.component;
+		app.handler = previous.handler;
+		app.generation = previous.generation;
+	};
+	return {
+		apply() {
+			if (prepared || settled) return;
+			stageAppRenderRouteLocation(runtime, input.href);
+			app.appRuntime = runtime;
+			if (input.replaceLifetime) {
+				app.component = input.handler;
+				app.handler = wrapRootRouteHandler(input.handler, app.cspNonce);
+				app.generation++;
+				runtime.lifetime = app.generation;
+			}
+			try {
+				prepared = app.root.prepare(app.view());
+				prepared.apply();
+			} catch (error) {
+				restore();
+				clearStagedAppRenderRouteLocation(runtime);
+				throw error;
+			}
+		},
+		publish() {
+			if (settled) return {
+				aborted: false,
+				errors: []
+			};
+			settled = true;
+			try {
+				prepared?.publish();
+				return {
+					aborted: false,
+					errors: []
+				};
+			} catch (error) {
+				const aborted = prepared?.aborted === true;
+				if (aborted) restore();
+				return {
+					aborted,
+					errors: [error]
+				};
+			} finally {
+				clearStagedAppRenderRouteLocation(runtime);
+			}
+		},
+		rollback() {
+			if (settled) return [];
+			settled = true;
+			clearStagedAppRenderRouteLocation(runtime);
+			const errors = prepared?.rollback() ?? [];
+			restore();
+			return errors;
+		},
+		retire() {
+			return [];
+		}
+	};
+}
+function installRootUpdateHost() {
+	configureRootUpdateHost({ prepare });
+}
+//#endregion
+//#region src/boot/composition.ts
+let composed = false;
+/**
+* Browser composition root, owned by the boot entry: connects route updates
+* from the router to application roots.
+*/
+function composeBrowserRuntime() {
+	if (composed) return;
+	composed = true;
+	installRootUpdateHost();
+}
+/** Compose whatever is still missing, for a mount reached without the boot entry. */
+function ensureBrowserRuntime() {
+	composeBrowserRuntime();
+}
+//#endregion
+//#region src/core/dom/pass.ts
+/**
+* A render pass.
+*
+* The render phase runs components, diffs their output, and builds new DOM
+* off-document. Anything that would change live DOM or committed renderer
+* state is recorded as an operation instead. `commit()` applies the
+* operations in order; `discard()` drops them, disposes every owner the pass
+* created, and rewinds the render journal (props and scope values set during
+* render). A failed structural DOM write restores child lists that this pass
+* already applied, then discards its provisional owners and subscriptions.
+*
+* Operations are recorded parent-first: a reconcile reserves its slot before
+* its children record theirs, so a parent places its children before the
+* children update their own contents.
+*/
+/** A structural DOM write failed before its render pass could publish. */
+var CommitMutationError = class extends Error {
+	constructor(failure) {
+		super("DOM commit failed");
+		this.failure = failure;
+	}
+};
+var Pass = class {
+	constructor() {
+		this.hasDormantPortalWriter = false;
+		this.commitAborted = false;
+		this.ops = [];
+		this.created = [];
+		this.renderedInstances = [];
+		this.afterCommit = [];
+		this.beforeSettle = [];
+		this.commitUndo = [];
+		this.commitSettle = [];
+		this.journal = createRenderJournal();
+		this.phase = "prepared";
+		this.failures = [];
+	}
+	/** Run render work with this pass's provisional undo journal active. */
+	run(render) {
+		return withRenderJournal(this.journal, render);
+	}
+	/** Record an operation on committed state. */
+	op(fn) {
+		this.ops.push(fn);
+	}
+	/** Reserve an operation slot to fill after nested work records its own. */
+	reserve() {
+		this.ops.push(null);
+		return this.ops.length - 1;
+	}
+	fill(slot, fn) {
+		this.ops[slot] = fn;
+	}
+	/** An owner this pass created; disposed if the pass is discarded. */
+	own(owner) {
+		this.created.push(owner);
+	}
+	/** An instance rendered by this pass; it commits (and mounts) with it. */
+	markRendered(instance) {
+		this.renderedInstances.push(instance);
+	}
+	/** Undo a provisional render-time change if this work is discarded. */
+	onDiscard(fn) {
+		recordUndo(fn, this.journal);
+	}
+	/** Run after all operations are applied (refs). */
+	after(fn) {
+		this.afterCommit.push(fn);
+	}
+	/** Run after DOM operations while the pass can still be rolled back. */
+	beforeJournalSettle(fn) {
+		this.beforeSettle.push(fn);
+	}
+	/** Restore a reversible write on abort; settle its old lifetime on success. */
+	onReversibleCommit(undo, settle = () => {}) {
+		this.commitUndo.push(undo);
+		this.commitSettle.push(settle);
+	}
+	mark() {
+		return {
+			ops: this.ops.length,
+			created: this.created.length,
+			rendered: this.renderedInstances.length,
+			journal: journalMark(this.journal),
+			after: this.afterCommit.length,
+			beforeSettle: this.beforeSettle.length,
+			commitUndo: this.commitUndo.length,
+			commitSettle: this.commitSettle.length,
+			dormantPortalWriter: this.hasDormantPortalWriter
+		};
+	}
+	/** Discard everything recorded since `mark` (an error boundary caught). */
+	rewind(mark) {
+		const errors = [];
+		this.ops.length = mark.ops;
+		this.afterCommit.length = mark.after;
+		this.renderedInstances.length = mark.rendered;
+		this.hasDormantPortalWriter = mark.dormantPortalWriter;
+		this.beforeSettle.length = mark.beforeSettle;
+		this.commitUndo.length = mark.commitUndo;
+		this.commitSettle.length = mark.commitSettle;
+		rewindJournal(this.journal, mark.journal, errors);
+		for (const owner of this.created.splice(mark.created).reverse()) owner.dispose(errors);
+		return errors;
+	}
+	discard() {
+		if (this.phase === "applied") return this.rollback();
+		if (this.phase === "published" || this.phase === "discarded") return [];
+		this.phase = "discarded";
+		return this.rewind({
+			ops: 0,
+			created: 0,
+			rendered: 0,
+			journal: 0,
+			after: 0,
+			beforeSettle: 0,
+			commitUndo: 0,
+			commitSettle: 0,
+			dormantPortalWriter: false
+		});
+	}
+	/** Apply reversible operations while retaining undo work for rollback. */
+	apply() {
+		if (this.phase === "applied") return;
+		if (this.phase !== "prepared") throw new Error("[Askr] Cannot apply a settled render pass.");
+		const abort = (failure) => {
+			this.commitAborted = true;
+			for (const error of this.rollback()) reportUncaughtErrorLater(error);
+			throw failure;
+		};
+		this.phase = "applied";
+		for (const op of this.ops) {
+			if (!op) continue;
+			try {
+				op();
+			} catch (error) {
+				if (error instanceof CommitMutationError) abort(error.failure);
+				this.failures.push(error);
+			}
+		}
+		for (const fn of this.beforeSettle) try {
+			fn();
+		} catch (error) {
+			if (error instanceof CommitMutationError) abort(error.failure);
+			this.failures.push(error);
+		}
+	}
+	/** Publish applied work and run irreversible cleanup, refs, and lifecycles. */
+	publish() {
+		if (this.phase === "prepared") this.apply();
+		if (this.phase !== "applied") throw new Error("[Askr] Cannot publish a render pass that was not applied.");
+		this.phase = "published";
+		settleJournal(this.journal, 0);
+		for (const settle of this.commitSettle) try {
+			settle();
+		} catch (error) {
+			this.failures.push(error);
+		}
+		for (const fn of this.afterCommit) try {
+			fn();
+		} catch (error) {
+			this.failures.push(error);
+		}
+		for (const instance of this.renderedInstances) if (!instance.disposed) try {
+			mount(instance);
+		} catch (error) {
+			this.failures.push(error);
+		}
+		if (this.failures.length === 1) throw this.failures[0];
+		if (this.failures.length > 1) throw new AggregateError(this.failures, "Commit failed");
+	}
+	/** Undo applied operations and discard every provisional render mutation. */
+	rollback() {
+		if (this.phase === "published" || this.phase === "discarded") return [];
+		const errors = [];
+		if (this.phase === "applied") for (let index = this.commitUndo.length - 1; index >= 0; index--) try {
+			this.commitUndo[index]();
+		} catch (error) {
+			errors.push(error);
+		}
+		this.phase = "prepared";
+		errors.push(...this.discard());
+		return errors;
+	}
+	/** Apply and publish immediately for a standalone root render. */
+	commit() {
+		this.apply();
+		this.publish();
+	}
+};
+/** Mark an instance committed and schedule its post-commit work. */
+function mount(instance) {
+	instance.mounted = true;
+	const syncQueue = instance.commitSyncQueue;
+	instance.commitSyncQueue = null;
+	for (const fn of syncQueue ?? []) fn();
+	const queue = instance.commitQueue;
+	if (!queue) return;
+	instance.commitQueue = null;
+	queueTask(() => {
+		if (instance.disposed) return;
+		for (const fn of queue) try {
+			const cleanup = fn();
+			if (typeof cleanup === "function") instance.onCleanup(cleanup);
+		} catch (error) {
+			reportUncaughtErrorLater(error);
+		}
+	});
+}
+//#endregion
+//#region src/core/dom/element-attributes.ts
+/**
+* Low-level attribute access for rendered elements: the attribute name a prop
+* renders as, namespaced writes, and class names on HTML and SVG elements.
+*/
+const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+function isSVGDomElement(el) {
+	return typeof SVGElement !== "undefined" && el instanceof SVGElement;
+}
+function getRenderedAttributeName(el, propName) {
+	const attributeName = getPublicAttributeName(propName, isCustomElementName(el.localName));
+	return el.namespaceURI === SVG_NAMESPACE ? attributeName : attributeName.toLowerCase();
+}
+/**
+* Write an attribute, placing `xlink:`/`xml:`/`xmlns:` names on SVG and MathML
+* elements in their namespace.
+*/
+function writeAttribute(el, attributeName, value, namespace = attributeNamespace(el.namespaceURI, attributeName)) {
+	if (namespace === null) el.setAttribute(attributeName, value);
+	else el.setAttributeNS(namespace, attributeName, value);
+}
+function setRenderedAttribute(el, propName, value) {
+	writeAttribute(el, getRenderedAttributeName(el, propName), value);
+}
+function removeRenderedAttribute(el, propName) {
+	el.removeAttribute(getRenderedAttributeName(el, propName));
+}
+function readElementClassName(el) {
+	if (isSVGDomElement(el)) return el.getAttribute("class") ?? "";
+	return el.className;
+}
+function writeElementClassName(el, value) {
+	if (isSVGDomElement(el)) {
+		if (value.length > 0) el.setAttribute("class", value);
+		else el.removeAttribute("class");
+		return;
+	}
+	el.className = value;
+}
+function tagNamesEqualIgnoreCase(a, b) {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	for (let index = 0; index < a.length; index += 1) {
+		const aCode = a.charCodeAt(index);
+		const bCode = b.charCodeAt(index);
+		if (aCode === bCode) continue;
+		if ((aCode >= 65 && aCode <= 90 ? aCode + 32 : aCode) !== (bCode >= 65 && bCode <= 90 ? bCode + 32 : bCode)) return false;
+	}
+	return true;
+}
+//#endregion
+//#region src/core/dom/events.ts
+/**
+* Event handler props on rendered elements.
+*
+* Bubbling UI events (`click`, `input`, keyboard, mouse, touch) are
+* delegated: each app root, plus `document.body` for content rendered outside
+* any root (portals), listens once per event type. When an event reaches a
+* container, its handlers along the event path are snapshotted and run
+* target-first in one batch, so state writes flush once, synchronously, after
+* the last handler, and a handler that removes an ancestor does not stop that
+* ancestor's handler for the same event. Other events and capture handlers
+* get one direct listener per element, run in their own batch.
+*
+* A handler's handler function can be swapped without re-registering. It runs
+* with its component as the current owner, and a throwing handler is reported
+* like an uncaught listener exception.
+*/
+/** Root container visible to listeners through their component owner. */
+const EVENT_ROOT_CONTAINER = Symbol("askr.event-root-container");
+const DELEGATED_EVENTS = /* @__PURE__ */ new Set([
+	"click",
+	"dblclick",
+	"mousedown",
+	"mouseup",
+	"mouseover",
+	"mouseout",
+	"mousemove",
+	"touchend",
+	"touchcancel",
+	"keydown",
+	"keyup",
+	"keypress",
+	"input"
+]);
+/** `onClick` -> click, `onKeyDownCapture` -> keydown (capture); else null. */
+function parseEventProp(propName) {
+	if (propName.length <= 2 || !propName.startsWith("on")) return null;
+	const capture = propName.endsWith("Capture") && !propName.endsWith("PointerCapture") && propName.length > 9;
+	const name = capture ? propName.slice(0, -7) : propName;
+	if (name.length <= 2) return null;
+	return {
+		eventName: name.slice(2).toLowerCase(),
+		capture
+	};
+}
+/**
+* `wheel`, `touchstart` and `touchmove` opt out of passive defaults so a
+* handler can call `preventDefault()`; `scroll` is always passive.
+*/
+function listenerOptions(eventName, capture) {
+	let options;
+	if (eventName === "scroll") options = { passive: true };
+	else if (eventName === "wheel" || eventName === "touchstart" || eventName === "touchmove") options = { passive: false };
+	if (!capture) return options;
+	return {
+		...options,
+		capture: true
+	};
+}
+function invoke(listener, el, event) {
+	runWithOwner(listener.owner, () => {
+		try {
+			listener.handler.call(el, event);
+		} catch (error) {
+			reportUncaughtError(error);
+		}
+	});
+}
+/** Delegated handlers per element, by event type. */
+const delegatedHandlers = /* @__PURE__ */ new WeakMap();
+/** Elements holding a delegated handler, per event type. */
+const delegatedUsage = /* @__PURE__ */ new Map();
+/** Registered app roots, each counted once per live root using it. */
+const roots = /* @__PURE__ */ new Map();
+/** Container listeners, per container, by event type. */
+const containerListeners = /* @__PURE__ */ new Map();
+function fallbackContainer() {
+	return typeof document === "undefined" ? null : document.body;
+}
+function listen(container, eventName) {
+	let listeners = containerListeners.get(container);
+	if (listeners?.has(eventName)) return;
+	const listener = (event) => dispatch(event, eventName);
+	container.addEventListener(eventName, listener);
+	if (!listeners) containerListeners.set(container, listeners = /* @__PURE__ */ new Map());
+	listeners.set(eventName, listener);
+}
+function unlisten(container, eventName) {
+	const listeners = containerListeners.get(container);
+	const listener = listeners?.get(eventName);
+	if (!listener) return;
+	container.removeEventListener(eventName, listener);
+	listeners.delete(eventName);
+	if (listeners.size === 0) containerListeners.delete(container);
+}
+function containers() {
+	const all = [...roots.keys()];
+	const fallback = fallbackContainer();
+	if (fallback && !roots.has(fallback)) all.push(fallback);
+	return all;
+}
+/** Delegate events rendered under `root` at `root`, until released. */
+function registerEventRoot(root) {
+	roots.set(root, (roots.get(root) ?? 0) + 1);
+	for (const eventName of delegatedUsage.keys()) listen(root, eventName);
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		const count = roots.get(root) - 1;
+		if (count > 0) {
+			roots.set(root, count);
+			return;
+		}
+		roots.delete(root);
+		if (root === fallbackContainer()) return;
+		for (const eventName of delegatedUsage.keys()) unlisten(root, eventName);
+	};
+}
+function isShadowRoot(node) {
+	return node.nodeType === 11 && node.host != null;
+}
+/**
+* Index of `container` in `composed`, or -1 when the composed path cannot be
+* used: it lacks the container, or it skips an ancestor of the (retargeted)
+* target below the container, as some browser hosts do.
+*/
+function composedPathEnd(composed, target, container) {
+	const end = composed.indexOf(container);
+	if (end === -1) return -1;
+	let expected = target;
+	for (let i = 0; i < end && expected; i++) if (composed[i] === expected) expected = expected.parentNode;
+	return expected === container ? end : -1;
+}
+/**
+* The target's parent chain up to `container`, supplemented with any
+* composed path nodes it misses, for hosts whose composed path is unusable.
+*/
+function ancestryPath(event, container) {
+	const path = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (let node = event.target; node; node = node.parentNode) {
+		seen.add(node);
+		path.push(node);
+		if (node === container) return path;
+	}
+	for (const node of event.composedPath?.() ?? []) if (!seen.has(node)) {
+		seen.add(node);
+		path.push(node);
+	}
+	return path;
+}
+/** The event as seen by one element's handler. */
+function eventFor(event, currentTarget, target) {
+	return new Proxy(event, { get(native, property) {
+		if (property === "currentTarget") return currentTarget;
+		if (property === "target") return target;
+		const value = Reflect.get(native, property, native);
+		return typeof value === "function" ? value.bind(native) : value;
+	} });
+}
+function dispatch(event, eventName) {
+	const container = event.currentTarget;
+	const composed = event.composedPath?.() ?? [];
+	const end = composedPathEnd(composed, event.target, container);
+	const path = end === -1 ? ancestryPath(event, container) : composed;
+	const last = end === -1 ? path.length : end;
+	const retarget = end > 0 && composed[0] !== event.target;
+	let target = retarget ? composed[0] : event.target;
+	let depth = 0;
+	let targetDepth = 0;
+	const handlers = [];
+	for (let i = 0; i < last; i++) {
+		const node = path[i];
+		if (node === container) break;
+		if (retarget) {
+			if (isShadowRoot(node)) {
+				if (--depth < targetDepth) {
+					target = node.host;
+					targetDepth = depth;
+				}
+			} else if (i > 0 && path[i - 1].assignedSlot === node) depth++;
+		}
+		if (node.nodeType !== 1) continue;
+		if (containerListeners.get(node)?.has(eventName)) handlers.length = 0;
+		const listener = delegatedHandlers.get(node)?.get(eventName);
+		if (listener) handlers.push({
+			el: node,
+			listener,
+			target
+		});
+	}
+	if (handlers.length === 0) return;
+	outsideRendering(() => batch(() => {
+		for (const { el, listener, target } of handlers) {
+			invoke(listener, el, eventFor(event, el, target));
+			if (event.cancelBubble) break;
+		}
+	}));
+}
+function delegate(el, listener) {
+	let byEvent = delegatedHandlers.get(el);
+	if (!byEvent) delegatedHandlers.set(el, byEvent = /* @__PURE__ */ new Map());
+	byEvent.set(listener.eventName, listener);
+	const usage = delegatedUsage.get(listener.eventName) ?? 0;
+	delegatedUsage.set(listener.eventName, usage + 1);
+	if (usage === 0) for (const container of containers()) listen(container, listener.eventName);
+}
+function undelegate(el, eventName) {
+	const byEvent = delegatedHandlers.get(el);
+	if (!byEvent?.delete(eventName)) return;
+	if (byEvent.size === 0) delegatedHandlers.delete(el);
+	const usage = delegatedUsage.get(eventName) - 1;
+	if (usage > 0) {
+		delegatedUsage.set(eventName, usage);
+		return;
+	}
+	delegatedUsage.delete(eventName);
+	for (const container of containerListeners.keys()) unlisten(container, eventName);
+}
+function setListener(listeners, el, propName, event, handler, owner) {
+	const existing = listeners.get(propName);
+	if (existing) {
+		existing.handler = handler;
+		return;
+	}
+	if (!event.capture && DELEGATED_EVENTS.has(event.eventName) && (roots.size > 0 || fallbackContainer())) {
+		const listener = {
+			handler,
+			owner,
+			eventName: event.eventName,
+			wrapped: null,
+			options: void 0
+		};
+		listeners.set(propName, listener);
+		delegate(el, listener);
+		return;
+	}
+	const options = listenerOptions(event.eventName, event.capture);
+	const listener = {
+		handler,
+		owner,
+		eventName: event.eventName,
+		options,
+		wrapped: (nativeEvent) => {
+			outsideRendering(() => batch(() => invoke(listener, el, nativeEvent)));
+		}
+	};
+	listeners.set(propName, listener);
+	el.addEventListener(event.eventName, listener.wrapped, options);
+}
+function removeListener(listeners, el, propName) {
+	const listener = listeners.get(propName);
+	if (!listener) return;
+	listeners.delete(propName);
+	if (!listener.wrapped) {
+		undelegate(el, listener.eventName);
+		return;
+	}
+	el.removeEventListener(listener.eventName, listener.wrapped, listener.options);
+}
+function removeAllListeners(listeners, el, errors) {
+	for (const propName of Array.from(listeners.keys())) try {
+		removeListener(listeners, el, propName);
+	} catch (error) {
+		errors.push(error);
+	}
+}
+//#endregion
+//#region src/core/dom/hydration.ts
+/**
+* Hydration: rendering over server markup with a cursor.
+*
+* While a root's first render hydrates, each container element has a cursor
+* at its next unclaimed child. Creating a text or element node first tries to
+* claim the node under the cursor: an element with the same tag, or a text
+* node (split when the server merged adjacent texts). A node that does not
+* match is created fresh instead. When a container's children are rendered,
+* one commit operation puts the claimed and created nodes in order and
+* removes whatever the server rendered that the client did not.
+*/
+var HydrationCursor = class HydrationCursor {
+	constructor(stopAt = null) {
+		this.stopAt = stopAt;
+		this.next = /* @__PURE__ */ new Map();
+		this.deferred = [];
+	}
+	/** Consume private SSR metadata emitted immediately before a component output. */
+	claimResourceSlots(container) {
+		let node = this.next.has(container) ? this.next.get(container) : container.firstChild;
+		for (; node && node !== this.stopAt; node = node.nextSibling) {
+			if (node.nodeType === 3 && isInsignificantWhitespace(node)) continue;
+			if (node.nodeType !== 8) return null;
+			const match = /^askr-resource:(r:\d+(?:,r:\d+)*)$/.exec(node.data);
+			if (match) {
+				this.advance(container, node);
+				return match[1].split(",");
+			}
+			if (isRangeMarker(node, "askr-range-start") || isRangeMarker(node, "askr-range-end")) return null;
+		}
+		return null;
+	}
+	/** Server nodes reserved for a portal host whose writer has not hydrated. */
+	heldNodes(container) {
+		if (!this.stopAt) return [];
+		const nodes = [];
+		let node = this.next.has(container) ? this.next.get(container) : container.firstChild;
+		while (node && node !== this.stopAt) {
+			if (node.nodeType !== 8) nodes.push(node);
+			node = node.nextSibling;
+		}
+		return nodes;
+	}
+	/**
+	* Reserve the server nodes at `container`'s cursor for a render that runs
+	* later. A server range (`askr-range-start` ... `askr-range-end`) is skipped
+	* as a whole; the returned cursor claims inside it, or from the reserved
+	* position onward when there is no range.
+	*/
+	reserve(container) {
+		let node = this.next.has(container) ? this.next.get(container) : container.firstChild;
+		while (node && node !== this.stopAt && node.nodeType === 3 && isInsignificantWhitespace(node)) node = node.nextSibling;
+		if (node && isRangeMarker(node, "askr-range-start")) {
+			let depth = 0;
+			let end = node;
+			for (; end && end !== this.stopAt; end = end.nextSibling) if (isRangeMarker(end, "askr-range-start")) depth++;
+			else if (isRangeMarker(end, "askr-range-end") && --depth === 0) break;
+			if (end && end !== this.stopAt) {
+				this.next.set(container, end.nextSibling);
+				const inner = new HydrationCursor(end);
+				inner.next.set(container, node.nextSibling);
+				return inner;
+			}
+		}
+		const later = new HydrationCursor(this.stopAt);
+		later.next.set(container, node);
+		return later;
+	}
+	peek(container) {
+		let node = this.next.has(container) ? this.next.get(container) : container.firstChild;
+		while (node && node !== this.stopAt && (node.nodeType === 8 || node.nodeType === 3 && isInsignificantWhitespace(node))) node = node.nextSibling;
+		return node === this.stopAt ? null : node;
+	}
+	advance(container, node) {
+		this.next.set(container, node.nextSibling);
+	}
+	claimElement(container, tag, namespace) {
+		const node = this.peek(container);
+		if (!node || node.nodeType !== 1) return null;
+		const el = node;
+		const expectedNs = namespace ?? "http://www.w3.org/1999/xhtml";
+		if (!(expectedNs === "http://www.w3.org/1999/xhtml" ? el.localName === tag.toLowerCase() : el.localName === tag)) return null;
+		if ((el.namespaceURI ?? expectedNs) !== expectedNs) return null;
+		this.advance(container, el);
+		return el;
+	}
+	/**
+	* Claim a text node for `text`. A server text that begins with `text` is
+	* split so the remainder stays claimable by the next text; any other
+	* server text is claimed and corrected at commit.
+	*/
+	claimText(container, text) {
+		const node = this.peek(container);
+		if (!node || node.nodeType !== 3) return null;
+		const textNode = node;
+		if (text.length > 0 && textNode.data.length > text.length && textNode.data.startsWith(text)) {
+			const remainder = document.createTextNode(textNode.data.slice(text.length));
+			this.next.set(container, remainder);
+			return textNode;
+		}
+		this.advance(container, textNode);
+		return textNode;
+	}
+};
+function isRangeMarker(node, data) {
+	return node.nodeType === 8 && node.data === data;
+}
+function isInsignificantWhitespace(node) {
+	return node.data.trim() === "" && node.data.includes("\n");
+}
+/**
+* Put `container`'s content in the order `expected`, removing any server
+* node that was not claimed. Nodes after `stopAt` are left alone.
+*/
+function syncChildren(pass, container, expected, stopAt = null) {
+	const previous = Array.from(container.childNodes);
+	pass.onReversibleCommit(() => restoreChildren(container, previous));
+	try {
+		const skipAnchors = (node) => {
+			while (node && node !== stopAt && isSSRPortalHydrationAnchor(node)) node = node.nextSibling;
+			return node;
+		};
+		let cursor = skipAnchors(container.firstChild);
+		for (const node of expected) if (node === cursor) cursor = skipAnchors(cursor.nextSibling);
+		else container.insertBefore(node, cursor);
+		while (cursor && cursor !== stopAt) {
+			const next = cursor.nextSibling;
+			if (!isSSRPortalHydrationAnchor(cursor)) container.removeChild(cursor);
+			cursor = next;
+		}
+	} catch (error) {
+		throw new CommitMutationError(error);
+	}
+}
+function restoreChildren(container, previous) {
+	for (let index = 0; index < previous.length; index++) {
+		const current = container.childNodes[index] ?? null;
+		if (current !== previous[index]) container.insertBefore(previous[index], current);
+	}
+	while (container.childNodes.length > previous.length) container.removeChild(container.lastChild);
+}
+/** Attribute names `props` renders on `el`. */
+function renderedAttributes(el, props) {
+	const names = /* @__PURE__ */ new Set();
+	if (el.localName === "option") {
+		const parent = el.parentElement;
+		const select = parent?.localName === "optgroup" ? parent.parentElement : parent;
+		if (select?.localName === "select" && select.hasAttribute("value")) names.add("selected");
+	}
+	for (const key in props) {
+		if (isSkippedProp(key) || parseEventProp(key)) continue;
+		const value = props[key];
+		if (typeof value !== "function") {
+			if (value === null || value === void 0) continue;
+			if (value === false && !keepsFalseValue(key)) continue;
+		}
+		if (key === "className") {
+			names.add("class");
+			continue;
+		}
+		const name = key.startsWith("attr:") ? key.slice(ATTRIBUTE_PROP_PREFIX.length) : key;
+		names.add(getRenderedAttributeName(el, name));
+	}
+	return names;
+}
+/**
+* Server attributes the client does not render are removed from an adopted
+* element, so a mismatched attribute does not survive hydration.
+*/
+function removeUnrenderedAttributes(el, props, beforeRemove) {
+	const keep = renderedAttributes(el, props);
+	const removed = Array.from(el.attributes).filter((attribute) => !keep.has(attribute.name));
+	beforeRemove?.(removed);
+	for (const attribute of removed) el.removeAttribute(attribute.name);
+}
+//#endregion
+//#region src/core/dom/dom-properties.ts
+/**
+* Per element, the props Askr wrote as DOM properties, mapped to the property
+* name. A property cannot be "removed" like an attribute, so this is what lets
+* an absent prop reset its property.
+*/
+const writtenDomProperties = /* @__PURE__ */ new WeakMap();
+/**
+* Property names `prop:` never assigns: raw HTML sinks (use
+* `dangerouslySetInnerHTML`) and names that would change the prototype chain.
+*/
+const BLOCKED_PROPERTY_NAMES = /* @__PURE__ */ new Set([
+	"innerHTML",
+	"outerHTML",
+	"srcdoc",
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+function isBlockedPropertyName(name) {
+	if (!BLOCKED_PROPERTY_NAMES.has(name)) return false;
+	if (isDevelopmentEnvironment()) logger.warn(`[Askr] ${PROPERTY_PROP_PREFIX}${name} is ignored.`);
+	return true;
+}
+function isUrlPropertyName(name) {
+	const lower = name.toLowerCase();
+	return UNSAFE_URL_SCHEME_ATTRIBUTES.has(lower) || SCRIPT_URL_RESOURCE_ATTRIBUTES.has(lower);
+}
+function writeProperty(el, name, value) {
+	const host = el;
+	if (Object.is(host[name], value)) return;
+	host[name] = value;
+}
+/** Capture property and ownership state before a pass writes a DOM property. */
+function captureDomPropertyUndo(el, key, value, tagName) {
+	const name = getDomPropertyName(tagName, key, value);
+	const written = writtenDomProperties.get(el);
+	const previousName = written?.get(key);
+	if (name === null && previousName === void 0) return null;
+	const names = /* @__PURE__ */ new Set();
+	if (name !== null && !BLOCKED_PROPERTY_NAMES.has(name)) names.add(name);
+	if (previousName !== void 0) names.add(previousName);
+	const host = el;
+	const properties = Array.from(names, (property) => ({
+		property,
+		descriptor: Object.getOwnPropertyDescriptor(host, property),
+		value: host[property]
+	}));
+	const attributeNames = /* @__PURE__ */ new Set();
+	for (const property of names) attributeNames.add(getRenderedAttributeName(el, property));
+	if (!key.startsWith("prop:")) attributeNames.add(getRenderedAttributeName(el, key));
+	const attributes = Array.from(attributeNames, (attribute) => ({
+		attribute,
+		value: el.getAttribute(attribute)
+	}));
+	const hadWrittenMap = written !== void 0;
+	const writtenBefore = written ? new Map(written) : null;
+	return () => {
+		const failures = [];
+		for (const { property, descriptor, value: before } of properties) try {
+			if (descriptor && "value" in descriptor) {
+				Object.defineProperty(host, property, descriptor);
+				continue;
+			}
+			if (!Reflect.set(host, property, before)) throw new TypeError(`Could not restore DOM property ${property}`);
+			if (descriptor) Object.defineProperty(host, property, descriptor);
+			else delete host[property];
+		} catch (error) {
+			failures.push(error);
+		}
+		for (const { attribute, value: before } of attributes) try {
+			if (before === null) el.removeAttribute(attribute);
+			else el.setAttribute(attribute, before);
+		} catch (error) {
+			failures.push(error);
+		}
+		try {
+			if (hadWrittenMap) writtenDomProperties.set(el, new Map(writtenBefore));
+			else writtenDomProperties.delete(el);
+		} catch (error) {
+			failures.push(error);
+		}
+		if (failures.length === 1) throw failures[0];
+		if (failures.length > 1) throw new AggregateError(failures, "DOM property rollback failed");
+	};
+}
+function hasDomPropertyWrite(el, key, value, tagName) {
+	return getDomPropertyName(tagName, key, value) !== null || writtenDomProperties.get(el)?.has(key) === true;
+}
+/**
+* Put a property back to its default once Askr no longer sets it.
+*
+* - `muted`/`indeterminate` become `false`.
+* - A property with a same-named attribute (`href`, `title`, `hidden`,
+*   `className` -> `class`, ...) has that attribute removed, which restores
+*   the element's own default.
+* - An own property (an expando, or a value set before a custom element
+*   upgraded) is deleted.
+* - Otherwise strings become `''` and booleans `false`. Numbers keep their
+*   value (there is no safe generic default), and anything else becomes
+*   `undefined`.
+*/
+function resetProperty(el, key, name) {
+	const host = el;
+	if (isKnownBooleanProperty(key)) {
+		writeProperty(el, name, false);
+		return;
+	}
+	const attributeName = getRenderedAttributeName(el, name);
+	if (el.hasAttribute(attributeName)) {
+		el.removeAttribute(attributeName);
+		return;
+	}
+	if (Object.prototype.hasOwnProperty.call(host, name)) {
+		delete host[name];
+		return;
+	}
+	const current = host[name];
+	if (typeof current === "number") return;
+	writeProperty(el, name, typeof current === "string" ? "" : typeof current === "boolean" ? false : void 0);
+}
+function forgetProperty(el, key) {
+	const written = writtenDomProperties.get(el);
+	const name = written?.get(key);
+	if (name === void 0) return;
+	written.delete(key);
+	resetProperty(el, key, name);
+}
+/**
+* Write a prop that targets a DOM property.
+*
+* Returns `true` when the prop is fully handled, and `false` when the caller
+* must still run the attribute path: for attribute props, and for `muted`,
+* which keeps its attribute alongside the property. A prop that was a
+* property and is now an attribute (a custom element prop that went from an
+* object to a string or `null`) has its property reset first.
+*/
+function applyDomPropertyProp(el, key, value, tagName) {
+	const name = getDomPropertyName(tagName, key, value);
+	if (name === null) {
+		if (isCustomElementName(tagName)) forgetProperty(el, key);
+		return false;
+	}
+	if (isBlockedPropertyName(name)) return true;
+	if (value === null || value === void 0) {
+		forgetProperty(el, key);
+		return true;
+	}
+	let next = domPropertyValue(key, value);
+	if (next !== null && next !== void 0 && isUrlPropertyName(name)) {
+		const text = String(next);
+		if (rejectUnsafeUrlAttribute(name, text)) {
+			forgetProperty(el, key);
+			return true;
+		}
+		if (!isCustomElementName(tagName)) next = text;
+	}
+	let written = writtenDomProperties.get(el);
+	if (!written) {
+		written = /* @__PURE__ */ new Map();
+		writtenDomProperties.set(el, written);
+	}
+	if (!written.has(key)) {
+		written.set(key, name);
+		if (!key.startsWith("prop:") && !isKnownBooleanProperty(key)) {
+			const attributeName = getRenderedAttributeName(el, key);
+			if (el.hasAttribute(attributeName)) el.removeAttribute(attributeName);
+		}
+	}
+	writeProperty(el, name, next);
+	return !propertyReflectsAttribute(key);
+}
+//#endregion
+//#region src/core/dom/prop-values.ts
+/**
+* How a scalar prop value is written to an element: class tokens, owned style
+* properties, form state, DOM properties, URL-guarded attributes, and the
+* `attr:`/`prop:` escape hatches. Shared semantics with SSR attribute
+* serialization; the renderer decides when these run.
+*/
+/** Props whose live DOM property must be synced alongside the attribute. */
+function isFormControlProp(key) {
+	return key === "value" || key === "checked" || key === "selected";
+}
+/** Attribute text for a scalar prop, rendering HTML booleans bare. */
+function renderedScalarValue(el, key, value) {
+	return value === true ? booleanAttributeValue(getRenderedAttributeName(el, key)) : String(value);
+}
+/**
+* The text to write for a scalar attribute prop, or `null` when the renderer
+* never writes it: unsafe URLs, and inline event handler or object values
+* requested through the `attr:` escape hatch (SSR skips those too). The value
+* is converted once, and the checked text is the text written, so a
+* `toString()` cannot pass the URL check and then return something else.
+*/
+function renderableAttributeText(el, key, value) {
+	let name = key;
+	if (key.startsWith("attr:")) {
+		name = key.slice(ATTRIBUTE_PROP_PREFIX.length);
+		if (value !== null && typeof value === "object" || name.slice(0, 2).toLowerCase() === "on") return null;
+	}
+	const text = renderedScalarValue(el, key, value);
+	return rejectUnsafeUrlAttribute(name, text) ? null : text;
+}
+function isDangerousInnerHTMLPayload(value) {
+	return value !== null && typeof value === "object" && "__html" in value;
+}
+function applyDangerousInnerHTMLValue(el, value) {
+	if (!isDangerousInnerHTMLPayload(value)) return;
+	if (isDevelopmentEnvironment()) logger.warn("[Askr] dangerouslySetInnerHTML is being used, which bypasses the framework's normal rendering and can introduce XSS vulnerabilities if the HTML is derived from untrusted input. Make sure the value is sanitized.");
+	const html = value.__html;
+	const nextHtml = html === null || html === void 0 ? "" : String(html);
+	if (hasMatchingInnerHTML(el, nextHtml)) return;
+	el.innerHTML = nextHtml;
+}
+/** Compare parsed HTML without replacing the live descendants. */
+function hasMatchingInnerHTML(el, html) {
+	try {
+		if (el.innerHTML === html) return true;
+		if (el.childNodes.length === 0 || !el.namespaceURI) return false;
+		const probe = el.ownerDocument.createElement("template").content.ownerDocument.createElementNS(el.namespaceURI, el.localName);
+		probe.innerHTML = html;
+		return probe.innerHTML === el.innerHTML;
+	} catch {
+		return false;
+	}
+}
+function applyFormControlProp(el, key, value, tagName) {
+	if (key === "value") {
+		const stringValue = String(value);
+		if (tagNamesEqualIgnoreCase(tagName, "select")) {
+			const select = el;
+			const selectedValues = new Set(select.multiple && Array.isArray(value) ? value.map(String) : [stringValue]);
+			let firstMatch = -1;
+			for (let index = 0; index < select.options.length; index++) {
+				const option = select.options[index];
+				const selected = selectedValues.has(option.value) && (select.multiple || firstMatch < 0);
+				if (selected && firstMatch < 0) firstMatch = index;
+				if (option.hasAttribute("selected") !== selected) {
+					if (selected) option.setAttribute("selected", "");
+					else option.removeAttribute("selected");
+				}
+				if (select.multiple && option.selected !== selected) option.selected = selected;
+			}
+			if (!select.multiple && select.selectedIndex !== firstMatch) select.selectedIndex = firstMatch;
+		} else if (tagNamesEqualIgnoreCase(tagName, "input") || tagNamesEqualIgnoreCase(tagName, "textarea")) {
+			const control = el;
+			if (control.value !== stringValue) control.value = stringValue;
+		}
+		if (el.getAttribute("value") !== stringValue) el.setAttribute("value", stringValue);
+		return;
+	}
+	if (key === "selected") {
+		const selected = Boolean(value);
+		if (tagNamesEqualIgnoreCase(tagName, "option")) {
+			const option = el;
+			if (option.selected !== selected) option.selected = selected;
+		}
+		if (selected) {
+			if (!el.hasAttribute("selected")) el.setAttribute("selected", "");
+		} else if (el.hasAttribute("selected")) el.removeAttribute("selected");
+		return;
+	}
+	if (key === "checked") {
+		if (tagNamesEqualIgnoreCase(tagName, "input")) {
+			const checked = Boolean(value);
+			const input = el;
+			if (input.checked !== checked) input.checked = checked;
+			if (checked) {
+				if (!el.hasAttribute("checked")) el.setAttribute("checked", "");
+			} else if (el.hasAttribute("checked")) el.removeAttribute("checked");
+		} else if (value) {
+			if (!el.hasAttribute("checked")) el.setAttribute("checked", "");
+		} else if (el.hasAttribute("checked")) el.removeAttribute("checked");
+	}
+}
+const IMPORTANT_SUFFIX = " !important";
+function readStyleEntry(style, propertyName) {
+	return style.getPropertyValue(propertyName) + (style.getPropertyPriority(propertyName) ? IMPORTANT_SUFFIX : "");
+}
+function collectStyleEntries(style) {
+	const entries = /* @__PURE__ */ new Map();
+	for (let index = 0; index < style.length; index += 1) {
+		const propertyName = style.item(index);
+		entries.set(propertyName, readStyleEntry(style, propertyName));
+	}
+	return entries;
+}
+function normalizeStyleEntries(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const entries = /* @__PURE__ */ new Map();
+	for (const [key, entryValue] of Object.entries(value)) {
+		if (entryValue === void 0 || entryValue === null || entryValue === false) continue;
+		const propertyName = normalizeStylePropertyName(key);
+		const safeValue = sanitizeCssValue(styleValueText(propertyName, entryValue));
+		if (safeValue) entries.set(propertyName, safeValue);
+	}
+	return entries;
+}
+let scratchStyle = null;
+/** Style entries a prop value renders; `null` when it is not expressible. */
+function readStyleEntries(el, value) {
+	if (value === null || value === void 0 || value === false) return /* @__PURE__ */ new Map();
+	if (typeof value !== "string") return normalizeStyleEntries(value);
+	scratchStyle ??= el.ownerDocument.createElement("div").style;
+	scratchStyle.cssText = value;
+	const entries = collectStyleEntries(scratchStyle);
+	scratchStyle.cssText = "";
+	return entries;
+}
+/**
+* Apply a `style` prop. `previousValue` is the value Askr last applied
+* (`null` when none): only the properties it owns are removed or rewritten, so
+* properties set by other code survive. When `previousValue` is `undefined`
+* the element's whole style is treated as Askr-owned.
+*/
+function applyStylePropValue(el, value, previousValue) {
+	const style = el.style;
+	const isEmpty = value === null || value === void 0 || value === false;
+	if (!style) {
+		if (isEmpty) {
+			el.removeAttribute("style");
+			return;
+		}
+		el.setAttribute("style", String(value));
+		return;
+	}
+	if ((el.getAttribute("style") ?? "") === (isEmpty ? "" : value) || isEmpty && previousValue === null) return;
+	if (previousValue === void 0 && (isEmpty || typeof value === "string")) {
+		style.cssText = isEmpty ? "" : value;
+		if (isEmpty) el.removeAttribute("style");
+		return;
+	}
+	const nextEntries = readStyleEntries(el, value);
+	if (!nextEntries) {
+		style.cssText = String(value);
+		return;
+	}
+	const previousEntries = (previousValue === void 0 ? null : previousValue === value ? nextEntries : readStyleEntries(el, previousValue)) ?? collectStyleEntries(style);
+	let didWrite = false;
+	for (const [propertyName] of previousEntries) {
+		if (nextEntries.has(propertyName) || !style.getPropertyValue(propertyName)) continue;
+		style.removeProperty(propertyName);
+		didWrite = true;
+	}
+	for (const [propertyName, propertyValue] of nextEntries) {
+		if (readStyleEntry(style, propertyName) === propertyValue) continue;
+		const important = propertyValue.endsWith(IMPORTANT_SUFFIX);
+		style.setProperty(propertyName, important ? propertyValue.slice(0, -11) : propertyValue, important ? "important" : "");
+		didWrite = true;
+	}
+	if (isEmpty && style.length === 0) {
+		el.removeAttribute("style");
+		didWrite = true;
+	}
+	if (!didWrite) {}
+}
+function applyStaticScalarPropsToElement(el, props, tagName) {
+	for (const key in props) {
+		if (isSkippedProp(key)) continue;
+		const value = props[key];
+		if (applyDomPropertyProp(el, key, value, tagName)) continue;
+		if (value === void 0 || value === null || value === false && !keepsFalseValue(key)) continue;
+		if (key === "class" || key === "className") writeElementClassName(el, String(value));
+		else if (key === "style") applyStylePropValue(el, value);
+		else if (isFormControlProp(key)) applyFormControlProp(el, key, value, tagName);
+		else if (key === "dangerouslySetInnerHTML") applyDangerousInnerHTMLValue(el, value);
+		else {
+			const text = renderableAttributeText(el, key, value);
+			if (text === null) removeRenderedAttribute(el, key);
+			else setRenderedAttribute(el, key, text);
+		}
+	}
+}
+const EMPTY_CLASS_TOKENS = [];
+/** Class tokens Askr last applied; `null` means unknown. */
+function previousClassTokens(previousValue) {
+	return previousValue === null || previousValue === false ? EMPTY_CLASS_TOKENS : tokenizeClassValue(previousValue);
+}
+function tokenizeClassValue(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return [];
+	return trimmed.split(/\s+/);
+}
+function patchClassList(el, previousTokens, nextTokens) {
+	if (previousTokens.length === nextTokens.length) {
+		let identical = true;
+		for (let index = 0; index < previousTokens.length; index += 1) if (previousTokens[index] !== nextTokens[index]) {
+			identical = false;
+			break;
+		}
+		if (identical) {
+			for (const token of nextTokens) if (!el.classList.contains(token)) el.classList.add(token);
+			return;
+		}
+	}
+	if (previousTokens.length === 0) {
+		if (nextTokens.length === 0) return;
+		el.classList.add(...nextTokens);
+		return;
+	}
+	if (nextTokens.length === 0) {
+		el.classList.remove(...previousTokens);
+		return;
+	}
+	if (previousTokens.length === 1 && nextTokens.length === 1) {
+		el.classList.remove(previousTokens[0]);
+		el.classList.add(nextTokens[0]);
+		return;
+	}
+	const nextSet = new Set(nextTokens);
+	const previousSet = new Set(previousTokens);
+	for (const token of previousTokens) if (!nextSet.has(token)) el.classList.remove(token);
+	for (const token of nextTokens) if (!previousSet.has(token)) el.classList.add(token);
+}
+function applyClassPropValue(el, value, previousValue, descriptor) {
+	const nextString = String(value);
+	if (!descriptor && nextString.length > 0 && readElementClassName(el) === nextString) return;
+	const nextTokens = tokenizeClassValue(nextString);
+	const previousTokens = descriptor?.lastClassTokens ?? previousClassTokens(previousValue);
+	if (nextTokens && previousTokens) {
+		if (Object.is(value, previousValue)) {
+			for (const token of nextTokens) if (!el.classList.contains(token)) el.classList.add(token);
+			return;
+		}
+		patchClassList(el, previousTokens, nextTokens);
+		dropEmptySvgClass(el);
+		if (descriptor) descriptor.lastClassTokens = nextTokens;
+		return;
+	}
+	writeElementClassName(el, nextString);
+	if (descriptor) descriptor.lastClassTokens = nextTokens;
+}
+/** An SVG element renders no `class` attribute for an empty class list. */
+function dropEmptySvgClass(el) {
+	if (isSVGDomElement(el) && el.getAttribute("class") === "") el.removeAttribute("class");
+}
+function applyScalarPropValue(el, key, value, tagName, previousValue, descriptor) {
+	if (key === "dangerouslySetInnerHTML" && !isDangerousInnerHTMLPayload(value)) return;
+	if (applyDomPropertyProp(el, key, value, tagName)) return;
+	if (value === void 0 || value === null || value === false && !keepsFalseValue(key)) {
+		if (key === "class" || key === "className") {
+			const previousTokens = descriptor ? descriptor.lastClassTokens : previousClassTokens(previousValue);
+			if (previousTokens === null) writeElementClassName(el, "");
+			else if (previousTokens.length > 0) {
+				el.classList.remove(...previousTokens);
+				dropEmptySvgClass(el);
+			}
+			if (descriptor) descriptor.lastClassTokens = [];
+		} else if (key === "value") applyFormControlProp(el, key, "", tagName);
+		else if (key === "checked" || key === "selected") applyFormControlProp(el, key, false, tagName);
+		else if (key === "style") applyStylePropValue(el, null, previousValue);
+		else removeRenderedAttribute(el, key);
+		return;
+	}
+	if (key === "class" || key === "className") applyClassPropValue(el, value, previousValue, descriptor);
+	else if (key === "style") applyStylePropValue(el, value, previousValue);
+	else if (isFormControlProp(key)) applyFormControlProp(el, key, value, tagName);
+	else if (key === "dangerouslySetInnerHTML") applyDangerousInnerHTMLValue(el, value);
+	else {
+		const nextValue = renderableAttributeText(el, key, value);
+		if (nextValue === null) {
+			removeRenderedAttribute(el, key);
+			return;
+		}
+		const attributeName = getRenderedAttributeName(el, key);
+		if (el.getAttribute(attributeName) === nextValue) return;
+		writeAttribute(el, attributeName, nextValue);
+	}
+}
+//#endregion
+//#region src/core/dom/refs.ts
+/**
+* Refs: a callback receives the element (then null on removal); an object
+* ref's `current` is assigned. A read-only object ref is ignored.
+*/
+function setRef(ref, value) {
+	if (!ref) return;
+	if (typeof ref === "function") {
+		ref(value);
+		return;
+	}
+	try {
+		ref.current = value;
+	} catch {}
+}
+//#endregion
+//#region src/core/dom/tree.ts
+const HOST = 0;
+const DYNAMIC = 4;
+/** Parents whose children are DOM children of one element. */
+function isContainer(parent) {
+	return parent.kind === HOST || parent.kind === 5;
+}
+function containerElement(parent) {
+	return parent.el;
+}
+/** The element that directly contains `parent`'s DOM. */
+function containerOf(parent) {
+	for (let p = parent; p; p = p.parent) if (isContainer(p)) return containerElement(p);
+	throw new Error("[Askr] Rendered node is not attached to a container.");
+}
+function firstDom(node) {
+	const pending = [node];
+	while (pending.length) {
+		const current = pending.pop();
+		switch (current.kind) {
+			case HOST: return current.el;
+			case 1:
+			case 7: return current.node;
+			default: for (let i = current.children.length - 1; i >= 0; i--) pending.push(current.children[i]);
+		}
+	}
+	return null;
+}
+function collectDom(node, out = []) {
+	const pending = [node];
+	while (pending.length) {
+		const current = pending.pop();
+		switch (current.kind) {
+			case HOST:
+				out.push(current.el);
+				break;
+			case 1:
+			case 7:
+				out.push(current.node);
+				break;
+			default: for (let i = current.children.length - 1; i >= 0; i--) pending.push(current.children[i]);
+		}
+	}
+	return out;
+}
+/**
+* The DOM node that content at the end of `parent` must be inserted before:
+* null for an element's children, otherwise the first DOM after `parent`.
+*/
+function endOf(parent) {
+	if (parent.kind === 5) return parent.tail?.parentNode === parent.el ? parent.tail : null;
+	if (isContainer(parent)) return null;
+	return nextDomAfter(parent);
+}
+/** The first DOM node after `node`'s own DOM within its container. */
+function nextDomAfter(node) {
+	let current = node;
+	for (let parent = current.parent; parent; parent = current.parent) {
+		const siblings = parent.children;
+		for (let i = siblings.indexOf(current) + 1; i < siblings.length; i++) {
+			const dom = firstDom(siblings[i]);
+			if (dom) return dom;
+		}
+		if (parent.kind === 5) return parent.tail?.parentNode === parent.el ? parent.tail : null;
+		if (isContainer(parent)) return null;
+		current = parent;
+	}
+	return null;
+}
+//#endregion
+//#region src/core/dom/teardown.ts
+/**
+* Failures while tearing down removed content are reported after the update,
+* never thrown into it: the DOM change has already happened and is not
+* rolled back.
+*/
+function reportTeardown(errors) {
+	if (errors.length === 1) reportUncaughtErrorLater(errors[0]);
+	else if (errors.length > 1) reportUncaughtErrorLater(new AggregateError(errors, "Cleanup failed while removing content"));
+}
+//#endregion
+//#region src/core/dom/props.ts
+function isBinding(key, value) {
+	return typeof value === "function" && key !== "ref" && key !== "dangerouslySetInnerHTML";
+}
+/** A `<select>` value can only select options that already exist. */
+function followsChildren(tag, key) {
+	return key === "value" && tag === "select";
+}
+function isSimpleAttribute(tag, key, value) {
+	return !isCustomElementName(tag) && !key.includes(":") && getDomPropertyName(tag, key, value) === null && key !== "class" && key !== "className" && key !== "style" && key !== "value" && key !== "checked" && key !== "selected" && key !== "dangerouslySetInnerHTML";
+}
+function isInputValue(tag, key) {
+	return key === "value" && (tag === "input" || tag === "textarea");
+}
+function isBooleanControl(tag, key) {
+	return tag === "input" && key === "checked" || tag === "option" && key === "selected";
+}
+/** Record the live attribute before applying a reversible scalar write. */
+function writeSimpleAttribute(pass, node, key, value, previous, beforeApply) {
+	const { el, tag } = node;
+	const name = getRenderedAttributeName(el, key);
+	pass.op(() => {
+		recordAttributeUndo(pass, el, name);
+		try {
+			beforeApply?.();
+			applyScalarPropValue(el, key, value, tag, previous);
+		} catch (error) {
+			throw new CommitMutationError(error);
+		}
+	});
+}
+/** Record a reflected class or style write for an abortable commit. */
+function writeReflectedProp(pass, node, key, apply, beforeApply) {
+	const { el } = node;
+	const name = getRenderedAttributeName(el, key);
+	pass.op(() => {
+		recordAttributeUndo(pass, el, name);
+		try {
+			beforeApply?.();
+			apply();
+		} catch (error) {
+			throw new CommitMutationError(error);
+		}
+	});
+}
+function recordAttributeUndo(pass, el, name) {
+	const namespace = attributeNamespace(el.namespaceURI, name);
+	const colon = name.indexOf(":");
+	const localName = colon === -1 ? name : name.slice(colon + 1);
+	const before = namespace ? el.getAttributeNS(namespace, localName) : el.getAttribute(name);
+	pass.onReversibleCommit(() => {
+		if (before === null) {
+			if (namespace) el.removeAttributeNS(namespace, localName);
+			else el.removeAttribute(name);
+		} else if (namespace) el.setAttributeNS(namespace, name, before);
+		else el.setAttribute(name, before);
+	});
+}
+/** Restore exact child identities without needlessly disconnecting unchanged nodes. */
+function restoreElementChildren(el, children) {
+	if (el.childNodes.length === children.length) {
+		let unchanged = true;
+		for (let index = 0; index < children.length; index += 1) if (el.childNodes[index] !== children[index]) {
+			unchanged = false;
+			break;
+		}
+		if (unchanged) return;
+	}
+	el.replaceChildren(...children);
+}
+/** Make property-backed scalar writes part of the pass rollback journal. */
+function writePropertyScalar(pass, node, key, value, apply) {
+	pass.op(() => {
+		try {
+			const undo = captureDomPropertyUndo(node.el, key, value, node.tag);
+			if (undo) pass.onReversibleCommit(undo);
+			apply();
+		} catch (error) {
+			throw new CommitMutationError(error);
+		}
+	});
+}
+function queueScalarProp(pass, node, key, value, apply) {
+	if (key === "dangerouslySetInnerHTML") {
+		if (!isDangerousInnerHTMLPayload(value)) {
+			pass.op(apply);
+			return;
+		}
+		pass.op(() => {
+			const children = Array.from(node.el.childNodes);
+			pass.onReversibleCommit(() => restoreElementChildren(node.el, children));
+			try {
+				apply();
+			} catch (error) {
+				if (error instanceof CommitMutationError) throw error;
+				throw new CommitMutationError(error);
+			}
+		});
+		return;
+	}
+	if (hasDomPropertyWrite(node.el, key, value, node.tag)) writePropertyScalar(pass, node, key, value, apply);
+	else pass.op(() => {
+		recordAttributeUndo(pass, node.el, getRenderedAttributeName(node.el, key));
+		try {
+			apply();
+		} catch (error) {
+			if (error instanceof CommitMutationError) throw error;
+			throw new CommitMutationError(error);
+		}
+	});
+}
+/** Remove a committed binding provisionally and restore it if the pass aborts. */
+function retireBindingForCommit(pass, node, key) {
+	const binding = node.bindings?.get(key);
+	if (!binding) return void 0;
+	node.bindings.delete(key);
+	pass.onReversibleCommit(() => {
+		(node.bindings ??= /* @__PURE__ */ new Map()).set(key, binding);
+	}, () => reportTeardown(binding.dispose()));
+	return binding;
+}
+/** Restore or remove a binding-map entry when a provisional install aborts. */
+function recordBindingInstallUndo(pass, node, key, binding, previous) {
+	pass.onReversibleCommit(() => {
+		if (node.bindings?.get(key) !== binding) return;
+		if (previous) node.bindings.set(key, previous);
+		else {
+			node.bindings.delete(key);
+			if (node.bindings.size === 0) node.bindings = null;
+		}
+	});
+}
+/** Restore both the reflected attribute and the live form value on abort. */
+function writeInputValue(pass, node, value, previous) {
+	const { el, tag } = node;
+	pass.op(() => {
+		recordInputValueUndo(pass, node);
+		try {
+			applyScalarPropValue(el, "value", value, tag, previous);
+		} catch (error) {
+			throw new CommitMutationError(error);
+		}
+	});
+}
+/** Restore a checkbox or option's live state and reflected attribute. */
+function writeBooleanControl(pass, node, key, value, previous) {
+	const { el, tag } = node;
+	pass.op(() => {
+		recordBooleanControlUndo(pass, node, key);
+		try {
+			applyScalarPropValue(el, key, value, tag, previous);
+		} catch (error) {
+			throw new CommitMutationError(error);
+		}
+	});
+}
+function recordInputValueUndo(pass, node) {
+	const control = node.el;
+	const beforeValue = control.value;
+	const beforeAttribute = node.el.getAttribute("value");
+	pass.onReversibleCommit(() => {
+		if (beforeAttribute === null) node.el.removeAttribute("value");
+		else node.el.setAttribute("value", beforeAttribute);
+		control.value = beforeValue;
+	});
+}
+function recordBooleanControlUndo(pass, node, key) {
+	const control = node.el;
+	const beforeValue = control[key];
+	const beforeAttribute = node.el.getAttribute(key);
+	pass.onReversibleCommit(() => {
+		if (beforeAttribute === null) node.el.removeAttribute(key);
+		else node.el.setAttribute(key, beforeAttribute);
+		control[key] = beforeValue;
+	});
+}
+/** The last value each binding applied, for diffing its next write. */
+const appliedByBinding = /* @__PURE__ */ new WeakMap();
+function lastApplied(binding) {
+	return binding ? appliedByBinding.get(binding) : void 0;
+}
+function setHandler(node, key, value) {
+	const event = parseEventProp(key);
+	if (typeof value === "function") setListener(node.listeners ??= /* @__PURE__ */ new Map(), node.el, key, event, value, node.owner);
+	else if (node.listeners) removeListener(node.listeners, node.el, key);
+}
+function setHandlerForCommit(pass, node, key, value, previous) {
+	pass.op(() => {
+		pass.onReversibleCommit(() => setHandler(node, key, previous));
+		try {
+			setHandler(node, key, value);
+		} catch (error) {
+			throw new CommitMutationError(error);
+		}
+	});
+}
+/**
+* Write props to an element that has no committed props yet: a new, detached
+* element (written now) or an adopted server element (`adopted`: recorded as
+* commit operations).
+*/
+function applyInitialProps(pass, node, adopted = false) {
+	const props = node.props;
+	let scalars = null;
+	const flushScalars = () => {
+		if (!scalars) return;
+		const batch = scalars;
+		scalars = null;
+		if (adopted) for (const key in batch) {
+			const value = batch[key];
+			if (isInputValue(node.tag, key)) writeInputValue(pass, node, value, void 0);
+			else if (isBooleanControl(node.tag, key)) writeBooleanControl(pass, node, key, value, void 0);
+			else if (isSimpleAttribute(node.tag, key, value)) writeSimpleAttribute(pass, node, key, value, void 0);
+			else if (key === "class" || key === "className" || key === "style") writeReflectedProp(pass, node, key, () => applyStaticScalarPropsToElement(node.el, { [key]: value }, node.tag));
+			else queueScalarProp(pass, node, key, value, () => applyStaticScalarPropsToElement(node.el, { [key]: value }, node.tag));
+		}
+		else applyStaticScalarPropsToElement(node.el, batch, node.tag);
+	};
+	for (const key in props) {
+		if (isSkippedProp(key)) continue;
+		const value = props[key];
+		if (parseEventProp(key)) {
+			flushScalars();
+			if (adopted) setHandlerForCommit(pass, node, key, value, void 0);
+			else {
+				setHandler(node, key, value);
+				recordUndo(() => setHandler(node, key, void 0));
+			}
+		} else if (isBinding(key, value)) {
+			flushScalars();
+			if (!followsChildren(node.tag, key)) bind(pass, node, key, value, void 0, !adopted);
+		} else if (!followsChildren(node.tag, key)) (scalars ??= {})[key] = value;
+	}
+	flushScalars();
+}
+/** Write props that must follow the element's children. */
+function captureSelectUndo(select) {
+	const beforeValue = select.getAttribute("value");
+	const beforeIndex = select.selectedIndex;
+	const beforeOptions = Array.from(select.options, (option) => ({
+		option,
+		selected: option.selected,
+		attribute: option.hasAttribute("selected")
+	}));
+	return () => {
+		if (beforeValue === null) select.removeAttribute("value");
+		else select.setAttribute("value", beforeValue);
+		for (const { option, attribute } of beforeOptions) if (attribute) option.setAttribute("selected", "");
+		else option.removeAttribute("selected");
+		if (select.multiple) for (const { option, selected } of beforeOptions) option.selected = selected;
+		else select.selectedIndex = beforeIndex;
+	};
+}
+function recordSelectUndo(pass, node) {
+	pass.onReversibleCommit(captureSelectUndo(node.el));
+}
+function applyTrailingProps(pass, node, props, initial = false, adopted = false) {
+	if (node.tag !== "select" || !("value" in props)) return;
+	if (initial && adopted) pass.op(() => recordSelectUndo(pass, node));
+	if (typeof props.value === "function") {
+		if (initial) bind(pass, node, "value", props.value, void 0, !adopted);
+		else node.bindings?.get("value")?.run();
+		return;
+	}
+	const writeValue = () => {
+		try {
+			applyScalarPropValue(node.el, "value", props.value, node.tag, void 0);
+		} catch (error) {
+			if (initial && !adopted) throw error;
+			throw new CommitMutationError(error);
+		}
+	};
+	if (initial && adopted) pass.op(writeValue);
+	else writeValue();
+}
+/** The select whose options include content under `parent`, if any. */
+function enclosingSelect(parent) {
+	for (let p = parent; p; p = p.parent) {
+		if (p.kind !== HOST) {
+			if (p.kind === 5) return null;
+			continue;
+		}
+		if (p.tag === "select") return p;
+		if (p.tag !== "optgroup" && p.tag !== "option") return null;
+	}
+	return null;
+}
+/**
+* Re-apply a committed select's controlled value against its current
+* options. Its options changed without the select itself being patched.
+*/
+function resyncSelect(select) {
+	if (select.dormant || !("value" in select.props)) return;
+	const value = select.props.value;
+	const resolved = typeof value === "function" ? readValue(value) : value;
+	const undo = captureSelectUndo(select.el);
+	try {
+		applyScalarPropValue(select.el, "value", resolved, select.tag, void 0);
+	} catch (error) {
+		try {
+			undo();
+		} catch (rollbackError) {
+			throw new AggregateError([error, rollbackError], "Controlled select resynchronization and rollback failed");
+		}
+		throw error;
+	}
+}
+/** Record the writes that turn `previous` into `next` on a committed element. */
+function patchProps(pass, node, previous, next) {
+	const { el, tag } = node;
+	for (const key in previous) {
+		if (key in next || isSkippedProp(key)) continue;
+		if (followsChildren(tag, key)) pass.op(() => recordSelectUndo(pass, node));
+		const old = previous[key];
+		if (parseEventProp(key)) setHandlerForCommit(pass, node, key, void 0, old);
+		else if (!isBinding(key, old) && isInputValue(tag, key)) writeInputValue(pass, node, void 0, old);
+		else if (!isBinding(key, old) && isBooleanControl(tag, key)) writeBooleanControl(pass, node, key, void 0, old);
+		else if (!isBinding(key, old) && isSimpleAttribute(tag, key, void 0)) writeSimpleAttribute(pass, node, key, void 0, old);
+		else if (!isBinding(key, old) && (key === "class" || key === "className" || key === "style")) writeReflectedProp(pass, node, key, () => applyScalarPropValue(el, key, void 0, tag, old));
+		else if (isBinding(key, old) && isSimpleAttribute(tag, key, void 0)) {
+			const binding = node.bindings?.get(key);
+			writeSimpleAttribute(pass, node, key, void 0, lastApplied(binding), () => retireBindingForCommit(pass, node, key));
+		} else if (isBinding(key, old) && (key === "class" || key === "className" || key === "style")) {
+			const binding = node.bindings?.get(key);
+			writeReflectedProp(pass, node, key, () => applyScalarPropValue(el, key, void 0, tag, lastApplied(binding)), () => retireBindingForCommit(pass, node, key));
+		} else queueScalarProp(pass, node, key, void 0, () => {
+			const binding = retireBindingForCommit(pass, node, key);
+			const from = isBinding(key, old) ? lastApplied(binding) : old;
+			try {
+				applyScalarPropValue(el, key, void 0, tag, from);
+			} catch (error) {
+				if (!followsChildren(tag, key)) throw error;
+				throw new CommitMutationError(error);
+			}
+		});
+	}
+	for (const key in next) {
+		if (isSkippedProp(key)) continue;
+		if (followsChildren(tag, key)) pass.op(() => recordSelectUndo(pass, node));
+		const value = next[key];
+		const old = previous[key];
+		if (parseEventProp(key)) {
+			if (value !== old) setHandlerForCommit(pass, node, key, value, old);
+			continue;
+		}
+		if (isBinding(key, value)) {
+			if (value === old && node.bindings?.has(key)) continue;
+			const replaced = node.bindings?.get(key);
+			const from = replaced ? lastApplied(replaced) : old;
+			pass.op(() => retireBindingForCommit(pass, node, key));
+			bind(pass, node, key, value, from, false);
+			continue;
+		}
+		if (isBinding(key, old)) {
+			const binding = node.bindings?.get(key);
+			const from = lastApplied(binding);
+			if (isSimpleAttribute(tag, key, value)) writeSimpleAttribute(pass, node, key, value, from, () => retireBindingForCommit(pass, node, key));
+			else if (key === "class" || key === "className" || key === "style") writeReflectedProp(pass, node, key, () => applyScalarPropValue(el, key, value, tag, from), () => retireBindingForCommit(pass, node, key));
+			else queueScalarProp(pass, node, key, value, () => {
+				const current = retireBindingForCommit(pass, node, key);
+				applyScalarPropValue(el, key, value, tag, lastApplied(current));
+			});
+			continue;
+		}
+		if (Object.is(value, old) && key === "dangerouslySetInnerHTML") continue;
+		if (isInputValue(tag, key)) writeInputValue(pass, node, value, old);
+		else if (isBooleanControl(tag, key)) writeBooleanControl(pass, node, key, value, old);
+		else if (isSimpleAttribute(tag, key, value)) writeSimpleAttribute(pass, node, key, value, old);
+		else if (key === "class" || key === "className" || key === "style") writeReflectedProp(pass, node, key, () => applyScalarPropValue(el, key, value, tag, old));
+		else queueScalarProp(pass, node, key, value, () => {
+			try {
+				applyScalarPropValue(el, key, value, tag, old);
+			} catch (error) {
+				if (!followsChildren(tag, key)) throw error;
+				throw new CommitMutationError(error);
+			}
+		});
+	}
+}
+function bind(pass, node, key, read, previousValue, fresh) {
+	const { el, tag } = node;
+	let last = previousValue;
+	let installing = true;
+	let propertyBacked = false;
+	const binding = new Computation(node.owner, () => {
+		try {
+			const value = key.startsWith("prop:") ? read() : readValue(read);
+			propertyBacked = hasDomPropertyWrite(el, key, value, tag);
+			const propertyUndo = propertyBacked ? captureDomPropertyUndo(el, key, value, tag) : null;
+			if (propertyUndo && installing && !fresh) pass.onReversibleCommit(propertyUndo);
+			try {
+				applyScalarPropValue(el, key, value, tag, last);
+			} catch (error) {
+				if (propertyUndo && (fresh || !installing)) try {
+					propertyUndo();
+				} catch (rollbackError) {
+					throw new AggregateError([error, rollbackError], "Bound DOM property write and rollback failed");
+				}
+				throw error;
+			}
+			const changed = !Object.is(last, value);
+			last = value;
+			if (changed && tag === "option" && key === "value") {
+				const select = enclosingSelect(node.parent);
+				if (select) resyncSelect(select);
+			}
+			appliedByBinding.set(binding, value);
+		} catch (error) {
+			if (!deliverToBoundary(node.owner, error)) throw error;
+		}
+	}, effectScheduler("effect", (node.owner?.depth ?? 0) + 1), null, "previous");
+	pass.own(binding);
+	const install = () => {
+		const previous = node.bindings?.get(key);
+		(node.bindings ??= /* @__PURE__ */ new Map()).set(key, binding);
+		const reversibleAttribute = isSimpleAttribute(tag, key, void 0) || key === "class" || key === "className" || key === "style";
+		const reversibleControl = isInputValue(tag, key) || isBooleanControl(tag, key);
+		if (!fresh) {
+			recordBindingInstallUndo(pass, node, key, binding, previous);
+			if (reversibleAttribute) recordAttributeUndo(pass, el, getRenderedAttributeName(el, key));
+			else if (isInputValue(tag, key)) recordInputValueUndo(pass, node);
+			else if (isBooleanControl(tag, key)) recordBooleanControlUndo(pass, node, key);
+		}
+		try {
+			binding.run();
+			if (binding._hasError) throw binding._error;
+		} catch (error) {
+			if (!fresh && (reversibleAttribute || reversibleControl || propertyBacked)) throw new CommitMutationError(error);
+			throw error;
+		} finally {
+			installing = false;
+		}
+	};
+	if (fresh) install();
+	else pass.op(install);
+}
+/** Point the element's ref at it once the pass commits. */
+function attachRef(pass, node, previous) {
+	const ref = node.props.ref;
+	if (ref === previous) return;
+	const el = node.el;
+	pass.after(() => {
+		if (previous) setRef(previous, null);
+		if (ref) setRef(ref, el);
+	});
+}
+/** End a removed element's bindings, listeners, and ref. */
+function releaseProps(node, errors) {
+	if (node.bindings) {
+		for (const binding of node.bindings.values()) binding.dispose(errors);
+		node.bindings = null;
+	}
+	if (node.listeners) removeAllListeners(node.listeners, node.el, errors);
+	const ref = node.props.ref;
+	if (ref) try {
+		setRef(ref, null);
+	} catch (error) {
+		errors.push(error);
+	}
+}
+//#endregion
+//#region src/core/dom/reconcile.ts
+function withOwner(ctx, owner) {
+	return owner === ctx.owner ? ctx : {
+		...ctx,
+		owner
+	};
+}
+function typeOf(node) {
+	switch (node.kind) {
+		case HOST: return node.tag;
+		case 2: return node.instance.fn;
+		case 7: return node.node;
+		default: return node.kind;
+	}
+}
+function matches(node, child) {
+	return node.kind === child.kind && typeOf(node) === descriptorType(child);
+}
+/**
+* Reconcile `parent`'s children against `value`.
+*
+* With `fresh`, `parent` is new: its children are built and, for an element,
+* appended to it directly. Otherwise the committed list is replaced by an
+* operation. Returns the new child list.
+*/
+function reconcileChildren(ctx, parent, value, fresh, checkKeys = true) {
+	const next = normalizeChildren(value);
+	if (fresh) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const child of next) {
+			if (child.key === void 0) continue;
+			if (seen.has(child.key)) throw new Error(`[Askr] Duplicate key ${String(child.key)} among siblings.`);
+			seen.add(child.key);
+		}
+		const result = next.map((child) => ctx.nodes.create(ctx, parent, child));
+		if (parent.kind === HOST) {
+			if (ctx.hydrate?.container === parent.el) {
+				const el = parent.el;
+				ctx.pass.op(() => syncChildren(ctx.pass, el, result.flatMap((node) => collectDom(node))));
+			} else for (const node of result) for (const dom of collectDom(node)) parent.el.appendChild(dom);
+		}
+		return result;
+	}
+	const previous = parent.children;
+	if (next.length === previous.length) {
+		let samePositions = true;
+		for (let i = 0; i < next.length; i++) if (next[i].key !== previous[i].key || !matches(previous[i], next[i])) {
+			samePositions = false;
+			break;
+		}
+		if (samePositions) {
+			const result = previous.slice();
+			for (let i = 0; i < next.length; i++) ctx.nodes.patch(ctx, previous[i], next[i]);
+			return result;
+		}
+	}
+	const slot = ctx.pass.reserve();
+	const index = indexChildren(previous);
+	const used = new Uint8Array(previous.length);
+	const sources = new Int32Array(next.length).fill(-1);
+	const result = [];
+	const cursors = /* @__PURE__ */ new Map();
+	let seen = null;
+	for (let i = 0; i < next.length; i++) {
+		const child = next[i];
+		let match = -1;
+		if (child.key !== void 0) {
+			seen ??= /* @__PURE__ */ new Set();
+			if (seen.has(child.key)) throw new Error(`[Askr] Duplicate key ${String(child.key)} among siblings.`);
+			seen.add(child.key);
+			const at = index.keyed?.get(child.key);
+			if (at !== void 0 && !used[at] && matches(previous[at], child)) match = at;
+		} else {
+			const type = descriptorType(child);
+			const bucket = index.unkeyed?.get(type);
+			if (bucket) {
+				let cursor = cursors.get(type) ?? 0;
+				while (cursor < bucket.length && used[bucket[cursor]]) cursor++;
+				if (cursor < bucket.length && matches(previous[bucket[cursor]], child)) {
+					match = bucket[cursor];
+					cursor++;
+				}
+				cursors.set(type, cursor);
+			}
+		}
+		if (match >= 0) {
+			used[match] = 1;
+			sources[i] = match;
+			ctx.nodes.patch(ctx, previous[match], child);
+			result.push(previous[match]);
+		} else result.push(ctx.nodes.create(ctx, parent, child));
+	}
+	const removed = previous.filter((_, i) => !used[i]);
+	if (removed.length === 0 && result.length === previous.length && result.every((node, index) => node === previous[index])) return result;
+	const stable = longestIncreasingSubsequence(sources);
+	const nodes = ctx.nodes;
+	nodes.listChanged?.(ctx, parent);
+	ctx.pass.fill(slot, () => {
+		const positions = [];
+		const record = (node) => {
+			positions.push({
+				node,
+				parent: node.parentNode,
+				next: node.nextSibling
+			});
+		};
+		ctx.pass.onReversibleCommit(() => {
+			for (let index = positions.length - 1; index >= 0; index--) {
+				const { node, parent, next } = positions[index];
+				if (!parent) node.parentNode?.removeChild(node);
+				else if (node.parentNode !== parent || node.nextSibling !== next) parent.insertBefore(node, next);
+			}
+			parent.children = previous;
+		}, () => {
+			const errors = [];
+			for (const node of removed) nodes.release(node, errors);
+			reportTeardown(errors);
+		});
+		try {
+			placeChildren(parent, result, sources, stable, record);
+			for (const node of removed) for (const dom of collectDom(node)) {
+				record(dom);
+				dom.parentNode?.removeChild(dom);
+			}
+		} catch (error) {
+			throw new CommitMutationError(error);
+		}
+		parent.children = result;
+		for (const node of result) if (node.parent !== parent) node.parent = parent;
+	});
+	return result;
+}
+function indexChildren(children) {
+	const index = {
+		keyed: null,
+		unkeyed: null
+	};
+	for (let i = 0; i < children.length; i++) {
+		const node = children[i];
+		if (node.key !== void 0) {
+			(index.keyed ??= /* @__PURE__ */ new Map()).set(node.key, i);
+			continue;
+		}
+		const type = typeOf(node);
+		const bucket = (index.unkeyed ??= /* @__PURE__ */ new Map()).get(type);
+		if (bucket) bucket.push(i);
+		else index.unkeyed.set(type, [i]);
+	}
+	return index;
+}
+/**
+* Put `children`'s DOM in order, walking backwards from the end so every
+* insertion has a settled reference node. Reused children on the stable
+* subsequence stay where they are.
+*/
+function placeChildren(parent, children, sources, stable, record) {
+	const container = containerOf(parent);
+	let next = endOf(parent);
+	for (let i = children.length - 1; i >= 0; i--) {
+		const node = children[i];
+		if (sources[i] >= 0 && stable.has(i)) {
+			next = firstDom(node) ?? next;
+			continue;
+		}
+		const nodes = collectDom(node);
+		for (let j = nodes.length - 1; j >= 0; j--) {
+			const dom = nodes[j];
+			if (dom.parentNode !== container || dom.nextSibling !== next) {
+				record(dom);
+				container.insertBefore(dom, next);
+			}
+			next = dom;
+		}
+	}
+}
+/** Indices of a longest increasing run of `sources` values (ignoring -1). */
+function longestIncreasingSubsequence(sources) {
+	const tails = [];
+	const previous = new Int32Array(sources.length).fill(-1);
+	for (let i = 0; i < sources.length; i++) {
+		const value = sources[i];
+		if (value < 0) continue;
+		let low = 0;
+		let high = tails.length;
+		while (low < high) {
+			const mid = low + high >> 1;
+			if (sources[tails[mid]] < value) low = mid + 1;
+			else high = mid;
+		}
+		if (low > 0) previous[i] = tails[low - 1];
+		tails[low] = i;
+	}
+	const result = /* @__PURE__ */ new Set();
+	for (let i = tails.length ? tails[tails.length - 1] : -1; i >= 0; i = previous[i]) result.add(i);
+	return result;
+}
+//#endregion
+//#region src/core/dom/nodes.ts
+const SVG_NS = "http://www.w3.org/2000/svg";
+const MATHML_NS = "http://www.w3.org/1998/Math/MathML";
+/** Namespace for children of an element in namespace `ns` with tag `tag`. */
+function childNamespace(tag, ns) {
+	if (tag === "svg") return SVG_NS;
+	if (tag === "math") return MATHML_NS;
+	if (ns === SVG_NS && tag === "foreignObject") return null;
+	return ns;
+}
+function elementNamespace(tag, parentNs) {
+	if (tag === "svg") return SVG_NS;
+	if (tag === "math") return MATHML_NS;
+	return parentNs;
+}
+/** Namespace new children of `parent` are created in. */
+function namespaceAt(parent) {
+	for (let p = parent; p; p = p.parent) {
+		if (p.kind === HOST) return childNamespace(p.tag, namespaceOf(p.el));
+		if (p.kind === 5) return childNamespace(p.el.localName, namespaceOf(p.el));
+	}
+	return null;
+}
+function createRenderContext(pass, owner, ns, hydrate = null) {
+	return {
+		pass,
+		owner,
+		ns,
+		nodes: domNodes,
+		hydrate
+	};
+}
+/** Schedules a standalone update of a function child (see `updates`). */
+let scheduleDynamicUpdate = () => {};
+function setDynamicUpdateScheduler(schedule) {
+	scheduleDynamicUpdate = schedule;
+}
+function nearestInstance(owner) {
+	for (let o = owner; o; o = o.parent) if (o instanceof ComponentInstance) return o;
+	return null;
+}
+function createHost(ctx, parent, key, tag, props) {
+	const ns = elementNamespace(tag, ctx.ns);
+	const hydrate = ctx.hydrate;
+	const adopted = hydrate ? hydrate.cursor.claimElement(hydrate.container, tag, ns) : null;
+	const el = adopted ?? (ns ? document.createElementNS(ns, tag) : document.createElement(tag));
+	const node = {
+		kind: HOST,
+		parent,
+		key,
+		el,
+		tag,
+		props,
+		children: [],
+		bindings: null,
+		listeners: null,
+		owner: nearestInstance(ctx.owner)
+	};
+	if (adopted?.hasAttribute(SKIP_HYDRATE)) {
+		ctx.pass.hasDormantPortalWriter ||= containsPortalWriterAnchor(adopted);
+		node.dormant = {
+			owner: ctx.owner,
+			ns
+		};
+		ctx.pass.op(() => {
+			const previous = dormantHosts.get(adopted);
+			ctx.pass.onReversibleCommit(() => {
+				if (previous) dormantHosts.set(adopted, previous);
+				else dormantHosts.delete(adopted);
+			});
+			dormantHosts.set(adopted, node);
+		});
+		return node;
+	}
+	applyInitialProps(ctx.pass, node, adopted !== null);
+	if (adopted) ctx.pass.op(() => {
+		try {
+			removeUnrenderedAttributes(adopted, props, (attributes) => {
+				ctx.pass.onReversibleCommit(() => {
+					for (const attribute of attributes) adopted.setAttributeNode(attribute);
+				});
+			});
+		} catch (error) {
+			throw new CommitMutationError(error);
+		}
+	});
+	if (!isDangerousInnerHTMLPayload(props.dangerouslySetInnerHTML)) node.children = reconcileChildren({
+		...ctx,
+		ns: childNamespace(tag, ns),
+		hydrate: adopted && hydrate ? {
+			cursor: hydrate.cursor,
+			container: adopted
+		} : null
+	}, node, props.children, true);
+	applyTrailingProps(ctx.pass, node, props, true, adopted !== null);
+	attachRef(ctx.pass, node, void 0);
+	return node;
+}
+const SKIP_HYDRATE = "data-skip-hydrate";
+const dormantHosts = /* @__PURE__ */ new WeakMap();
+function containsPortalWriterAnchor(root) {
+	const pending = Array.from(root.childNodes);
+	while (pending.length) {
+		const node = pending.pop();
+		if (isSSRPortalWriterAnchor(node)) return true;
+		for (const child of node.childNodes) pending.push(child);
+	}
+	return false;
+}
+/** The dormant host adopted for `el`, if it has not been activated. */
+function dormantHostFor(el) {
+	const node = dormantHosts.get(el);
+	return node?.dormant ? node : null;
+}
+/**
+* Hydrate a dormant host in place: claim its server children, then apply
+* its props, listeners, and ref. The marker is removed when the pass
+* commits, so a failed activation leaves it for a retry.
+*/
+function hydrateDormantHost(pass, node) {
+	const dormant = node.dormant;
+	const el = node.el;
+	const ctx = createRenderContext(pass, dormant.owner, dormant.ns, {
+		cursor: new HydrationCursor(),
+		container: el
+	});
+	const props = node.props;
+	applyInitialProps(pass, node, true);
+	if (!isDangerousInnerHTMLPayload(props.dangerouslySetInnerHTML)) {
+		node.children = reconcileChildren({
+			...ctx,
+			ns: childNamespace(node.tag, dormant.ns)
+		}, node, props.children, true);
+		pass.onDiscard(() => {
+			node.children = [];
+		});
+	}
+	applyTrailingProps(pass, node, props, true, true);
+	attachRef(pass, node, void 0);
+	pass.op(() => {
+		pass.onReversibleCommit(() => {
+			node.dormant = dormant;
+			dormantHosts.set(el, node);
+		});
+		try {
+			removeUnrenderedAttributes(el, props, (attributes) => {
+				pass.onReversibleCommit(() => {
+					for (const attribute of attributes) el.setAttributeNode(attribute);
+				});
+			});
+		} catch (error) {
+			throw new CommitMutationError(error);
+		}
+		node.dormant = null;
+		dormantHosts.delete(el);
+	});
+}
+function ownsChildren(props) {
+	return !props.imperativeChildren && !isDangerousInnerHTMLPayload(props.dangerouslySetInnerHTML);
+}
+function patchHost(ctx, node, props) {
+	const previous = node.props;
+	if (previous === props) return;
+	if (node.dormant) {
+		ctx.pass.op(() => {
+			const previous = node.props;
+			ctx.pass.onReversibleCommit(() => {
+				node.props = previous;
+			});
+			node.props = props;
+		});
+		return;
+	}
+	const wasManaged = ownsChildren(previous);
+	const isManaged = ownsChildren(props);
+	if (wasManaged && !isManaged) reconcileChildren(ctx, node, null, false);
+	patchProps(ctx.pass, node, previous, props);
+	if (node.tag === "option" && !Object.is(previous.value, props.value)) syncEnclosingSelect(ctx.pass, node.parent);
+	if (!wasManaged && isManaged && node.children.length === 0) ctx.pass.op(() => {
+		const children = Array.from(node.el.childNodes);
+		ctx.pass.onReversibleCommit(() => restoreElementChildren(node.el, children));
+		try {
+			node.el.replaceChildren();
+		} catch (error) {
+			throw new CommitMutationError(error);
+		}
+	});
+	if (isManaged) {
+		reconcileChildren({
+			...ctx,
+			ns: childNamespace(node.tag, namespaceOf(node.el))
+		}, node, props.children, false);
+		if (props.children === void 0 || props.children === null || props.children === false) ctx.pass.op(() => {
+			if (!node.el.firstChild) return;
+			const previous = Array.from(node.el.childNodes);
+			ctx.pass.onReversibleCommit(() => restoreElementChildren(node.el, previous));
+			try {
+				node.el.replaceChildren();
+			} catch (error) {
+				throw new CommitMutationError(error);
+			}
+		});
+	}
+	ctx.pass.op(() => {
+		const previous = node.props;
+		ctx.pass.onReversibleCommit(() => {
+			node.props = previous;
+		});
+		node.props = props;
+	});
+	if (node.tag === "select") ctx.pass.op(() => {
+		applyTrailingProps(ctx.pass, node, props);
+		markSelectSynced(ctx.pass, node);
+	});
+	if (props.ref !== previous.ref) attachRef(ctx.pass, {
+		...node,
+		props
+	}, previous.ref);
+}
+function namespaceOf(el) {
+	const uri = el.namespaceURI;
+	return uri === SVG_NS || uri === MATHML_NS ? uri : null;
+}
+function createComponent(ctx, parent, key, fn, props) {
+	const instance = new ComponentInstance(ctx.owner, fn, props);
+	ctx.pass.own(instance);
+	const node = {
+		kind: 2,
+		parent,
+		key,
+		instance,
+		children: []
+	};
+	instance.view = node;
+	node.children = renderInstance(ctx, node, true);
+	return node;
+}
+function propsChanged(previous, next) {
+	if (previous === next) return false;
+	let count = 0;
+	for (const key in previous) {
+		count++;
+		if (!(key in next) || !Object.is(previous[key], next[key])) return true;
+	}
+	for (const key in next) count--;
+	return count !== 0;
+}
+function patchComponent(ctx, node, props) {
+	const instance = node.instance;
+	if (!propsChanged(instance.props, props) && !instance.computation.stale && !instance.computation._hasError && instance.seenAncestorContextRevision === ancestorContextRevision(instance)) return;
+	instance.setProps(props);
+	renderInstance(ctx, node, false);
+}
+function nearestComponent(instance) {
+	for (let owner = instance.parent; owner; owner = owner.parent) if (owner instanceof ComponentInstance) return owner;
+	return null;
+}
+/**
+* Highest `contextRevision` among `instance`'s component ancestors. Each
+* instance caches its inherited value for the current context epoch, so
+* patching every component in a deep chain stays linear. The cache relies on
+* a live instance's parent chain never changing (owners are not reparented).
+* The epoch is global, so a `provide()` anywhere invalidates every cache; the
+* worst case is the uncached O(depth) walk.
+*/
+function ancestorContextRevision(instance) {
+	const epoch = getContextEpoch();
+	let chain = null;
+	let revision = 0;
+	for (let current = nearestComponent(instance); current;) {
+		if (current.inheritedContextEpoch === epoch) {
+			revision = Math.max(current.inheritedContextRevision, current.contextRevision);
+			break;
+		}
+		(chain ??= []).push(current);
+		current = nearestComponent(current);
+	}
+	if (!chain) return revision;
+	for (let index = chain.length - 1; index >= 0; index--) {
+		const ancestor = chain[index];
+		ancestor.inheritedContextRevision = revision;
+		ancestor.inheritedContextEpoch = epoch;
+		revision = Math.max(revision, ancestor.contextRevision);
+	}
+	return revision;
+}
+/**
+* Render a component and reconcile its output. An error boundary catches a
+* failure anywhere in its subtree: the work recorded since it started is
+* rewound and it renders again showing its fallback.
+*/
+/** The component rendering now while its root hydrates. */
+let hydratingRender = null;
+function renderComponent(ctx, node) {
+	const previous = hydratingRender;
+	hydratingRender = ctx.hydrate ? {
+		ctx,
+		node
+	} : null;
+	node.instance.hydrationResourceKeys = ctx.hydrate ? ctx.hydrate.cursor.claimResourceSlots(ctx.hydrate.container) : null;
+	try {
+		return node.instance.render((undo) => ctx.pass.onDiscard(undo));
+	} finally {
+		node.instance.hydrationResourceKeys = null;
+		hydratingRender = previous;
+	}
+}
+function isHydratingRender() {
+	return hydratingRender !== null;
+}
+function commitSeenAncestorContextRevision(pass, instance, revision) {
+	pass.op(() => {
+		const previous = instance.seenAncestorContextRevision;
+		pass.onReversibleCommit(() => {
+			instance.seenAncestorContextRevision = previous;
+		});
+		instance.seenAncestorContextRevision = revision;
+	});
+}
+/**
+* Render the hydrating component again after the rest of its root, claiming
+* the server nodes reserved at its position (portal hosts whose content is
+* written later in the same render).
+*/
+function deferHydratingRender(instance) {
+	const active = hydratingRender;
+	if (!active || active.node.instance !== instance) return false;
+	const { ctx, node } = active;
+	const hydrate = ctx.hydrate;
+	const cursor = hydrate.cursor.reserve(hydrate.container);
+	hydrate.cursor.deferred.push({ render: () => {
+		if (instance.disposed) return;
+		if (!instance.computation.stale) {
+			if (ctx.pass.hasDormantPortalWriter) {
+				const held = cursor.heldNodes(hydrate.container);
+				node.children = held.map((dom) => ({
+					kind: 7,
+					parent: node,
+					key: void 0,
+					node: dom
+				}));
+				node.deferredHydration = {
+					cursor,
+					container: hydrate.container
+				};
+			}
+			return;
+		}
+		renderInstance({
+			...ctx,
+			hydrate: {
+				cursor,
+				container: hydrate.container
+			}
+		}, node, true);
+	} });
+	return true;
+}
+/** Adopt held server portal output when its deferred writer first runs. */
+function hydrateDeferredComponent(ctx, node, output) {
+	const deferred = node.deferredHydration;
+	const previous = node.children;
+	const next = reconcileChildren(withOwner({
+		...ctx,
+		hydrate: deferred
+	}, node.instance), node, output, true);
+	const container = deferred.container;
+	const after = nextDomAfter(node);
+	ctx.pass.op(() => {
+		const previousDom = Array.from(container.childNodes);
+		ctx.pass.onReversibleCommit(() => {
+			try {
+				restoreNodeChildren(container, previousDom);
+			} finally {
+				node.children = previous;
+				node.deferredHydration = deferred;
+			}
+		});
+		const retained = new Set(next.flatMap((child) => collectDom(child)));
+		try {
+			for (const child of previous) for (const dom of collectDom(child)) if (!retained.has(dom)) dom.parentNode?.removeChild(dom);
+			let before = after;
+			for (let index = next.length - 1; index >= 0; index--) {
+				const doms = collectDom(next[index]);
+				for (let item = doms.length - 1; item >= 0; item--) {
+					const dom = doms[item];
+					if (dom.parentNode !== container || dom.nextSibling !== before) container.insertBefore(dom, before);
+					before = dom;
+				}
+			}
+		} catch (error) {
+			throw new CommitMutationError(error);
+		}
+		node.children = next;
+		node.deferredHydration = null;
+	});
+	ctx.pass.markRendered(node.instance);
+}
+function renderInstance(ctx, node, fresh) {
+	const instance = node.instance;
+	const inner = withOwner(ctx, instance);
+	const mark = ctx.pass.mark();
+	try {
+		const output = renderComponent(ctx, node);
+		if (instance.mounted) ctx.pass.onDiscard(() => {
+			if (ctx.pass.commitAborted) instance.computation.deferRetry();
+			else instance.computation.invalidate();
+		});
+		const children = reconcileComponentOutput(inner, node, output, fresh);
+		ctx.pass.markRendered(instance);
+		const revision = ancestorContextRevision(instance);
+		commitSeenAncestorContextRevision(ctx.pass, instance, revision);
+		return children;
+	} catch (caught) {
+		const error = clarifyRenderError(caught);
+		const boundary = instance.boundary;
+		if (!boundary) {
+			noteErrorOrigin(instance.parent, error);
+			throw error;
+		}
+		for (const failure of ctx.pass.rewind(mark)) reportUncaughtErrorLater(failure);
+		if (!boundary(error)) throw error;
+		const children = reconcileChildren(inner, node, componentOutput(renderComponent(ctx, node)), fresh);
+		ctx.pass.markRendered(instance);
+		const revision = ancestorContextRevision(instance);
+		commitSeenAncestorContextRevision(ctx.pass, instance, revision);
+		return children;
+	}
+}
+/**
+* A component that returns the same component type directly can form a very
+* deep transparent chain. Walk the hook-free part of that chain explicitly;
+* all other output still goes through the ordinary child reconciler.
+*/
+function reconcileComponentOutput(ctx, node, value, fresh) {
+	let output = componentOutput(value);
+	let current = node;
+	let inner = ctx;
+	let creating = fresh;
+	const rendered = [];
+	for (;;) {
+		const next = current.instance.hooks.length === 0 && !current.instance.boundary ? selfChild(output, current.instance.fn) : null;
+		if (!next) {
+			const children = reconcileChildren(inner, current, output, creating);
+			if (creating) current.children = children;
+			break;
+		}
+		let child;
+		if (creating) {
+			const instance = new ComponentInstance(current.instance, next.fn, next.props);
+			ctx.pass.own(instance);
+			child = {
+				kind: 2,
+				parent: current,
+				key: next.key,
+				instance,
+				children: []
+			};
+			instance.view = child;
+			current.children = [child];
+		} else {
+			const previous = current.children;
+			if (previous.length !== 1 || previous[0].kind !== 2 || previous[0].key !== next.key || previous[0].instance.fn !== next.fn) {
+				reconcileChildren(inner, current, output, false);
+				break;
+			}
+			child = previous[0];
+			const instance = child.instance;
+			if (!propsChanged(instance.props, next.props) && !instance.computation.stale && !instance.computation._hasError && instance.seenAncestorContextRevision === ancestorContextRevision(instance)) break;
+			instance.setProps(next.props);
+		}
+		const instance = child.instance;
+		rendered.push(child);
+		inner = withOwner(inner, instance);
+		current = child;
+		output = componentOutput(renderComponent(inner, child));
+		if (instance.mounted) ctx.pass.onDiscard(() => {
+			if (ctx.pass.commitAborted) instance.computation.deferRetry();
+			else instance.computation.invalidate();
+		});
+		creating = fresh;
+	}
+	for (let i = rendered.length - 1; i >= 0; i--) {
+		const instance = rendered[i].instance;
+		ctx.pass.markRendered(instance);
+		const revision = ancestorContextRevision(instance);
+		commitSeenAncestorContextRevision(ctx.pass, instance, revision);
+	}
+	return node.children;
+}
+function restoreNodeChildren(container, previous) {
+	for (let index = 0; index < previous.length; index += 1) {
+		const current = container.childNodes[index] ?? null;
+		if (current !== previous[index]) container.insertBefore(previous[index], current);
+	}
+	while (container.childNodes.length > previous.length) container.removeChild(container.lastChild);
+}
+function selfChild(output, fn) {
+	if (!output || typeof output !== "object" || Array.isArray(output) || output.type !== fn) return null;
+	const children = normalizeChildren(output);
+	return children.length === 1 && children[0].kind === 2 ? children[0] : null;
+}
+/** A function returned by a component is a value, not a child slot. */
+function componentOutput(value) {
+	return typeof value === "function" ? null : value;
+}
+function createDynamic(ctx, parent, fn) {
+	const node = {
+		kind: DYNAMIC,
+		parent,
+		key: void 0,
+		fn,
+		children: [],
+		depth: (nearestInstance(ctx.owner)?.depth ?? 0) + 1
+	};
+	node.instance = new ComponentInstance(ctx.owner, () => functionChildOutput(readValue(node.fn)), {}, () => scheduleDynamicUpdate(node));
+	node.computation = node.instance.computation;
+	ctx.pass.own(node.instance);
+	node.children = reconcileChildren(withOwner(ctx, node.instance), node, readDynamic(node), true, false);
+	ctx.pass.markRendered(node.instance);
+	return node;
+}
+/** Run a function child's read now, tracking what it reads. */
+function readDynamic(node, pass) {
+	const output = node.instance.render(pass ? (undo) => pass.onDiscard(undo) : void 0);
+	if (pass && node.instance.mounted) pass.onDiscard(() => {
+		if (pass.commitAborted) node.computation.deferRetry();
+		else node.computation.invalidate();
+	});
+	return componentOutput(output);
+}
+function patchDynamic(ctx, node, fn) {
+	const previous = node.fn;
+	node.fn = fn;
+	ctx.pass.onDiscard(() => {
+		node.fn = previous;
+	});
+	updateDynamic(ctx, node);
+}
+/** Reconcile a function child, remounting only when its own hooks change. */
+function updateDynamic(ctx, node) {
+	const mark = ctx.pass.mark();
+	try {
+		reconcileChildren(withOwner(ctx, node.instance), node, readDynamic(node, ctx.pass), false, false);
+		ctx.pass.markRendered(node.instance);
+	} catch (error) {
+		if (!(error instanceof HookOrderChangeError) || error.instance !== node.instance) throw error;
+		for (const failure of ctx.pass.rewind(mark)) reportUncaughtErrorLater(failure);
+		const slot = ctx.pass.reserve();
+		const replacement = createDynamic(withOwner(ctx, node.instance.parent), node.parent, node.fn);
+		ctx.pass.fill(slot, () => {
+			const parent = node.parent;
+			const container = containerOf(parent);
+			const next = nextDomAfter(node);
+			const oldDom = collectDom(node);
+			const replacementDom = collectDom(replacement);
+			const index = parent.children.indexOf(node);
+			ctx.pass.onReversibleCommit(() => {
+				for (const dom of replacementDom) dom.parentNode?.removeChild(dom);
+				parent.children[index] = node;
+			}, () => {
+				const errors = [];
+				for (const dom of oldDom) dom.parentNode?.removeChild(dom);
+				release(node, errors);
+				reportTeardown(errors);
+			});
+			parent.children[index] = replacement;
+			try {
+				for (const dom of replacementDom) container.insertBefore(dom, next);
+			} catch (error) {
+				throw new CommitMutationError(error);
+			}
+		});
+	}
+}
+function release(node, errors) {
+	const pending = [{
+		node,
+		finish: false
+	}];
+	while (pending.length) {
+		const frame = pending.pop();
+		const current = frame.node;
+		if (frame.finish) {
+			if (current.kind === HOST) {
+				if (current.dormant) dormantHosts.delete(current.el);
+				releaseProps(current, errors);
+			}
+			if (current.kind === 2 || current.kind === DYNAMIC) current.instance.dispose(errors);
+			continue;
+		}
+		if (current.kind === 1 || current.kind === 7) continue;
+		pending.push({
+			node: current,
+			finish: true
+		});
+		for (let i = current.children.length - 1; i >= 0; i--) pending.push({
+			node: current.children[i],
+			finish: false
+		});
+	}
+}
+/**
+* A select's controlled value depends on its options. When a pass changes
+* them without patching the select (a child component, `For`, or function
+* child adds, removes, or edits options), re-apply the select's value after
+* the pass commits, once per select. Each change registers its own sync so
+* an error boundary that rewinds part of the pass drops only its own.
+*/
+const scheduledSelectSyncs = /* @__PURE__ */ new WeakMap();
+const writtenSelectValues = /* @__PURE__ */ new WeakMap();
+function syncEnclosingSelect(pass, parent) {
+	const select = enclosingSelect(parent);
+	if (!select || select.dormant || !("value" in select.props)) return;
+	let scheduled = scheduledSelectSyncs.get(pass);
+	if (!scheduled) scheduledSelectSyncs.set(pass, scheduled = /* @__PURE__ */ new Set());
+	if (scheduled.has(select)) return;
+	scheduled.add(select);
+	pass.onDiscard(() => scheduled.delete(select));
+	recordSelectUndo(pass, select);
+	pass.beforeJournalSettle(() => {
+		if (writtenSelectValues.get(pass)?.has(select)) return;
+		try {
+			resyncSelect(select);
+		} catch (error) {
+			throw new CommitMutationError(error);
+		}
+	});
+}
+/** The select's own patch applied its value after its options. */
+function markSelectSynced(pass, select) {
+	let written = writtenSelectValues.get(pass);
+	if (!written) writtenSelectValues.set(pass, written = /* @__PURE__ */ new Set());
+	written.add(select);
+}
+const domNodes = {
+	listChanged(ctx, parent) {
+		syncEnclosingSelect(ctx.pass, parent);
+	},
+	create(ctx, parent, child) {
+		switch (child.kind) {
+			case 1: {
+				const hydrate = ctx.hydrate;
+				const claimed = hydrate?.cursor.claimText(hydrate.container, child.text);
+				if (claimed && claimed.data !== child.text) {
+					const text = child.text;
+					ctx.pass.op(() => {
+						const previous = claimed.data;
+						ctx.pass.onReversibleCommit(() => {
+							claimed.data = previous;
+						});
+						try {
+							claimed.data = text;
+						} catch (error) {
+							throw new CommitMutationError(error);
+						}
+					});
+				}
+				return {
+					kind: 1,
+					parent,
+					key: void 0,
+					node: claimed ?? document.createTextNode(child.text),
+					text: child.text
+				};
+			}
+			case 0: return createHost(ctx, parent, child.key, child.tag, child.props);
+			case 2: return createComponent(ctx, parent, child.key, child.fn, child.props);
+			case 3: {
+				const node = {
+					kind: 3,
+					parent,
+					key: child.key,
+					children: []
+				};
+				node.children = reconcileChildren(withOwner(ctx, child.owner ?? ctx.owner), node, child.children, true);
+				return node;
+			}
+			case 4: return createDynamic(ctx, parent, child.fn);
+			case 7: return {
+				kind: 7,
+				parent,
+				key: void 0,
+				node: child.node
+			};
+		}
+	},
+	patch(ctx, node, child) {
+		switch (node.kind) {
+			case 1: {
+				const text = child.text;
+				if (node.text !== text) {
+					ctx.pass.op(() => {
+						const previous = node.text;
+						const previousData = node.node.data;
+						ctx.pass.onReversibleCommit(() => {
+							try {
+								node.node.data = previousData;
+							} finally {
+								node.text = previous;
+							}
+						});
+						try {
+							node.node.data = text;
+							node.text = text;
+						} catch (error) {
+							throw new CommitMutationError(error);
+						}
+					});
+					syncEnclosingSelect(ctx.pass, node.parent);
+				}
+				return;
+			}
+			case HOST:
+				patchHost(ctx, node, child.props);
+				return;
+			case 2:
+				patchComponent(ctx, node, child.props);
+				return;
+			case DYNAMIC:
+				patchDynamic(ctx, node, child.fn);
+				return;
+			case 7: return;
+			case 3: {
+				const owner = child.owner;
+				reconcileChildren(withOwner(ctx, owner ?? ctx.owner), node, child.children, false);
+				return;
+			}
+		}
+	},
+	release
+};
+//#endregion
+//#region src/core/dom/updates.ts
+/**
+* Standalone updates: a component or function child whose own reads changed
+* re-renders in its own pass, independent of its parent.
+*
+* A failed update discards its pass and is delivered to the nearest error
+* boundary above it; without one, the error propagates to the scheduler,
+* which reports it after the flush.
+*/
+function runPass(owner, render) {
+	const pass = new Pass();
+	try {
+		pass.run(() => render(pass));
+	} catch (error) {
+		for (const failure of pass.discard()) reportUncaughtErrorLater(failure);
+		routeError(owner, clarifyRenderError(error));
+		return;
+	}
+	try {
+		pass.commit();
+	} catch (error) {
+		if (pass.commitAborted) routeError(owner, error);
+		else throw error;
+	}
+}
+function rerenderInstance(instance) {
+	const node = instance.view;
+	if (!node || instance.disposed || !instance.mounted) return;
+	if (!instance.computation.stale) return;
+	runPass(instance.parent, (pass) => {
+		const before = instance.renderCount;
+		const computation = instance.computation;
+		const sources = new Set(computation._sources ?? []);
+		pass.onDiscard(() => computation.restoreSources(sources));
+		try {
+			computation.update();
+			if (computation._hasError) throw computation._error;
+		} catch (error) {
+			if (!instance.boundary) throw error;
+		}
+		if (instance.renderCount === before && !computation._hasError) return;
+		renderAfterUpdate(createRenderContext(pass, instance.parent, namespaceAt(node.parent)), node);
+	});
+}
+/**
+* The instance already ran with fresh reads; reconcile that output (or, for
+* a boundary whose render failed, render its fallback).
+*/
+function renderAfterUpdate(ctx, node) {
+	const instance = node.instance;
+	const computation = instance.computation;
+	if (computation._hasError) {
+		renderInstance(ctx, node, false);
+		return;
+	}
+	const mark = ctx.pass.mark();
+	try {
+		if (node.deferredHydration) {
+			hydrateDeferredComponent(ctx, node, componentOutput(computation._value));
+			return;
+		}
+		reconcileChildren(withOwner(ctx, instance), node, componentOutput(computation._value), false);
+		ctx.pass.markRendered(instance);
+	} catch (caught) {
+		const error = clarifyRenderError(caught);
+		if (!instance.boundary) throw error;
+		ctx.pass.rewind(mark);
+		if (!instance.boundary(error)) throw error;
+		renderInstance(ctx, node, false);
+	}
+}
+const dynamicJobs = /* @__PURE__ */ new WeakMap();
+function scheduleDynamic(node) {
+	let job = dynamicJobs.get(node);
+	if (!job) {
+		job = {
+			depth: node.depth,
+			run: () => rerenderDynamic(node),
+			cancel: () => node.computation.dropScheduled(),
+			get skip() {
+				return node.computation.disposed || !node.computation.stale;
+			}
+		};
+		dynamicJobs.set(node, job);
+	}
+	schedule(job, "render");
+}
+function rerenderDynamic(node) {
+	const computation = node.computation;
+	if (computation.disposed || !computation.stale) return;
+	runPass(node.instance.parent, (pass) => {
+		updateDynamic(createRenderContext(pass, node.instance, namespaceAt(node.parent)), node);
+	});
+}
+/** Bind standalone updates when a DOM root is created. */
+function installRenderUpdates() {
+	setRenderHost({
+		rerender: rerenderInstance,
+		isHydrating: isHydratingRender,
+		deferHydration: deferHydratingRender
+	});
+	setDynamicUpdateScheduler(scheduleDynamic);
+}
+//#endregion
+//#region src/core/dom/root.ts
+/**
+* A root renders a value into a container element and owns everything it
+* renders.
+*
+* `prepare()` runs the render phase and returns work that is either
+* committed or discarded as a unit, so a caller updating several roots (a
+* navigation) can commit all of them or none. `render()` prepares and
+* commits in one step.
+*/
+function createRoot(container, options = {}) {
+	installRenderUpdates();
+	const owner = new Owner(options.owner === void 0 ? getOwner() : options.owner);
+	(owner.context ??= /* @__PURE__ */ new Map()).set(EVENT_ROOT_CONTAINER, container);
+	const node = {
+		kind: 5,
+		el: container,
+		children: [],
+		parent: null,
+		key: void 0,
+		tail: options.before ?? null
+	};
+	let mounted = false;
+	let hydrate = options.hydrate === true;
+	let releaseEvents = null;
+	function prepare(value) {
+		const pass = new Pass();
+		const fresh = !mounted;
+		const tail = node.tail?.parentNode === container ? node.tail : null;
+		const cursor = fresh && hydrate ? new HydrationCursor(tail) : null;
+		const ctx = createRenderContext(pass, owner, namespaceAt(node), cursor ? {
+			cursor,
+			container
+		} : null);
+		try {
+			pass.run(() => runWithOwner(owner, () => {
+				if (!fresh) {
+					reconcileChildren(ctx, node, value, false);
+					return;
+				}
+				const children = reconcileChildren(ctx, node, value, true);
+				for (const deferred of cursor?.deferred ?? []) deferred.render();
+				const adopting = ctx.hydrate !== null;
+				pass.op(() => {
+					const before = node.tail?.parentNode === container ? node.tail : null;
+					const dom = children.flatMap((child) => collectDom(child));
+					if (adopting) {
+						const previous = node.children;
+						pass.onReversibleCommit(() => {
+							node.children = previous;
+						});
+						syncChildren(pass, container, dom, before);
+						node.children = children;
+						return;
+					}
+					const previousChildren = node.children;
+					if (!before) {
+						const replaced = Array.from(container.childNodes);
+						pass.onReversibleCommit(() => {
+							try {
+								restoreRootChildren(container, replaced);
+							} finally {
+								node.children = previousChildren;
+							}
+						});
+						try {
+							container.replaceChildren(...dom);
+						} catch (error) {
+							if (error instanceof CommitMutationError) throw error;
+							throw new CommitMutationError(error);
+						}
+						node.children = children;
+						return;
+					}
+					const previous = Array.from(container.childNodes);
+					pass.onReversibleCommit(() => {
+						try {
+							restoreRootChildren(container, previous);
+						} finally {
+							node.children = previousChildren;
+						}
+					});
+					try {
+						for (const item of dom) container.insertBefore(item, before);
+					} catch (error) {
+						if (error instanceof CommitMutationError) throw error;
+						throw new CommitMutationError(error);
+					}
+					node.children = children;
+				});
+			}));
+		} catch (error) {
+			for (const failure of pass.discard()) reportUncaughtErrorLater(failure);
+			throw clarifyRenderOverflow(error);
+		}
+		let settled = false;
+		let phase = "prepared";
+		let registeredEventsForPass = false;
+		const apply = () => {
+			if (settled || phase !== "prepared") return;
+			try {
+				if (!releaseEvents) {
+					releaseEvents = registerEventRoot(container);
+					registeredEventsForPass = true;
+				}
+				pass.apply();
+				phase = "applied";
+			} catch (error) {
+				phase = "discarded";
+				settled = true;
+				for (const failure of pass.discard()) reportUncaughtErrorLater(failure);
+				if (registeredEventsForPass) {
+					try {
+						releaseEvents?.();
+					} catch (cleanupError) {
+						reportUncaughtErrorLater(cleanupError);
+					}
+					releaseEvents = null;
+					registeredEventsForPass = false;
+				}
+				throw error;
+			}
+		};
+		const publish = () => {
+			if (settled) return;
+			if (phase === "prepared") apply();
+			if (phase !== "applied") throw new Error("[Askr] Cannot publish a render that was not applied.");
+			settled = true;
+			phase = "published";
+			try {
+				pass.publish();
+			} finally {
+				mounted = true;
+				hydrate = false;
+			}
+		};
+		const rollback = () => {
+			if (settled || phase === "discarded") return [];
+			settled = true;
+			phase = "discarded";
+			const errors = pass.rollback();
+			if (registeredEventsForPass) {
+				try {
+					releaseEvents?.();
+				} catch (error) {
+					errors.push(error);
+				}
+				releaseEvents = null;
+				registeredEventsForPass = false;
+			}
+			return errors;
+		};
+		const discard = () => {
+			if (settled || phase === "discarded") return [];
+			if (phase === "applied") return rollback();
+			settled = true;
+			phase = "discarded";
+			return pass.discard();
+		};
+		return {
+			apply,
+			publish,
+			commit() {
+				apply();
+				publish();
+			},
+			rollback,
+			discard,
+			get aborted() {
+				return pass.commitAborted;
+			}
+		};
+	}
+	return {
+		node,
+		owner,
+		prepare,
+		render(value) {
+			prepare(value).commit();
+		},
+		dispose() {
+			const errors = [];
+			for (const child of node.children) {
+				for (const dom of collectDom(child)) dom.parentNode?.removeChild(dom);
+				domNodes.release(child, errors);
+			}
+			node.children = [];
+			mounted = false;
+			owner.dispose(errors);
+			releaseEvents?.();
+			releaseEvents = null;
+			return errors;
+		}
+	};
+}
+function restoreRootChildren(container, previous) {
+	for (let index = 0; index < previous.length; index += 1) {
+		const current = container.childNodes[index] ?? null;
+		if (current !== previous[index]) container.insertBefore(previous[index], current);
+	}
+	while (container.childNodes.length > previous.length) container.removeChild(container.lastChild);
+}
+//#endregion
+//#region src/boot/root-element.ts
+function resolveRootElement(root) {
+	if (typeof root !== "string") return root;
+	const id = root.startsWith("#") ? root.slice(1) : root;
+	return document.getElementById(id);
+}
+//#endregion
+//#region src/boot/root-lifecycle.ts
+/**
+* Application roots: one per mounted container element.
+*
+* An application root owns a core render root, its application runtime (route
+* data, data runtime), its default portal, and its cleanup callbacks. The
+* rendered tree is `RootView`, which provides the application runtime and
+* renders the current route handler followed by the automatic default portal
+* host. The root view keeps shared route shells in place across navigation.
+*/
+var AppRoot = class {
+	constructor(element, component, hydrate) {
+		this.cleanupStrict = false;
+		this.generation = 0;
+		this.routed = false;
+		this.callbacks = /* @__PURE__ */ new Set();
+		this.element = element;
+		this.root = createRoot(element, {
+			owner: null,
+			hydrate
+		});
+		provideDefaultPortal(this.root.owner, element);
+		this.component = component;
+		this.handler = component;
+	}
+	view() {
+		return {
+			$$typeof: ELEMENT_TYPE,
+			type: RootView,
+			props: {
+				handler: this.handler,
+				runtime: this.appRuntime
+			},
+			key: this.routed ? 0 : this.generation
+		};
+	}
+};
+function RootView(props, context) {
+	provideAppRuntime(props.runtime);
+	const instance = currentComponent();
+	if (instance) instance.name = props.handler.name || null;
+	return props.handler({}, context);
+}
+const appRoots = /* @__PURE__ */ new WeakMap();
+let routedRootCount = 0;
+function registerRootCleanupCallback(rootElement, callback) {
+	const app = appRoots.get(rootElement);
+	if (!app) return () => {};
+	app.callbacks.add(callback);
+	return () => app.callbacks.delete(callback);
+}
+function disposeAppRoot(app) {
+	if (appRoots.get(app.element) !== app) return;
+	appRoots.delete(app.element);
+	restoreInnerHTML(app.element);
+	const errors = app.root.dispose();
+	for (const callback of Array.from(app.callbacks)) try {
+		callback();
+	} catch (error) {
+		errors.push(error);
+	}
+	app.callbacks.clear();
+	unregisterAppInstance(app);
+	if (app.routed) {
+		app.routed = false;
+		routedRootCount--;
+		if (routedRootCount === 0) clearRouteState();
+	}
+	if (errors.length === 0) return;
+	if (app.cleanupStrict) throw new AggregateError(errors, "cleanup failed for app root");
+	reportUncaughtErrorLater(errors.length === 1 ? errors[0] : new AggregateError(errors, "cleanup failed for app root"));
+}
+/**
+* Clearing a root's markup with `innerHTML = ''` tears the app down first,
+* so its lifetimes end with the DOM they own.
+*/
+function interceptInnerHTML(app) {
+	const element = app.element;
+	const descriptor = Object.getOwnPropertyDescriptor(Element.prototype, "innerHTML") ?? Object.getOwnPropertyDescriptor(Object.getPrototypeOf(element), "innerHTML");
+	if (!descriptor?.set || !descriptor.get) return;
+	try {
+		Object.defineProperty(element, "innerHTML", {
+			configurable: true,
+			get() {
+				return descriptor.get.call(this);
+			},
+			set(value) {
+				if (value === "" && appRoots.get(this) === app) {
+					disposeAppRoot(app);
+					if (appRoots.has(this)) return;
+				}
+				descriptor.set.call(this, value);
+			}
+		});
+	} catch {}
+}
+function restoreInnerHTML(element) {
+	if (Object.prototype.hasOwnProperty.call(element, "innerHTML")) Reflect.deleteProperty(element, "innerHTML");
+}
+/** Mount `component` at `rootElement`, or re-render the app already there. */
+function mountOrUpdate(rootElement, component, options) {
+	ensureBrowserRuntime();
+	const nonce = validateCspNonce(options?.cspNonce);
+	let app = appRoots.get(rootElement);
+	const replacingIsland = app !== void 0 && app.component !== component && !app.routed;
+	if (!app) {
+		app = new AppRoot(rootElement, component, options?.hydrate === true);
+		appRoots.set(rootElement, app);
+		interceptInnerHTML(app);
+	} else if (app.component !== component) app.generation++;
+	app.component = component;
+	app.handler = wrapRootRouteHandler(component, nonce);
+	app.cspNonce = nonce;
+	app.appRuntime = options?.appRuntime;
+	if (typeof options?.cleanupStrict === "boolean") app.cleanupStrict = options.cleanupStrict;
+	app.root.render(app.view());
+	options?.onCommit?.();
+	flushSync();
+	if (replacingIsland) {
+		const callbacks = Array.from(app.callbacks);
+		app.callbacks.clear();
+		const errors = [];
+		for (const callback of callbacks) try {
+			callback();
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length > 0) {
+			if (app.cleanupStrict) throw new AggregateError(errors, "cleanup failed for app root");
+			reportUncaughtErrorLater(errors.length === 1 ? errors[0] : new AggregateError(errors, "cleanup failed for app root"));
+		}
+	}
+	return app;
+}
+async function registerAppNavigation(rootElement, path, source) {
+	ensureBrowserRuntime();
+	const app = appRoots.get(rootElement);
+	if (!app) throw new Error("Internal error: app instance missing");
+	if (!app.routed) {
+		app.routed = true;
+		routedRootCount++;
+	}
+	registerAppInstance(app, path, source);
+	initializeNavigation();
+}
+function activateHydrationBoundary(rootElement, boundary) {
+	const app = appRoots.get(rootElement);
+	if (!app || !rootElement.contains(boundary)) return false;
+	const host = dormantHostFor(boundary);
+	if (!host) return false;
+	let parent = host.parent;
+	while (parent && parent.kind !== 5) parent = parent.parent;
+	if (parent !== app.root.node) return false;
+	const pass = new Pass();
+	try {
+		pass.run(() => hydrateDormantHost(pass, host));
+	} catch (error) {
+		for (const failure of pass.discard()) reportUncaughtErrorLater(failure);
+		throw clarifyRenderOverflow(error);
+	}
+	pass.commit();
+	flushSync();
+	return true;
+}
+/**
+* Tear down the app mounted at `root`: its content, lifetimes, and cleanup
+* callbacks, and its route registration.
+*/
+function cleanupApp(root) {
+	const rootElement = resolveRootElement(root);
+	if (!rootElement) return;
+	const app = appRoots.get(rootElement);
+	if (app) disposeAppRoot(app);
+}
+/** Check whether an app is currently mounted at `root`. */
+function hasApp(root) {
+	const rootElement = resolveRootElement(root);
+	return rootElement ? appRoots.has(rootElement) : false;
+}
+//#endregion
+//#region src/boot/islands.ts
+/**
+* createIsland: Enhances existing DOM (no router, mounts once)
+*/
+function createIsland(config) {
+	assertExecutionModel("islands");
+	if (!config || typeof config !== "object") throw new Error("createIsland requires a config object");
+	if (typeof config.component !== "function") throw new Error("createIsland: component must be a function");
+	validateCspNonce(config.cspNonce);
+	const rootElement = resolveRootElement(config.root);
+	if (!rootElement) throw new Error(`Root element not found: ${config.root}`);
+	if ("routes" in config) throw new Error("createIsland does not accept routes; use createSPA for routed apps");
+	if (hasRegisteredRoutes()) throw new Error("Routes are not supported with islands. Use createSPA or hydrateSPA with a route registry instead.");
+	mountOrUpdate(rootElement, config.component, {
+		cleanupStrict: config.cleanupStrict,
+		cspNonce: config.cspNonce,
+		appRuntime: createAppRenderRuntime({ dataRuntime: config.dataRuntime ?? getDefaultDataRuntime() })
+	});
+}
+/**
+* createIslands: Enhances one or more existing DOM roots (no router).
+* The only public islands constructor.
+*/
+function createIslands(config) {
+	assertExecutionModel("islands");
+	if (!config || typeof config !== "object") throw new Error("createIslands requires a config object");
+	validateCspNonce(config.cspNonce);
+	if (!Array.isArray(config.islands) || config.islands.length === 0) throw new Error("createIslands requires a non-empty islands array");
+	for (const island of config.islands) createIsland({
+		...island,
+		cspNonce: island.cspNonce ?? config.cspNonce
+	});
+}
+//#endregion
+//#region src/boot/route-startup.ts
+const MAX_INITIAL_ROUTE_REDIRECTS = 20;
+function bindResolvedRouteHandler(resolved) {
+	return () => resolved.handler(resolved.params);
+}
+function createDeniedStatusNode(status) {
+	return {
+		type: "div",
+		props: { "data-route-denied": String(status) },
+		children: [String(status)]
+	};
+}
+function bindDeniedStatus(status) {
+	return () => createDeniedStatusNode(status);
+}
+function bindDeniedRouteHandler(status) {
+	return () => createDeniedStatusNode(status);
+}
+async function reconcileInitialRouteMetadata(resolved) {
+	if (resolved?.kind !== "render" || !resolved.record) return;
+	if (!resolved.record.options.title && !resolved.record.options.meta && !resolved.record.metaChain?.length) return;
+	const context = getRouteRenderContext(resolved);
+	if (!context) return;
+	reconcileRouteMeta(await resolveRouteMeta(resolved.record, context));
+}
+/**
+* Resolve the route for the current location, following redirects (and
+* replacing the history entry for each) until a render, deny, or no-match
+* result is reached. Returns `null` when a redirect leaves the origin: the
+* browser is loading that document, so there is nothing to mount.
+*/
+async function resolveInitialRoute(auth, source) {
+	let path = typeof window !== "undefined" ? window.location.pathname : "/";
+	let href = typeof window !== "undefined" ? `${window.location.pathname}${window.location.search}${window.location.hash}` : path;
+	const visited = /* @__PURE__ */ new Set();
+	for (let redirects = 0; redirects <= MAX_INITIAL_ROUTE_REDIRECTS; redirects++) {
+		if (visited.has(href)) throw new Error(`[Askr] Route redirect cycle detected at ${href}.`);
+		visited.add(href);
+		if (!source?.registry) throw new TypeError("resolveInitialRoute requires a route registry.");
+		const resolved = await resolveRouteRequest(href, {
+			registry: source.registry,
+			auth,
+			load: source.load,
+			authContext: source.authContext,
+			dataRuntime: source.dataRuntime
+		});
+		if (!resolved || resolved.kind !== "redirect") return {
+			path,
+			href,
+			resolved
+		};
+		const base = typeof window !== "undefined" ? window.location.href : new URL(href, "http://localhost").href;
+		const redirectTarget = resolveNavigationUrl(resolved.to, base);
+		if (redirectTarget.origin !== new URL(base).origin) {
+			if (typeof window !== "undefined") loadDocument(redirectTarget.href, "replace");
+			return null;
+		}
+		const redirectHref = `${redirectTarget.pathname}${redirectTarget.search}${redirectTarget.hash}`;
+		if (typeof window !== "undefined") window.history.replaceState({
+			path: redirectHref,
+			askrIndex: readHistoryIndex(window.history.state)
+		}, "", redirectTarget.href);
+		path = redirectTarget.pathname;
+		href = redirectHref;
+	}
+	throw new Error(`[Askr] Route redirect limit exceeded (${MAX_INITIAL_ROUTE_REDIRECTS}).`);
+}
+//#endregion
+//#region src/boot/spa.ts
+/**
+* App bootstrap and mount
+*/
+/**
+* createSPA: Initializes the router and mounts the app with an explicit route registry.
+* ```ts
+* import { createRouteRegistry } from '@askrjs/askr/router';
+* const registry = createRouteRegistry(() => { ... });
+* await createSPA({ root: '#app', registry });
+* ```
+*
+*/
+async function createSPA(config) {
+	assertExecutionModel("spa");
+	if (!config || typeof config !== "object") throw new Error("createSPA requires a config object");
+	validateCspNonce(config.cspNonce);
+	if (!config.registry) throw new Error("createSPA requires a route registry.");
+	const { manifest } = config.registry;
+	if (manifest.records.length === 0) throw new Error("createSPA requires a route registry with at least one route. If you are enhancing existing HTML, use createIsland instead.");
+	const rootElement = resolveRootElement(config.root);
+	if (!rootElement) throw new Error(`Root element not found: ${config.root}`);
+	configureScrollRestoration(config.scrollRestoration);
+	clearRouteState();
+	_applyManifest(manifest);
+	const routeAuth = config.auth ?? manifest.auth;
+	const dataRuntime = config.dataRuntime ?? getDefaultDataRuntime();
+	const appRouteSource = {
+		registry: config.registry,
+		auth: routeAuth
+	};
+	_setActiveRouteAuthOptions(routeAuth);
+	if (isProductionEnvironment()) lockRouteRegistration();
+	const initialRoute = await resolveInitialRoute(routeAuth, {
+		registry: config.registry,
+		dataRuntime
+	});
+	if (!initialRoute) return;
+	const { path, href: currentUrl, resolved } = initialRoute;
+	setServerLocation(currentUrl);
+	const appRuntime = createAppRenderRuntime({
+		...resolved?.kind === "render" && hasRouteRenderData(resolved) ? {
+			route: getRouteRenderData(resolved),
+			hasRoute: true
+		} : {},
+		dataRuntime,
+		routeRegistry: config.registry,
+		routeAuth
+	});
+	if (!resolved) {
+		mountOrUpdate(rootElement, () => ({
+			type: "div",
+			children: []
+		}), {
+			cleanupStrict: config.cleanupStrict,
+			appRuntime,
+			cspNonce: config.cspNonce
+		});
+		await registerAppNavigation(rootElement, path, {
+			...appRouteSource,
+			runtime: appRuntime
+		});
+		return;
+	}
+	await reconcileInitialRouteMetadata(resolved);
+	mountOrUpdate(rootElement, resolved.kind === "deny" ? bindDeniedStatus(resolved.status) : bindResolvedRouteHandler({
+		handler: resolved.handler,
+		params: resolved.params
+	}), {
+		cleanupStrict: config.cleanupStrict,
+		appRuntime,
+		cspNonce: config.cspNonce
+	});
+	await registerAppNavigation(rootElement, path, {
+		...appRouteSource,
+		runtime: appRuntime
+	});
+}
+//#endregion
+//#region src/boot/hydration.ts
+const DEFERRED_PAYLOAD = "__askr_deferred__";
+const SSR_STYLE_REGISTRY_ATTR = "data-askr-style-registry";
+function applyDeferredStreamPatches(rootElement) {
+	const patches = Array.from(rootElement.querySelectorAll("template[data-askr-deferred-patch]"));
+	for (const template of patches) {
+		const id = template.getAttribute("data-askr-deferred-patch");
+		if (!id) continue;
+		const boundary = Array.from(rootElement.querySelectorAll("askr-resolve[data-askr-deferred]")).find((candidate) => candidate.getAttribute("data-askr-deferred") === id);
+		if (boundary) boundary.replaceWith(template.content.cloneNode(true));
+		template.remove();
+		for (const script of Array.from(rootElement.querySelectorAll("script[data-askr-deferred-apply]"))) if (script.getAttribute("data-askr-deferred-apply") === id) script.remove();
+	}
+}
+function hydrationReviver(_key, value) {
+	if (!value || typeof value !== "object") return value;
+	const payload = value;
+	if (payload[DEFERRED_PAYLOAD] === "fulfilled") return reviveDeferredValue("fulfilled", payload.value, void 0);
+	if (payload[DEFERRED_PAYLOAD] === "rejected") return reviveDeferredValue("rejected", void 0, payload.error);
+	return value;
+}
+/**
+* Relocate the SSR style registry carrier out of the hydration root.
+*
+* `@askrjs/server` prepends the collected styles to the page body, so they land
+* as a direct child of the mount root. That extra element makes the root's
+* child list disagree with the rendered tree, which costs the app in-place
+* adoption and discards the carried CSS during reconciliation. The carrier is
+* transport rather than application markup, so move it into `<head>`, where it
+* still applies and no longer participates in reconciliation.
+*
+* Deferred style patches resolve the carrier with a document-wide query, so
+* they keep working from its new position.
+*/
+function adoptSsrStyleCarriers(rootElement) {
+	const head = document.head;
+	if (!head) return;
+	for (const child of Array.from(rootElement.children)) if (child instanceof HTMLStyleElement && child.hasAttribute(SSR_STYLE_REGISTRY_ATTR)) head.append(child);
+}
+function takeHydrationRenderData(rootElement) {
+	for (const child of Array.from(rootElement.children)) if (child instanceof HTMLScriptElement && child.getAttribute("data-askr-render-data") === "true") {
+		const raw = child.textContent ?? "";
+		child.remove();
+		if (!raw) return pageRenderEnvelope(void 0);
+		try {
+			return pageRenderEnvelope(JSON.parse(raw, hydrationReviver));
+		} catch (err) {
+			const error = /* @__PURE__ */ new Error("[Askr] Failed to parse embedded SSR render data during hydration.");
+			error.cause = err;
+			throw error;
+		}
+	}
+	return null;
+}
+function markSkippedElements(root, skipSelectors) {
+	if (skipSelectors.length === 0) return;
+	const selectorList = Array.from(new Set(skipSelectors)).join(", ");
+	root.querySelectorAll(selectorList).forEach((el) => el.setAttribute("data-skip-hydrate", "true"));
+}
+function collectDeferredBelowFoldBoundaries(root, foldY) {
+	const boundaries = [];
+	const stack = [];
+	for (let index = root.children.length - 1; index >= 0; index -= 1) stack.push(root.children[index]);
+	while (stack.length > 0) {
+		const element = stack.pop();
+		if (element.hasAttribute("data-skip-hydrate")) continue;
+		if (element.getBoundingClientRect().top >= foldY) {
+			element.setAttribute("data-skip-hydrate", "true");
+			boundaries.push(element);
+			continue;
+		}
+		for (let index = element.children.length - 1; index >= 0; index -= 1) stack.push(element.children[index]);
+	}
+	return boundaries;
+}
+function activateVisibleDeferredBoundaries(root, boundaries, foldY, activate, reportedDepthErrors) {
+	let activated = false;
+	let remaining = 0;
+	for (const element of boundaries) {
+		if (!element.hasAttribute("data-skip-hydrate")) continue;
+		if (element.getBoundingClientRect().top < foldY) try {
+			if (activate(root, element)) {
+				activated = true;
+				reportedDepthErrors.delete(element);
+			}
+		} catch (error) {
+			const clarified = clarifyRenderOverflow(error);
+			if (clarified instanceof RenderDepthError && !reportedDepthErrors.has(element)) {
+				reportedDepthErrors.add(element);
+				reportUncaughtErrorLater(clarified);
+			}
+		}
+		if (element.hasAttribute("data-skip-hydrate")) remaining += 1;
+	}
+	return {
+		activated,
+		remaining
+	};
+}
+function queueIdleWork(work) {
+	return new Promise((resolve, reject) => {
+		const run = () => {
+			try {
+				work();
+				resolve();
+			} catch (error) {
+				reject(error);
+			}
+		};
+		if (typeof requestIdleCallback !== "undefined") {
+			requestIdleCallback(run, { timeout: 2e3 });
+			return;
+		}
+		setTimeout(run, 0);
+	});
+}
+function shouldVerifyHydrationMarkup(config) {
+	const explicit = config.hydrate?.verifyMarkup;
+	if (typeof explicit === "boolean") return explicit;
+	return !isProductionEnvironment();
+}
+async function applySelectiveHydration(rootElement, resolved, path, cleanupStrict, hydrateOptions, source, hooks, interactionReplay) {
+	const hasBelowFoldDeferral = !!hydrateOptions.deferBelowFold;
+	let releaseSelectiveHydrationResources = () => {};
+	let registerSelectiveHydrationCleanup = () => {};
+	if (hydrateOptions.skipSelectors?.length) markSkippedElements(rootElement, hydrateOptions.skipSelectors);
+	let deferredBoundaries = [];
+	const reportedDepthErrors = /* @__PURE__ */ new WeakSet();
+	if (hydrateOptions.deferBelowFold) {
+		const foldY = hydrateOptions.foldThreshold ?? window.innerHeight;
+		deferredBoundaries = collectDeferredBelowFoldBoundaries(rootElement, foldY);
+		interactionReplay.registerDeferredBoundaries(deferredBoundaries);
+		let selectiveHydrationResourcesReleased = false;
+		let unregisterRootCleanupCallback = () => {};
+		function handleScroll() {
+			const { activated, remaining } = activateVisibleDeferredBoundaries(rootElement, deferredBoundaries, foldY, hooks.activateHydrationBoundary, reportedDepthErrors);
+			if (!activated) return;
+			if (remaining === 0) releaseSelectiveHydrationResources();
+		}
+		releaseSelectiveHydrationResources = () => {
+			if (selectiveHydrationResourcesReleased) return;
+			selectiveHydrationResourcesReleased = true;
+			unregisterRootCleanupCallback();
+			window.removeEventListener("scroll", handleScroll);
+			interactionReplay.clearDeferredBoundaries();
+		};
+		interactionReplay.setOnDeferredBoundariesDrained(releaseSelectiveHydrationResources);
+		registerSelectiveHydrationCleanup = () => {
+			unregisterRootCleanupCallback = hooks.registerRootCleanupCallback(rootElement, releaseSelectiveHydrationResources);
+		};
+		window.addEventListener("scroll", handleScroll, { passive: true });
+	}
+	if (hydrateOptions.deferUntilIdle && !hasBelowFoldDeferral) {
+		await queueIdleWork(() => {
+			hooks.mountOrUpdate(rootElement, (() => resolved.handler(resolved.params)), {
+				cleanupStrict,
+				appRuntime: source?.runtime
+			});
+		});
+		await hooks.registerAppNavigation(rootElement, path, source);
+		return;
+	}
+	try {
+		hooks.mountOrUpdate(rootElement, (() => resolved.handler(resolved.params)), {
+			cleanupStrict,
+			appRuntime: source?.runtime
+		});
+		registerSelectiveHydrationCleanup();
+		await hooks.registerAppNavigation(rootElement, path, source);
+	} catch (error) {
+		releaseSelectiveHydrationResources();
+		throw error;
+	}
+	if (hydrateOptions.deferUntilIdle && deferredBoundaries.length > 0) await queueIdleWork(() => {
+		try {
+			activateVisibleDeferredBoundaries(rootElement, deferredBoundaries, Number.POSITIVE_INFINITY, hooks.activateHydrationBoundary, reportedDepthErrors);
+		} finally {
+			releaseSelectiveHydrationResources();
+		}
+	});
+	if (deferredBoundaries.length === 0) releaseSelectiveHydrationResources();
+}
+//#endregion
+//#region src/boot/hydration-interaction-replay.ts
+const HYDRATION_INTERACTION_TYPES = [
+	"click",
+	"dblclick",
+	"pointerdown",
+	"pointerup",
+	"keydown",
+	"keyup",
+	"input",
+	"change",
+	"submit"
+];
+function cloneInteractionEvent(event) {
+	const EventConstructor = event.constructor;
+	const eventWithDetails = event;
+	const init = {
+		bubbles: event.bubbles,
+		cancelable: event.cancelable,
+		composed: event.composed,
+		detail: eventWithDetails.detail,
+		view: eventWithDetails.view,
+		key: eventWithDetails.key,
+		code: eventWithDetails.code,
+		location: eventWithDetails.location,
+		repeat: eventWithDetails.repeat,
+		isComposing: eventWithDetails.isComposing,
+		ctrlKey: eventWithDetails.ctrlKey,
+		shiftKey: eventWithDetails.shiftKey,
+		altKey: eventWithDetails.altKey,
+		metaKey: eventWithDetails.metaKey,
+		button: eventWithDetails.button,
+		buttons: eventWithDetails.buttons,
+		clientX: eventWithDetails.clientX,
+		clientY: eventWithDetails.clientY,
+		screenX: eventWithDetails.screenX,
+		screenY: eventWithDetails.screenY,
+		pointerId: eventWithDetails.pointerId,
+		pointerType: eventWithDetails.pointerType,
+		isPrimary: eventWithDetails.isPrimary,
+		data: eventWithDetails.data,
+		inputType: eventWithDetails.inputType
+	};
+	try {
+		return new EventConstructor(event.type, init);
+	} catch {
+		return new Event(event.type, {
+			bubbles: event.bubbles,
+			cancelable: event.cancelable,
+			composed: event.composed
+		});
+	}
+}
+/**
+* Capture discrete interactions before hydrated handlers exist, then replay
+* them after the listener transaction commits. Deferred boundaries remain
+* interaction-activatable until they are revealed or the root is cleaned up.
+*/
+function beginHydrationInteractionReplay(root, activateBoundary, permanentSkipSelectors = []) {
+	const queued = [];
+	const deferredBoundaries = /* @__PURE__ */ new Set();
+	let active = true;
+	let hydratingRoot = true;
+	let replaying = false;
+	let hadDeferredBoundaries = false;
+	let onDeferredBoundariesDrained;
+	function isPermanentlySkipped(target) {
+		const element = target instanceof Element ? target : target instanceof Node ? target.parentElement : null;
+		if (!element) return false;
+		return permanentSkipSelectors.some((selector) => {
+			try {
+				return element.closest(selector) !== null;
+			} catch {
+				return false;
+			}
+		});
+	}
+	function findDeferredBoundary(target) {
+		if (!(target instanceof Node)) return;
+		for (const boundary of deferredBoundaries) if (boundary.hasAttribute("data-skip-hydrate") && boundary.contains(target)) return boundary;
+	}
+	function removeCaptureListeners() {
+		if (!active) return;
+		active = false;
+		for (const type of HYDRATION_INTERACTION_TYPES) root.removeEventListener(type, captureInteraction, true);
+	}
+	function releaseIfFinished() {
+		if (!hydratingRoot && deferredBoundaries.size === 0) removeCaptureListeners();
+	}
+	function notifyIfDeferredBoundariesDrained() {
+		if (hadDeferredBoundaries && deferredBoundaries.size === 0) onDeferredBoundariesDrained?.();
+	}
+	function replayInteraction(interaction) {
+		if (!(interaction.target instanceof Node) || !root.contains(interaction.target)) return;
+		const boundary = findDeferredBoundary(interaction.target);
+		if (boundary) {
+			try {
+				if (!activateBoundary(boundary)) return;
+			} catch {
+				return;
+			}
+			deferredBoundaries.delete(boundary);
+			notifyIfDeferredBoundariesDrained();
+		}
+		replaying = true;
+		try {
+			interaction.target.dispatchEvent(interaction.event);
+		} finally {
+			replaying = false;
+		}
+		releaseIfFinished();
+	}
+	function captureInteraction(event) {
+		if (!active || replaying) return;
+		const target = event.target;
+		if (!target || isPermanentlySkipped(target)) return;
+		const boundary = findDeferredBoundary(target);
+		if (!hydratingRoot && !boundary) return;
+		event.preventDefault();
+		event.stopImmediatePropagation();
+		const interaction = {
+			target,
+			event: cloneInteractionEvent(event)
+		};
+		if (hydratingRoot) {
+			queued.push(interaction);
+			return;
+		}
+		replayInteraction(interaction);
+	}
+	const installedTypes = [];
+	try {
+		for (const type of HYDRATION_INTERACTION_TYPES) {
+			root.addEventListener(type, captureInteraction, true);
+			installedTypes.push(type);
+		}
+	} catch (error) {
+		active = false;
+		for (const type of installedTypes) root.removeEventListener(type, captureInteraction, true);
+		throw error;
+	}
+	return {
+		registerDeferredBoundaries(boundaries) {
+			for (const boundary of boundaries) deferredBoundaries.add(boundary);
+			hadDeferredBoundaries ||= boundaries.length > 0;
+		},
+		setOnDeferredBoundariesDrained(callback) {
+			onDeferredBoundariesDrained = callback;
+		},
+		clearDeferredBoundaries() {
+			deferredBoundaries.clear();
+			releaseIfFinished();
+		},
+		complete() {
+			if (!active || !hydratingRoot) return;
+			hydratingRoot = false;
+			const pending = queued.splice(0);
+			for (const interaction of pending) replayInteraction(interaction);
+			releaseIfFinished();
+		},
+		abort() {
+			queued.length = 0;
+			deferredBoundaries.clear();
+			onDeferredBoundariesDrained = void 0;
+			hydratingRoot = false;
+			removeCaptureListeners();
+		}
+	};
+}
+//#endregion
+//#region src/boot/hydrate-spa.ts
+/**
+* App bootstrap and mount
+*/
+/**
+* hydrateSPA: Hydrate server-rendered HTML with an explicit route registry.
+*/
+async function hydrateSPA(config) {
+	assertExecutionModel("spa");
+	if (!config || typeof config !== "object") throw new Error("hydrateSPA requires a config object");
+	validateCspNonce(config.cspNonce);
+	if (!config.registry) throw new Error("hydrateSPA requires a route registry.");
+	const { manifest } = config.registry;
+	if (manifest.records.length === 0) throw new Error("hydrateSPA requires a route registry with at least one route. If you are enhancing existing HTML, use createIsland instead.");
+	const rootElement = resolveRootElement(config.root);
+	if (!rootElement) throw new Error(`Root element not found: ${config.root}`);
+	const interactionReplay = beginHydrationInteractionReplay(rootElement, (boundary) => activateHydrationBoundary(rootElement, boundary), config.hydrate?.skipSelectors);
+	try {
+		applyDeferredStreamPatches(rootElement);
+		adoptSsrStyleCarriers(rootElement);
+		const hydrationRenderData = takeHydrationRenderData(rootElement);
+		const hydrationQueryCache = hydrationRenderData?.queries;
+		const dataRuntime = config.dataRuntime ?? getDefaultDataRuntime();
+		if (hydrationQueryCache) hydrateDataRuntime(dataRuntime, hydrationQueryCache);
+		const hydrationRenderDataForApp = withoutHydratedAuth(hydrationRenderData);
+		configureScrollRestoration(config.scrollRestoration);
+		clearRouteState();
+		_applyManifest(manifest);
+		const hydratedAuth = readHydratedAuth(hydrationRenderData);
+		const routeAuth = config.auth ?? manifest.auth;
+		const appRouteSource = {
+			registry: config.registry,
+			auth: routeAuth,
+			runtime: createAppRenderRuntime({
+				hydrationResources: hydrationRenderDataForApp?.resources,
+				framework: hydrationRenderDataForApp?.framework,
+				route: hydrationRenderData?.route,
+				hasRoute: hydrationRenderData !== null,
+				dataRuntime,
+				routeRegistry: config.registry,
+				routeAuth
+			})
+		};
+		_setActiveRouteAuthOptions(routeAuth);
+		const initialRoute = await resolveInitialRoute(routeAuth, {
+			registry: config.registry,
+			load: false,
+			authContext: hydratedAuth,
+			dataRuntime
+		});
+		if (!initialRoute) {
+			interactionReplay.abort();
+			return;
+		}
+		const { path, href: currentUrl, resolved } = initialRoute;
+		setServerLocation(currentUrl);
+		if (isProductionEnvironment()) lockRouteRegistration();
+		if (!resolved) throw new Error(`hydrateSPA: no route found for current path (${path}).`);
+		await reconcileInitialRouteMetadata(resolved);
+		const hydrationResolved = resolved.kind === "deny" ? {
+			handler: bindDeniedRouteHandler(resolved.status),
+			params: {}
+		} : resolved;
+		let verifyClientMarkup;
+		let clientMarkup = null;
+		const captureClientMarkup = () => {
+			if (verifyClientMarkup) clientMarkup = rootElement.innerHTML;
+		};
+		const mountHydratedRoot = (...args) => mountOrUpdate(args[0], args[1], {
+			...args[2],
+			cspNonce: config.cspNonce,
+			hydrate: true,
+			onCommit: captureClientMarkup
+		});
+		if (shouldVerifyHydrationMarkup(config)) {
+			const { captureServerHydrationMarkup, verifyClientHydrationMarkup, verifyHydrationSyncForUrl } = await import("./verify-hydration-DpVaDnqz.js");
+			if (!verifyHydrationSyncForUrl({
+				root: rootElement,
+				url: currentUrl,
+				registry: config.registry,
+				resolved: hydrationResolved,
+				options: {
+					data: hydrationRenderDataForApp?.resources,
+					dataRuntime,
+					envelope: hydrationRenderDataForApp ?? void 0,
+					cspNonce: config.cspNonce
+				}
+			})) throw new Error("[Askr] Hydration mismatch detected. Server HTML does not match expected server-render output.");
+			const serverMarkup = captureServerHydrationMarkup(rootElement, currentUrl, hydrationRenderDataForApp ?? void 0);
+			if (serverMarkup !== null) verifyClientMarkup = async () => {
+				await Promise.resolve();
+				if (!(clientMarkup !== null && verifyClientHydrationMarkup(clientMarkup, serverMarkup)) && !verifyClientHydrationMarkup(rootElement.innerHTML, serverMarkup)) throw new Error("[Askr] Hydration mismatch detected between server and client markup.");
+			};
+		}
+		const hydrateOptions = config.hydrate;
+		if (hydrateOptions) {
+			if (hydrateOptions.deferUntilIdle || hydrateOptions.deferBelowFold) {
+				if (hydrationRenderDataForApp) startHydrationRenderPhase(hydrationRenderDataForApp);
+				try {
+					await applySelectiveHydration(rootElement, hydrationResolved, path, config.cleanupStrict, hydrateOptions, appRouteSource, {
+						mountOrUpdate: mountHydratedRoot,
+						registerAppNavigation,
+						registerRootCleanupCallback,
+						activateHydrationBoundary
+					}, interactionReplay);
+				} finally {
+					if (hydrationRenderDataForApp) stopHydrationRenderPhase();
+				}
+				flushSync();
+				if (!rootElement.querySelector("[data-skip-hydrate]")) await verifyClientMarkup?.();
+				interactionReplay.complete();
+				return;
+			}
+			if (hydrateOptions.skipSelectors?.length) markSkippedElements(rootElement, hydrateOptions.skipSelectors);
+		}
+		if (hydrationRenderDataForApp) startHydrationRenderPhase(hydrationRenderDataForApp);
+		try {
+			mountHydratedRoot(rootElement, resolved.kind === "deny" ? bindDeniedStatus(resolved.status) : bindResolvedRouteHandler(hydrationResolved), {
+				cleanupStrict: config.cleanupStrict,
+				appRuntime: appRouteSource.runtime
+			});
+			flushSync();
+		} finally {
+			if (hydrationRenderDataForApp) stopHydrationRenderPhase();
+		}
+		await verifyClientMarkup?.();
+		interactionReplay.complete();
+		await registerAppNavigation(rootElement, path, { ...appRouteSource });
+	} catch (error) {
+		interactionReplay.abort();
+		throw error;
+	}
+}
+//#endregion
+//#region src/boot/index.ts
+/** Stable bootstrap exports; each mounting mode owns its orchestration. */
+composeBrowserRuntime();
+//#endregion
+export { cleanupApp as a, createIslands as i, createSPA as n, hasApp as o, createIsland as r, hydrateSPA as t };