eclipsa 0.1.0 → 0.2.0-alpha.0

package/action-LXy_7T1f.mjs

@@ -0,0 +1,4086 @@
+import { i as jsxDEV, n as isSSRAttrValue, r as isSSRTemplate } from "./jsx-dev-runtime-CY60yQJY.mjs";
+import { a as ROUTE_PREFLIGHT_REQUEST_HEADER, c as composeRouteMetadata, o as ROUTE_REPLACE_ATTR, r as ROUTE_PREFETCH_ATTR, s as ROUTE_METADATA_HEAD_ATTR, t as ROUTE_LINK_ATTR } from "./router-shared-Y6ck-Mcm.mjs";
+import { t as __exportAll } from "./vite/mod.mjs";
+//#region core/component.ts
+const component$ = (component) => {
+	Object.defineProperty(component, "__eclipsa_component", {
+		configurable: true,
+		enumerable: false,
+		value: true
+	});
+	return component;
+};
+const $ = (value) => value;
+//#endregion
+//#region core/serialize.ts
+const DEFAULT_MAX_DEPTH = 64;
+const DEFAULT_MAX_ENTRIES = 1e4;
+const RESERVED_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+const isPlainObject$1 = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+};
+const assertSafeEntryBudget = (count, maxEntries) => {
+	if (count > maxEntries) throw new RangeError(`Serialized value exceeds the maximum entry budget of ${maxEntries}.`);
+};
+const assertSafeDepth = (depth, maxDepth) => {
+	if (depth > maxDepth) throw new RangeError(`Serialized value exceeds the maximum depth of ${maxDepth}.`);
+};
+const assertSafeObject = (value) => {
+	const descriptors = Object.getOwnPropertyDescriptors(value);
+	if (Object.getOwnPropertySymbols(value).length > 0) throw new TypeError("Objects with symbol keys cannot be serialized.");
+	for (const [key, descriptor] of Object.entries(descriptors)) if ("get" in descriptor || "set" in descriptor) throw new TypeError(`Objects with accessors cannot be serialized (${key}).`);
+};
+const defineDecodedProperty = (target, key, value) => {
+	Object.defineProperty(target, key, {
+		configurable: true,
+		enumerable: true,
+		value,
+		writable: true
+	});
+};
+const assertReferenceShape = (value) => {
+	const keys = Object.keys(value).sort();
+	const allowedKeys = value.data === void 0 ? [
+		"__eclipsa_type",
+		"kind",
+		"token"
+	] : [
+		"__eclipsa_type",
+		"data",
+		"kind",
+		"token"
+	];
+	if (keys.length !== allowedKeys.length || keys.some((key, index) => key !== allowedKeys[index])) throw new TypeError("Malformed serialized reference.");
+	if (typeof value.kind !== "string" || value.kind.length === 0) throw new TypeError("Serialized references require a non-empty kind.");
+	if (typeof value.token !== "string" || value.token.length === 0) throw new TypeError("Serialized references require a non-empty token.");
+};
+const serializeUnknown = (value, state, stack, depth) => {
+	assertSafeDepth(depth, state.maxDepth);
+	const reference = state.serializeReference?.(value) ?? null;
+	if (reference) {
+		state.entryCount += 1;
+		assertSafeEntryBudget(state.entryCount, state.maxEntries);
+		return reference;
+	}
+	if (value === void 0) {
+		state.entryCount += 1;
+		assertSafeEntryBudget(state.entryCount, state.maxEntries);
+		return { __eclipsa_type: "undefined" };
+	}
+	if (value === null || typeof value === "string" || typeof value === "boolean") {
+		state.entryCount += 1;
+		assertSafeEntryBudget(state.entryCount, state.maxEntries);
+		return value;
+	}
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new TypeError("Non-finite numbers cannot be serialized.");
+		state.entryCount += 1;
+		assertSafeEntryBudget(state.entryCount, state.maxEntries);
+		return value;
+	}
+	if (typeof value === "function") throw new TypeError("Functions cannot be serialized.");
+	if (typeof value === "symbol") throw new TypeError("Symbols cannot be serialized.");
+	if (typeof value !== "object") throw new TypeError(`Unsupported primitive ${typeof value}.`);
+	if (value instanceof Promise) throw new TypeError("Promises cannot be serialized.");
+	if (value instanceof WeakMap || value instanceof WeakSet) throw new TypeError("Weak collections cannot be serialized.");
+	if (value instanceof Date || value instanceof RegExp || value instanceof URL || value instanceof Error || value instanceof ArrayBuffer || ArrayBuffer.isView(value)) throw new TypeError(`Unsupported object ${Object.prototype.toString.call(value)}.`);
+	if (stack.has(value)) throw new TypeError("Circular values cannot be serialized.");
+	stack.add(value);
+	try {
+		if (Array.isArray(value)) {
+			for (let index = 0; index < value.length; index += 1) if (!(index in value)) throw new TypeError("Sparse arrays cannot be serialized.");
+			state.entryCount += value.length + 1;
+			assertSafeEntryBudget(state.entryCount, state.maxEntries);
+			return value.map((entry) => serializeUnknown(entry, state, stack, depth + 1));
+		}
+		if (value instanceof Map) {
+			state.entryCount += value.size * 2 + 1;
+			assertSafeEntryBudget(state.entryCount, state.maxEntries);
+			const entries = [];
+			for (const [key, entry] of value.entries()) entries.push([serializeUnknown(key, state, stack, depth + 1), serializeUnknown(entry, state, stack, depth + 1)]);
+			return {
+				__eclipsa_type: "map",
+				entries
+			};
+		}
+		if (value instanceof Set) {
+			state.entryCount += value.size + 1;
+			assertSafeEntryBudget(state.entryCount, state.maxEntries);
+			return {
+				__eclipsa_type: "set",
+				entries: [...value].map((entry) => serializeUnknown(entry, state, stack, depth + 1))
+			};
+		}
+		if (isPlainObject$1(value)) {
+			assertSafeObject(value);
+			const descriptors = Object.entries(value);
+			state.entryCount += descriptors.length + 1;
+			assertSafeEntryBudget(state.entryCount, state.maxEntries);
+			return {
+				__eclipsa_type: "object",
+				entries: descriptors.map(([key, entry]) => [key, serializeUnknown(entry, state, stack, depth + 1)])
+			};
+		}
+		throw new TypeError(`Unsupported object ${Object.prototype.toString.call(value)}.`);
+	} finally {
+		stack.delete(value);
+	}
+};
+const deserializeUnknown = (value, state, depth) => {
+	assertSafeDepth(depth, state.maxDepth);
+	if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number") {
+		state.entryCount += 1;
+		assertSafeEntryBudget(state.entryCount, state.maxEntries);
+		return value;
+	}
+	if (Array.isArray(value)) {
+		state.entryCount += value.length + 1;
+		assertSafeEntryBudget(state.entryCount, state.maxEntries);
+		return value.map((entry) => deserializeUnknown(entry, state, depth + 1));
+	}
+	if (!value || typeof value !== "object" || typeof value.__eclipsa_type !== "string") throw new TypeError("Malformed serialized value.");
+	switch (value.__eclipsa_type) {
+		case "undefined":
+			state.entryCount += 1;
+			assertSafeEntryBudget(state.entryCount, state.maxEntries);
+			return;
+		case "object": {
+			const keys = Object.keys(value).sort();
+			if (keys.length !== 2 || keys[0] !== "__eclipsa_type" || keys[1] !== "entries") throw new TypeError("Malformed serialized object.");
+			if (!Array.isArray(value.entries)) throw new TypeError("Serialized object entries must be an array.");
+			state.entryCount += value.entries.length + 1;
+			assertSafeEntryBudget(state.entryCount, state.maxEntries);
+			const result = Object.create(null);
+			for (const entry of value.entries) {
+				if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string") throw new TypeError("Malformed serialized object entry.");
+				const [key, child] = entry;
+				if (RESERVED_KEYS.has(key)) {
+					defineDecodedProperty(result, key, deserializeUnknown(child, state, depth + 1));
+					continue;
+				}
+				defineDecodedProperty(result, key, deserializeUnknown(child, state, depth + 1));
+			}
+			return result;
+		}
+		case "map": {
+			const keys = Object.keys(value).sort();
+			if (keys.length !== 2 || keys[0] !== "__eclipsa_type" || keys[1] !== "entries") throw new TypeError("Malformed serialized map.");
+			if (!Array.isArray(value.entries)) throw new TypeError("Serialized map entries must be an array.");
+			state.entryCount += value.entries.length * 2 + 1;
+			assertSafeEntryBudget(state.entryCount, state.maxEntries);
+			const result = /* @__PURE__ */ new Map();
+			for (const entry of value.entries) {
+				if (!Array.isArray(entry) || entry.length !== 2) throw new TypeError("Malformed serialized map entry.");
+				result.set(deserializeUnknown(entry[0], state, depth + 1), deserializeUnknown(entry[1], state, depth + 1));
+			}
+			return result;
+		}
+		case "set": {
+			const keys = Object.keys(value).sort();
+			if (keys.length !== 2 || keys[0] !== "__eclipsa_type" || keys[1] !== "entries") throw new TypeError("Malformed serialized set.");
+			if (!Array.isArray(value.entries)) throw new TypeError("Serialized set entries must be an array.");
+			state.entryCount += value.entries.length + 1;
+			assertSafeEntryBudget(state.entryCount, state.maxEntries);
+			return new Set(value.entries.map((entry) => deserializeUnknown(entry, state, depth + 1)));
+		}
+		case "ref":
+			assertReferenceShape(value);
+			state.entryCount += 1;
+			assertSafeEntryBudget(state.entryCount, state.maxEntries);
+			if (!state.deserializeReference) throw new TypeError(`Cannot deserialize reference kind "${value.kind}" in this context.`);
+			return state.deserializeReference(value);
+		default: throw new TypeError(`Unknown serialized value type "${value.__eclipsa_type}".`);
+	}
+};
+const serializeValue = (value, options) => serializeUnknown(value, {
+	entryCount: 0,
+	maxDepth: options?.maxDepth ?? DEFAULT_MAX_DEPTH,
+	maxEntries: options?.maxEntries ?? DEFAULT_MAX_ENTRIES,
+	serializeReference: options?.serializeReference
+}, /* @__PURE__ */ new Set(), 0);
+const deserializeValue = (value, options) => deserializeUnknown(value, {
+	deserializeReference: options?.deserializeReference,
+	entryCount: 0,
+	maxDepth: options?.maxDepth ?? DEFAULT_MAX_DEPTH,
+	maxEntries: options?.maxEntries ?? DEFAULT_MAX_ENTRIES
+}, 0);
+const escapeJSONScriptText = (json) => json.replaceAll("<", "\\u003C").replaceAll(">", "\\u003E").replaceAll("&", "\\u0026").replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+const serializeJSONScriptContent = (value, options) => escapeJSONScriptText(JSON.stringify(serializeValue(value, options)));
+const parseSerializedJSON = (json) => {
+	return JSON.parse(json);
+};
+//#endregion
+//#region core/suspense.ts
+const PENDING_SIGNAL_ERROR_KEY = Symbol.for("eclipsa.pending-signal-error");
+const Suspense = (props) => props.children ?? null;
+const createPendingSignalError = (promise) => ({
+	[PENDING_SIGNAL_ERROR_KEY]: true,
+	promise
+});
+const isPendingSignalError = (value) => !!value && typeof value === "object" && value[PENDING_SIGNAL_ERROR_KEY] === true;
+const isSuspenseType = (value) => value === Suspense;
+//#endregion
+//#region core/loader.ts
+var loader_exports = /* @__PURE__ */ __exportAll({
+	__eclipsaLoader: () => __eclipsaLoader,
+	consumePendingSsrLoaderIds: () => consumePendingSsrLoaderIds,
+	executeLoader: () => executeLoader,
+	hasLoader: () => hasLoader,
+	isPendingSsrLoaderError: () => isPendingSsrLoaderError,
+	loader$: () => loader$,
+	markPendingSsrLoader: () => markPendingSsrLoader,
+	primeLoaderState: () => primeLoaderState,
+	registerLoader: () => registerLoader,
+	resolvePendingLoaders: () => resolvePendingLoaders
+});
+const LOADER_REGISTRY_KEY = Symbol.for("eclipsa.loader-registry");
+const LOADER_CONTENT_TYPE = "application/eclipsa-loader+json";
+const SSR_PENDING_LOADER_ERROR = Symbol.for("eclipsa.ssr-pending-loader-error");
+const SSR_PENDING_LOADER_IDS_KEY = Symbol.for("eclipsa.ssr-pending-loader-ids");
+const ensurePendingSsrLoaderIds = (container) => {
+	const record = container;
+	const existing = record[SSR_PENDING_LOADER_IDS_KEY];
+	if (existing instanceof Set) return existing;
+	const created = /* @__PURE__ */ new Set();
+	record[SSR_PENDING_LOADER_IDS_KEY] = created;
+	return created;
+};
+const markPendingSsrLoader = (container, id) => {
+	ensurePendingSsrLoaderIds(container).add(id);
+};
+const consumePendingSsrLoaderIds = (container) => {
+	const ids = [...ensurePendingSsrLoaderIds(container)];
+	ensurePendingSsrLoaderIds(container).clear();
+	return ids;
+};
+const isPendingSsrLoaderError = (error) => error === SSR_PENDING_LOADER_ERROR;
+const getLoaderRegistry = () => {
+	const globalRecord = globalThis;
+	const existing = globalRecord[LOADER_REGISTRY_KEY];
+	if (existing instanceof Map) return existing;
+	const created = /* @__PURE__ */ new Map();
+	globalRecord[LOADER_REGISTRY_KEY] = created;
+	return created;
+};
+const composeMiddlewares$1 = async (c, middlewares, handler) => {
+	let index = -1;
+	const dispatch = async (nextIndex) => {
+		if (nextIndex <= index) throw new Error("Loader middleware called next() multiple times.");
+		index = nextIndex;
+		const middleware = middlewares[nextIndex];
+		if (!middleware) return handler(c);
+		let nextResult = void 0;
+		const result = await middleware(c, (async () => {
+			nextResult = await dispatch(nextIndex + 1);
+		}));
+		if (result !== void 0) return result;
+		return nextResult;
+	};
+	return dispatch(0);
+};
+const toSerializedLoaderError = (error) => {
+	if (error instanceof Error) return serializeValue({
+		message: error.message,
+		name: error.name
+	});
+	try {
+		return serializeValue(error);
+	} catch {
+		return serializeValue({ message: "Loader failed." });
+	}
+};
+const normalizeLoaderValue = (value) => {
+	if (value instanceof Response) throw new TypeError("loader$() handlers and middlewares must resolve to data, not Response.");
+	if (typeof ReadableStream !== "undefined" && value instanceof ReadableStream) throw new TypeError("loader$() does not support ReadableStream results.");
+	if (value && typeof value === "object" && Symbol.asyncIterator in value) throw new TypeError("loader$() does not support async iterable results.");
+	return value;
+};
+const updateLoaderSnapshot = (container, id, snapshot) => {
+	container?.loaderStates.set(id, snapshot);
+};
+const createHandleSignal$1 = (container, id, key, initialValue) => {
+	if (!container) throw new Error("Loader handles require an active runtime container.");
+	return {
+		detached: false,
+		signal: createDetachedRuntimeSignal(container, `$loader:${id}:${key}`, initialValue)
+	};
+};
+const parseJsonLoaderResponse = async (response) => {
+	const body = await response.json();
+	if (!body || typeof body !== "object" || typeof body.ok !== "boolean") throw new TypeError("Malformed loader response.");
+	if (!body.ok) throw deserializeValue(body.error);
+	return deserializeValue(body.value);
+};
+const invokeLoader = async (id) => {
+	return parseJsonLoaderResponse(await fetch(`/__eclipsa/loader/${encodeURIComponent(id)}`, {
+		headers: { accept: LOADER_CONTENT_TYPE },
+		method: "GET"
+	}));
+};
+const resolveLoader = async (id, c) => {
+	const loader = getLoaderRegistry().get(id);
+	if (!loader) throw new Error(`Unknown loader ${id}.`);
+	return normalizeLoaderValue(await composeMiddlewares$1(c, loader.middlewares, loader.handler));
+};
+const loader$ = (() => {
+	throw new Error("loader$() must be compiled by the Eclipsa analyzer before it can run.");
+});
+function registerLoader(id, middlewares, handler) {
+	getLoaderRegistry().set(id, {
+		handler,
+		id,
+		middlewares: [...middlewares]
+	});
+}
+const hasLoader = (id) => getLoaderRegistry().has(id);
+const executeLoader = async (id, c) => {
+	try {
+		return new Response(JSON.stringify({
+			ok: true,
+			value: serializeValue(await resolveLoader(id, c))
+		}), { headers: { "content-type": LOADER_CONTENT_TYPE } });
+	} catch (error) {
+		return new Response(JSON.stringify({
+			error: toSerializedLoaderError(error),
+			ok: false
+		}), {
+			headers: { "content-type": LOADER_CONTENT_TYPE },
+			status: error instanceof Error && error.message.startsWith("Unknown loader ") ? 404 : 500
+		});
+	}
+};
+const primeLoaderState = async (container, id, c) => {
+	const value = await resolveLoader(id, c);
+	updateLoaderSnapshot(container, id, {
+		data: value,
+		error: void 0,
+		loaded: true
+	});
+	return value;
+};
+const resolvePendingLoaders = async (container, c) => {
+	const pendingIds = consumePendingSsrLoaderIds(container);
+	if (pendingIds.length === 0) return false;
+	await Promise.all(pendingIds.map((id) => primeLoaderState(container, id, c)));
+	return true;
+};
+const __eclipsaLoader = (id, middlewares, handler) => {
+	if (typeof window === "undefined") getLoaderRegistry().set(id, {
+		handler,
+		id,
+		middlewares: [...middlewares]
+	});
+	return registerLoaderHook(id, setLoaderHookMeta(() => {
+		const container = getRuntimeContainer();
+		const existing = container?.loaders.get(id);
+		if (existing) return existing;
+		const initialState = container?.loaderStates.get(id);
+		if (typeof window === "undefined" && !initialState?.loaded) {
+			if (!container) throw new Error(`loader$("${id}") was used during SSR before it was preloaded.`);
+			markPendingSsrLoader(container, id);
+			throw SSR_PENDING_LOADER_ERROR;
+		}
+		const loadingState = createHandleSignal$1(container, id, "loading", false);
+		const dataState = createHandleSignal$1(container, id, "data", initialState?.loaded ? initialState.data : void 0);
+		const errorState = createHandleSignal$1(container, id, "error", initialState?.error);
+		const isDetached = loadingState.detached || dataState.detached || errorState.detached;
+		const isLoading = loadingState.signal;
+		const data = dataState.signal;
+		const error = errorState.signal;
+		let loaded = initialState?.loaded ?? false;
+		let inFlight = null;
+		let autoRequested = false;
+		const syncSnapshot = () => {
+			updateLoaderSnapshot(container ?? null, id, {
+				data: data.value,
+				error: error.value,
+				loaded
+			});
+		};
+		const load = async () => {
+			if (inFlight) return inFlight;
+			isLoading.value = true;
+			error.value = void 0;
+			syncSnapshot();
+			inFlight = (async () => {
+				try {
+					const value = await invokeLoader(id);
+					data.value = value;
+					loaded = true;
+					return value;
+				} catch (caught) {
+					error.value = caught;
+					throw caught;
+				} finally {
+					isLoading.value = false;
+					syncSnapshot();
+					inFlight = null;
+				}
+			})();
+			return inFlight;
+		};
+		const loaderHandle = setLoaderHandleMeta({
+			get data() {
+				return data.value;
+			},
+			get error() {
+				return error.value;
+			},
+			get isLoading() {
+				return isLoading.value;
+			},
+			load
+		}, id);
+		container?.loaders.set(id, loaderHandle);
+		syncSnapshot();
+		if (typeof window !== "undefined" && !isDetached && !loaded && !autoRequested) {
+			autoRequested = true;
+			queueMicrotask(() => {
+				load().catch(() => {});
+			});
+		}
+		return loaderHandle;
+	}, id));
+};
+//#endregion
+//#region core/internal.ts
+const COMPONENT_META_KEY = Symbol.for("eclipsa.component-meta");
+const LAZY_META_KEY = Symbol.for("eclipsa.lazy-meta");
+const NAVIGATE_META_KEY = Symbol.for("eclipsa.navigate-meta");
+const SIGNAL_META_KEY = Symbol.for("eclipsa.signal-meta");
+const ACTION_HOOK_META_KEY = Symbol.for("eclipsa.action-hook-meta");
+const ACTION_HANDLE_META_KEY = Symbol.for("eclipsa.action-handle-meta");
+const LOADER_HOOK_META_KEY = Symbol.for("eclipsa.loader-hook-meta");
+const LOADER_HANDLE_META_KEY = Symbol.for("eclipsa.loader-handle-meta");
+const WATCH_META_KEY = Symbol.for("eclipsa.watch-meta");
+const ACTION_HOOK_REGISTRY_KEY = Symbol.for("eclipsa.action-hook-registry");
+const LOADER_HOOK_REGISTRY_KEY = Symbol.for("eclipsa.loader-hook-registry");
+const __eclipsaComponent = (component, symbol, captures, projectionSlots) => {
+	Object.defineProperty(component, COMPONENT_META_KEY, {
+		configurable: true,
+		enumerable: false,
+		value: {
+			symbol,
+			captures,
+			...projectionSlots ? { projectionSlots } : {}
+		},
+		writable: true
+	});
+	return component;
+};
+const __eclipsaLazy = (symbol, fn, captures) => {
+	const wrapped = ((...args) => fn(...args));
+	Object.defineProperty(wrapped, LAZY_META_KEY, {
+		configurable: true,
+		enumerable: false,
+		value: {
+			symbol,
+			captures
+		},
+		writable: true
+	});
+	return wrapped;
+};
+const __eclipsaWatch = (symbol, fn, captures) => {
+	const wrapped = ((...args) => fn(...args));
+	Object.defineProperty(wrapped, WATCH_META_KEY, {
+		configurable: true,
+		enumerable: false,
+		value: {
+			symbol,
+			captures
+		},
+		writable: true
+	});
+	return wrapped;
+};
+const __eclipsaEvent = (eventName, symbol, captures) => ({
+	eventName,
+	symbol,
+	captures
+});
+const getComponentMeta = (value) => {
+	if (typeof value !== "function") return null;
+	return value[COMPONENT_META_KEY] ?? null;
+};
+const getLazyMeta = (value) => {
+	if (typeof value !== "function") return null;
+	return value[LAZY_META_KEY] ?? null;
+};
+const setNavigateMeta = (target) => {
+	Object.defineProperty(target, NAVIGATE_META_KEY, {
+		configurable: true,
+		enumerable: false,
+		value: { kind: "navigate" },
+		writable: true
+	});
+	return target;
+};
+const getNavigateMeta = (value) => {
+	if (typeof value !== "function") return null;
+	return value[NAVIGATE_META_KEY] ?? null;
+};
+const setActionHookMeta = (target, id) => {
+	Object.defineProperty(target, ACTION_HOOK_META_KEY, {
+		configurable: true,
+		enumerable: false,
+		value: {
+			id,
+			kind: "action-hook"
+		},
+		writable: true
+	});
+	return target;
+};
+const getActionHookMeta = (value) => {
+	if (typeof value !== "function") return null;
+	return value[ACTION_HOOK_META_KEY] ?? null;
+};
+const setActionHandleMeta = (target, id) => {
+	Object.defineProperty(target, ACTION_HANDLE_META_KEY, {
+		configurable: true,
+		enumerable: false,
+		value: {
+			id,
+			kind: "action"
+		},
+		writable: true
+	});
+	return target;
+};
+const getActionHandleMeta = (value) => {
+	if (!value || typeof value !== "object") return null;
+	return value[ACTION_HANDLE_META_KEY] ?? null;
+};
+const setLoaderHookMeta = (target, id) => {
+	Object.defineProperty(target, LOADER_HOOK_META_KEY, {
+		configurable: true,
+		enumerable: false,
+		value: {
+			id,
+			kind: "loader-hook"
+		},
+		writable: true
+	});
+	return target;
+};
+const getLoaderHookMeta = (value) => {
+	if (typeof value !== "function") return null;
+	return value[LOADER_HOOK_META_KEY] ?? null;
+};
+const setLoaderHandleMeta = (target, id) => {
+	Object.defineProperty(target, LOADER_HANDLE_META_KEY, {
+		configurable: true,
+		enumerable: false,
+		value: {
+			id,
+			kind: "loader"
+		},
+		writable: true
+	});
+	return target;
+};
+const getLoaderHandleMeta = (value) => {
+	if (!value || typeof value !== "object") return null;
+	return value[LOADER_HANDLE_META_KEY] ?? null;
+};
+const getActionHookRegistry = () => {
+	const globalRecord = globalThis;
+	const existing = globalRecord[ACTION_HOOK_REGISTRY_KEY];
+	if (existing instanceof Map) return existing;
+	const created = /* @__PURE__ */ new Map();
+	globalRecord[ACTION_HOOK_REGISTRY_KEY] = created;
+	return created;
+};
+const registerActionHook = (id, hook) => {
+	getActionHookRegistry().set(id, hook);
+	return hook;
+};
+const getRegisteredActionHook = (id) => getActionHookRegistry().get(id) ?? null;
+const getRegisteredActionHookIds = () => [...getActionHookRegistry().keys()];
+const getLoaderHookRegistry = () => {
+	const globalRecord = globalThis;
+	const existing = globalRecord[LOADER_HOOK_REGISTRY_KEY];
+	if (existing instanceof Map) return existing;
+	const created = /* @__PURE__ */ new Map();
+	globalRecord[LOADER_HOOK_REGISTRY_KEY] = created;
+	return created;
+};
+const registerLoaderHook = (id, hook) => {
+	getLoaderHookRegistry().set(id, hook);
+	return hook;
+};
+const getRegisteredLoaderHook = (id) => getLoaderHookRegistry().get(id) ?? null;
+const getRegisteredLoaderHookIds = () => [...getLoaderHookRegistry().keys()];
+const getWatchMeta = (value) => {
+	if (typeof value !== "function") return null;
+	return value[WATCH_META_KEY] ?? null;
+};
+const getEventMeta = (value) => {
+	if (value && typeof value === "object") {
+		const descriptor = value;
+		if (typeof descriptor.symbol === "string" && typeof descriptor.captures === "function") return descriptor;
+	}
+	return getLazyMeta(value);
+};
+const setSignalMeta = (target, meta) => {
+	Object.defineProperty(target, SIGNAL_META_KEY, {
+		configurable: true,
+		enumerable: false,
+		value: meta,
+		writable: true
+	});
+	return target;
+};
+const getSignalMeta = (value) => {
+	if (!value || typeof value !== "object") return null;
+	return value[SIGNAL_META_KEY] ?? null;
+};
+//#endregion
+//#region core/runtime.ts
+const CONTAINER_STACK_KEY = Symbol.for("eclipsa.container-stack");
+const FRAME_STACK_KEY = Symbol.for("eclipsa.frame-stack");
+const DIRTY_FLUSH_PROMISE_KEY = Symbol.for("eclipsa.dirty-flush-promise");
+const ASYNC_SIGNAL_SNAPSHOT_CACHE_KEY = Symbol.for("eclipsa.async-signal-snapshot-cache");
+const STANDALONE_SIGNAL_ID_KEY = Symbol.for("eclipsa.standalone-signal-id");
+const ACTION_FORM_ATTR$1 = "data-e-action-form";
+const ROUTER_EVENT_STATE_KEY = Symbol.for("eclipsa.router-event-state");
+const ROUTER_CURRENT_PATH_SIGNAL_ID = "$router:path";
+const ROUTER_IS_NAVIGATING_SIGNAL_ID = "$router:isNavigating";
+const ROUTER_LINK_BOUND_KEY = Symbol.for("eclipsa.router-link-bound");
+const ROUTER_LINK_PREFETCH_BOUND_KEY = Symbol.for("eclipsa.router-link-prefetch-bound");
+const ROUTE_NOT_FOUND_KEY = Symbol.for("eclipsa.route-not-found");
+const ROUTE_PARAMS_PROP = "__eclipsa_route_params";
+const ROUTE_SLOT_ROUTE_KEY = Symbol.for("eclipsa.route-slot-route");
+const RESUME_CONTAINERS_KEY = Symbol.for("eclipsa.resume-containers");
+const RESUME_STATE_ELEMENT_ID = "eclipsa-resume";
+const RESUME_FINAL_STATE_ELEMENT_ID = "eclipsa-resume-final";
+const ROOT_COMPONENT_ID = "$root";
+const SUSPENSE_COMPONENT_SYMBOL = "$suspense";
+const ROUTE_SLOT_TYPE = "route-slot";
+const PROJECTION_SLOT_TYPE = "projection-slot";
+const CONTAINER_ID_KEY = Symbol.for("eclipsa.runtime-container-id");
+const RENDER_COMPONENT_TYPE_KEY = Symbol.for("eclipsa.render-component-type");
+const RENDER_REFERENCE_KIND = "render";
+const REF_SIGNAL_ATTR = "data-e-ref";
+const STREAM_STATE_KEY = "__eclipsa_stream";
+const getDomContexts = (value) => {
+	const contexts = [];
+	if (!value || typeof value !== "object" && typeof value !== "function") return contexts;
+	if ("ownerDocument" in value) {
+		const ownerDocument = value.ownerDocument;
+		if (ownerDocument?.defaultView) contexts.push(ownerDocument.defaultView);
+	}
+	if ("defaultView" in value) {
+		const defaultView = value.defaultView;
+		if (defaultView) contexts.push(defaultView);
+	}
+	contexts.push(globalThis);
+	return contexts;
+};
+const isDomInstance = (value, name) => {
+	for (const context of getDomContexts(value)) {
+		const ctor = context[name];
+		if (typeof ctor === "function" && value instanceof ctor) return true;
+	}
+	return false;
+};
+const hasOwnerDocument = (value) => !!value && (typeof value === "object" || typeof value === "function") && "ownerDocument" in value && !!value.ownerDocument;
+const isElementNode = (value) => isDomInstance(value, "Element") || isDomInstance(value, "HTMLElement");
+const isHTMLElementNode = (value) => isDomInstance(value, "HTMLElement");
+const isHTMLInputElementNode = (value) => isDomInstance(value, "HTMLInputElement");
+const isHTMLTextAreaElementNode = (value) => isDomInstance(value, "HTMLTextAreaElement");
+const isTextEntryElement = (value) => isHTMLInputElementNode(value) || isHTMLTextAreaElementNode(value);
+const isHTMLAnchorElementNode = (value) => isDomInstance(value, "HTMLAnchorElement");
+const isHTMLFormElementNode = (value) => isDomInstance(value, "HTMLFormElement");
+const resolvedRuntimeSymbols = /* @__PURE__ */ new WeakMap();
+const getResolvedRuntimeSymbols = (container) => {
+	const existing = resolvedRuntimeSymbols.get(container);
+	if (existing) return existing;
+	const created = /* @__PURE__ */ new Map();
+	resolvedRuntimeSymbols.set(container, created);
+	return created;
+};
+const isRenderObject = (value) => typeof value === "object" && value !== null && "type" in value && "props" in value;
+const getContainerStack = () => {
+	const globalRecord = globalThis;
+	const existing = globalRecord[CONTAINER_STACK_KEY];
+	if (Array.isArray(existing)) return existing;
+	const created = [];
+	globalRecord[CONTAINER_STACK_KEY] = created;
+	return created;
+};
+const getFrameStack = () => {
+	const globalRecord = globalThis;
+	const existing = globalRecord[FRAME_STACK_KEY];
+	if (Array.isArray(existing)) return existing;
+	const created = [];
+	globalRecord[FRAME_STACK_KEY] = created;
+	return created;
+};
+const getResumeContainers = () => {
+	const globalRecord = globalThis;
+	const existing = globalRecord[RESUME_CONTAINERS_KEY];
+	if (existing instanceof Set) return existing;
+	const created = /* @__PURE__ */ new Set();
+	globalRecord[RESUME_CONTAINERS_KEY] = created;
+	return created;
+};
+const getCurrentContainer = () => {
+	const stack = getContainerStack();
+	return stack.length > 0 ? stack[stack.length - 1] : null;
+};
+const getAsyncSignalSnapshotCache = () => {
+	const globalRecord = globalThis;
+	const existing = globalRecord[ASYNC_SIGNAL_SNAPSHOT_CACHE_KEY];
+	if (existing instanceof Map) return existing;
+	const created = /* @__PURE__ */ new Map();
+	globalRecord[ASYNC_SIGNAL_SNAPSHOT_CACHE_KEY] = created;
+	return created;
+};
+const readAsyncSignalSnapshot = (id, container = getCurrentContainer()) => container?.asyncSignalStates.get(id) ?? container?.asyncSignalSnapshotCache.get(id) ?? getAsyncSignalSnapshotCache().get(id);
+const writeAsyncSignalSnapshot = (id, value, container = getCurrentContainer()) => {
+	container?.asyncSignalStates.set(id, value);
+	container?.asyncSignalSnapshotCache.set(id, value);
+	if (!container) getAsyncSignalSnapshotCache().set(id, value);
+};
+const getCurrentFrame = () => {
+	const stack = getFrameStack();
+	return stack.length > 0 ? stack[stack.length - 1] : null;
+};
+const normalizeRoutePath = (pathname) => {
+	const normalizedPath = pathname.trim() || "/";
+	const withLeadingSlash = normalizedPath.startsWith("/") ? normalizedPath : `/${normalizedPath}`;
+	if (withLeadingSlash.length > 1 && withLeadingSlash.endsWith("/")) return withLeadingSlash.slice(0, -1);
+	return withLeadingSlash;
+};
+const EMPTY_ROUTE_PARAMS = Object.freeze({});
+const splitRoutePath = (pathname) => normalizeRoutePath(pathname).split("/").filter(Boolean);
+const matchRouteSegments = (segments, pathnameSegments, routeIndex = 0, pathIndex = 0, params = {}) => {
+	if (routeIndex >= segments.length) return pathIndex >= pathnameSegments.length ? params : null;
+	const segment = segments[routeIndex];
+	switch (segment.kind) {
+		case "static":
+			if (pathnameSegments[pathIndex] !== segment.value) return null;
+			return matchRouteSegments(segments, pathnameSegments, routeIndex + 1, pathIndex + 1, params);
+		case "required":
+			if (pathIndex >= pathnameSegments.length) return null;
+			return matchRouteSegments(segments, pathnameSegments, routeIndex + 1, pathIndex + 1, {
+				...params,
+				[segment.value]: pathnameSegments[pathIndex]
+			});
+		case "optional": {
+			const consumed = pathIndex < pathnameSegments.length ? matchRouteSegments(segments, pathnameSegments, routeIndex + 1, pathIndex + 1, {
+				...params,
+				[segment.value]: pathnameSegments[pathIndex]
+			}) : null;
+			if (consumed) return consumed;
+			return matchRouteSegments(segments, pathnameSegments, routeIndex + 1, pathIndex, {
+				...params,
+				[segment.value]: void 0
+			});
+		}
+		case "rest": return matchRouteSegments(segments, pathnameSegments, segments.length, pathnameSegments.length, {
+			...params,
+			[segment.value]: pathnameSegments.slice(pathIndex)
+		});
+	}
+};
+const matchRouteManifest = (manifest, pathname) => {
+	const normalizedPath = normalizeRoutePath(pathname);
+	const pathnameSegments = splitRoutePath(normalizedPath);
+	for (const entry of manifest) {
+		const params = matchRouteSegments(entry.segments, pathnameSegments);
+		if (params) return {
+			entry,
+			params,
+			pathname: normalizedPath
+		};
+	}
+	return null;
+};
+const scoreSpecialManifestEntry = (entry, pathname) => {
+	const pathnameSegments = splitRoutePath(pathname);
+	let score = 0;
+	for (let index = 0; index < entry.segments.length && index < pathnameSegments.length; index += 1) {
+		const segment = entry.segments[index];
+		const pathnameSegment = pathnameSegments[index];
+		if (segment.kind === "static") {
+			if (segment.value !== pathnameSegment) break;
+			score += 10;
+			continue;
+		}
+		score += segment.kind === "rest" ? 1 : 2;
+		if (segment.kind === "rest") break;
+	}
+	return score;
+};
+const findSpecialManifestEntry = (manifest, pathname, kind) => {
+	const matched = matchRouteManifest(manifest, pathname);
+	if (matched?.entry[kind]) return matched;
+	let best = null;
+	let bestScore = -1;
+	for (const entry of manifest) {
+		if (!entry[kind]) continue;
+		const score = scoreSpecialManifestEntry(entry, pathname);
+		if (score > bestScore) {
+			best = {
+				entry,
+				params: EMPTY_ROUTE_PARAMS,
+				pathname: normalizeRoutePath(pathname)
+			};
+			bestScore = score;
+		}
+	}
+	return best;
+};
+const routeCacheKey = (pathname, variant = "page") => `${normalizeRoutePath(pathname)}::${variant}`;
+const routePrefetchKey = (url) => `${normalizeRoutePath(url.pathname)}${url.search}`;
+let currentEffect = null;
+let currentCleanupSlot = null;
+const withoutTrackedEffect = (fn) => {
+	const previous = currentEffect;
+	currentEffect = null;
+	try {
+		return fn();
+	} finally {
+		currentEffect = previous;
+	}
+};
+const createCleanupSlot = () => ({ callbacks: [] });
+const withCleanupSlot = (slot, fn) => {
+	const previous = currentCleanupSlot;
+	currentCleanupSlot = slot;
+	try {
+		return fn();
+	} finally {
+		currentCleanupSlot = previous;
+	}
+};
+const disposeCleanupSlot = (slot) => {
+	if (!slot || slot.callbacks.length === 0) return;
+	const callbacks = [...slot.callbacks].reverse();
+	slot.callbacks.length = 0;
+	let firstError = null;
+	const previous = currentCleanupSlot;
+	currentCleanupSlot = null;
+	try {
+		for (const callback of callbacks) try {
+			withoutTrackedEffect(callback);
+		} catch (error) {
+			firstError ??= error;
+		}
+	} finally {
+		currentCleanupSlot = previous;
+	}
+	if (firstError) throw firstError;
+};
+const clearEffectSignals = (effect) => {
+	for (const signal of effect.signals) signal.effects.delete(effect);
+	effect.signals.clear();
+};
+const collectTrackedDependencies = (effect, fn) => {
+	clearEffectSignals(effect);
+	currentEffect = effect;
+	try {
+		fn();
+	} finally {
+		currentEffect = null;
+	}
+};
+const trackWatchDependencies = (dependencies) => {
+	for (const dependency of dependencies) {
+		if (typeof dependency === "function") {
+			dependency();
+			continue;
+		}
+		if (!getSignalMeta(dependency)) throw new TypeError("useWatch dependencies must be signals or getter functions.");
+		dependency.value;
+	}
+};
+const runWatchCallback = (effect, cleanupSlot, fn, dependencies) => {
+	disposeCleanupSlot(cleanupSlot);
+	if (!dependencies) {
+		collectTrackedDependencies(effect, () => {
+			withCleanupSlot(cleanupSlot, fn);
+		});
+		return;
+	}
+	collectTrackedDependencies(effect, () => {
+		trackWatchDependencies(dependencies);
+	});
+	withCleanupSlot(cleanupSlot, fn);
+};
+const createLocalWatchRunner = (effect, cleanupSlot, fn, dependencies) => () => {
+	runWatchCallback(effect, cleanupSlot, fn, dependencies);
+};
+const isPlainObject = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+};
+const isProjectionSlot = (value) => isPlainObject(value) && value.__eclipsa_type === PROJECTION_SLOT_TYPE;
+const createProjectionSlot = (componentId, name, occurrence, source) => ({
+	__eclipsa_type: PROJECTION_SLOT_TYPE,
+	componentId,
+	name,
+	occurrence,
+	source
+});
+const encodeProjectionSlotName = (value) => encodeURIComponent(value);
+const decodeProjectionSlotName = (value) => decodeURIComponent(value);
+const createProjectionSlotMarker = (componentId, name, occurrence, kind) => `ec:s:${componentId}:${encodeProjectionSlotName(name)}:${occurrence}:${kind}`;
+const PROJECTION_SLOT_MARKER_REGEX = /^ec:s:([^:]+):([^:]+):(\d+):(start|end)$/;
+const parseProjectionSlotMarker = (value) => {
+	const matched = value.match(PROJECTION_SLOT_MARKER_REGEX);
+	if (!matched) return null;
+	return {
+		componentId: matched[1],
+		kind: matched[4],
+		key: `${matched[1]}:${matched[2]}:${matched[3]}`,
+		name: decodeProjectionSlotName(matched[2]),
+		occurrence: Number(matched[3])
+	};
+};
+const getRenderComponentTypeRef = (value) => {
+	if (typeof value !== "function") return null;
+	return value[RENDER_COMPONENT_TYPE_KEY] ?? null;
+};
+const createMaterializedRenderComponentType = (container, symbol, scopeId) => {
+	const component = __eclipsaComponent(((props) => {
+		const module = getResolvedRuntimeSymbols(container).get(symbol);
+		if (!module) throw new Error(`Missing preloaded render component symbol ${symbol}.`);
+		return module.default(materializeScope(container, scopeId), props);
+	}), symbol, () => materializeScope(container, scopeId));
+	Object.defineProperty(component, RENDER_COMPONENT_TYPE_KEY, {
+		configurable: true,
+		enumerable: false,
+		value: {
+			scopeId,
+			symbol
+		},
+		writable: true
+	});
+	return component;
+};
+const serializeRenderObjectReference = (container, value) => {
+	const evaluatedProps = evaluateProps(value.props);
+	const key = value.key ?? null;
+	const metadata = value.metadata ?? null;
+	if (typeof value.type === "string") return {
+		__eclipsa_type: "ref",
+		data: [
+			"element",
+			value.type,
+			null,
+			serializeRuntimeValue(container, evaluatedProps),
+			serializeRuntimeValue(container, key),
+			value.isStatic,
+			serializeRuntimeValue(container, metadata)
+		],
+		kind: RENDER_REFERENCE_KIND,
+		token: "jsx"
+	};
+	const meta = getComponentMeta(value.type);
+	if (!meta) throw new TypeError("Only resumable component render objects can be serialized.");
+	return {
+		__eclipsa_type: "ref",
+		data: [
+			"component",
+			meta.symbol,
+			registerScope(container, meta.captures()),
+			serializeRuntimeValue(container, evaluatedProps),
+			serializeRuntimeValue(container, key),
+			value.isStatic,
+			serializeRuntimeValue(container, metadata)
+		],
+		kind: RENDER_REFERENCE_KIND,
+		token: "jsx"
+	};
+};
+const deserializeRenderObjectReference = (container, data) => {
+	if (!Array.isArray(data) || data.length !== 7) throw new TypeError("Render references require a seven-part payload.");
+	const [variant, typeValue, scopeValue, propsValue, keyValue, isStaticValue, metadataValue] = data;
+	if (variant !== "element" && variant !== "component") throw new TypeError(`Unsupported render reference variant "${String(variant)}".`);
+	if (typeof isStaticValue !== "boolean") throw new TypeError("Render references require a boolean static flag.");
+	const props = deserializeRuntimeValue(container, propsValue);
+	const key = deserializeRuntimeValue(container, keyValue);
+	const metadata = deserializeRuntimeValue(container, metadataValue);
+	if (!props || typeof props !== "object") throw new TypeError("Render references require object props.");
+	if (variant === "element") {
+		if (typeof typeValue !== "string") throw new TypeError("Element render references require a string tag name.");
+		return {
+			isStatic: isStaticValue,
+			key: key ?? void 0,
+			metadata: metadata ?? void 0,
+			props,
+			type: typeValue
+		};
+	}
+	if (typeof typeValue !== "string" || typeof scopeValue !== "string") throw new TypeError("Component render references require a symbol id and scope id.");
+	return {
+		isStatic: isStaticValue,
+		key: key ?? void 0,
+		metadata: metadata ?? void 0,
+		props,
+		type: createMaterializedRenderComponentType(container, typeValue, scopeValue)
+	};
+};
+const preloadResumableValue = async (container, value, seen = /* @__PURE__ */ new Set()) => {
+	if (value === null || value === void 0 || value === false) return;
+	if (seen.has(value)) return;
+	if (typeof value === "function") {
+		const renderComponentRef = getRenderComponentTypeRef(value);
+		if (!renderComponentRef) return;
+		seen.add(value);
+		await loadSymbol(container, renderComponentRef.symbol);
+		for (const capturedValue of materializeScope(container, renderComponentRef.scopeId)) await preloadResumableValue(container, capturedValue, seen);
+		return;
+	}
+	if (Array.isArray(value)) {
+		seen.add(value);
+		for (const entry of value) await preloadResumableValue(container, entry, seen);
+		return;
+	}
+	if (typeof Node !== "undefined" && value instanceof Node) return;
+	if (isProjectionSlot(value)) return;
+	if (isRenderObject(value)) {
+		seen.add(value);
+		await preloadResumableValue(container, value.type, seen);
+		await preloadResumableValue(container, evaluateProps(value.props), seen);
+		return;
+	}
+	if (!isPlainObject(value)) return;
+	seen.add(value);
+	for (const entry of Object.values(value)) await preloadResumableValue(container, entry, seen);
+};
+const serializeRuntimeValue = (container, value) => serializeValue(value, { serializeReference(candidate) {
+	const signalMeta = getSignalMeta(candidate);
+	if (signalMeta) return {
+		__eclipsa_type: "ref",
+		kind: "signal",
+		token: signalMeta.id
+	};
+	if (getNavigateMeta(candidate)) return {
+		__eclipsa_type: "ref",
+		kind: "navigate",
+		token: "navigate"
+	};
+	const actionMeta = getActionHandleMeta(candidate);
+	if (actionMeta) return {
+		__eclipsa_type: "ref",
+		kind: "action",
+		token: actionMeta.id
+	};
+	const actionHookMeta = getActionHookMeta(candidate);
+	if (actionHookMeta) return {
+		__eclipsa_type: "ref",
+		kind: "action-hook",
+		token: actionHookMeta.id
+	};
+	const loaderMeta = getLoaderHandleMeta(candidate);
+	if (loaderMeta) return {
+		__eclipsa_type: "ref",
+		kind: "loader",
+		token: loaderMeta.id
+	};
+	const loaderHookMeta = getLoaderHookMeta(candidate);
+	if (loaderHookMeta) return {
+		__eclipsa_type: "ref",
+		kind: "loader-hook",
+		token: loaderHookMeta.id
+	};
+	if (isRouteSlot(candidate)) return {
+		__eclipsa_type: "ref",
+		data: serializeValue(candidate.startLayoutIndex),
+		kind: "route-slot",
+		token: candidate.pathname
+	};
+	if (isProjectionSlot(candidate)) return {
+		__eclipsa_type: "ref",
+		data: serializeRuntimeValue(container, candidate.source),
+		kind: PROJECTION_SLOT_TYPE,
+		token: JSON.stringify([
+			candidate.componentId,
+			candidate.name,
+			candidate.occurrence
+		])
+	};
+	if (isRenderObject(candidate)) return serializeRenderObjectReference(container, candidate);
+	const lazyMeta = getLazyMeta(candidate);
+	if (lazyMeta) return {
+		__eclipsa_type: "ref",
+		data: lazyMeta.captures().map((entry) => serializeRuntimeValue(container, entry)),
+		kind: "symbol",
+		token: lazyMeta.symbol
+	};
+	if (isElementNode(candidate)) return {
+		__eclipsa_type: "ref",
+		kind: "dom",
+		token: ensureRuntimeElementId(container, candidate)
+	};
+	return null;
+} });
+const deserializeRuntimeValue = (container, value) => deserializeValue(value, { deserializeReference(reference) {
+	if (reference.kind === "navigate") return ensureRouterState(container).navigate;
+	if (reference.kind === "action") {
+		const action = container.actions.get(reference.token);
+		if (!action) throw new Error(`Missing action handle ${reference.token}.`);
+		return action;
+	}
+	if (reference.kind === "action-hook") {
+		const actionHook = getRegisteredActionHook(reference.token);
+		if (!actionHook) throw new Error(`Missing action hook ${reference.token}.`);
+		return actionHook;
+	}
+	if (reference.kind === "loader") {
+		const loader = container.loaders.get(reference.token);
+		if (!loader) throw new Error(`Missing loader handle ${reference.token}.`);
+		return loader;
+	}
+	if (reference.kind === "loader-hook") {
+		const loaderHook = getRegisteredLoaderHook(reference.token);
+		if (!loaderHook) throw new Error(`Missing loader hook ${reference.token}.`);
+		return loaderHook;
+	}
+	if (reference.kind === "route-slot") {
+		const startLayoutIndex = reference.data === void 0 ? 0 : deserializeValue(reference.data);
+		if (typeof startLayoutIndex !== "number" || !Number.isInteger(startLayoutIndex)) throw new TypeError("Route slot references require an integer start layout index.");
+		return {
+			__eclipsa_type: ROUTE_SLOT_TYPE,
+			pathname: reference.token,
+			startLayoutIndex
+		};
+	}
+	if (reference.kind === PROJECTION_SLOT_TYPE) {
+		let componentId = "";
+		let name = "";
+		let occurrence = 0;
+		try {
+			const parsed = JSON.parse(reference.token);
+			if (!Array.isArray(parsed) || parsed.length !== 3 || typeof parsed[0] !== "string" || typeof parsed[1] !== "string" || typeof parsed[2] !== "number") throw new Error("invalid projection slot token");
+			componentId = parsed[0];
+			name = parsed[1];
+			occurrence = parsed[2];
+		} catch {
+			throw new TypeError("Projection slot references require a component id, name, and occurrence.");
+		}
+		return createProjectionSlot(componentId, name, occurrence, deserializeRuntimeValue(container, reference.data));
+	}
+	if (reference.kind === "signal") {
+		const record = container.signals.get(reference.token);
+		if (!record) throw new Error(`Missing signal ${reference.token}.`);
+		return record.handle;
+	}
+	if (reference.kind === "symbol") {
+		if (!reference.data || !Array.isArray(reference.data)) throw new TypeError("Symbol references require an encoded scope array.");
+		const scopeId = registerSerializedScope(container, reference.data);
+		return materializeSymbolReference(container, reference.token, scopeId);
+	}
+	if (reference.kind === RENDER_REFERENCE_KIND) return deserializeRenderObjectReference(container, reference.data);
+	if (reference.kind === "dom") {
+		const element = findRuntimeElement(container, reference.token);
+		if (!element) throw new Error(`Missing DOM reference ${reference.token}.`);
+		return element;
+	}
+	throw new TypeError(`Unsupported runtime reference kind "${reference.kind}".`);
+} });
+const findNextNumericId = (ids, prefix) => {
+	let nextId = 0;
+	for (const id of ids) {
+		if (!id.startsWith(prefix)) continue;
+		const suffix = id.slice(prefix.length);
+		if (!/^\d+$/.test(suffix)) continue;
+		nextId = Math.max(nextId, Number(suffix) + 1);
+	}
+	return nextId;
+};
+const getRefSignalId = (value) => getSignalMeta(value)?.id ?? null;
+const assignRuntimeRef = (value, element, container = getCurrentContainer()) => {
+	const signalMeta = getSignalMeta(value);
+	if (!signalMeta) return false;
+	const record = container?.signals.get(signalMeta.id);
+	if (record) {
+		record.value = element;
+		return true;
+	}
+	signalMeta.set(element);
+	return true;
+};
+const restoreSignalRefs = (container, root) => {
+	const assignElement = (element) => {
+		const signalId = element.getAttribute(REF_SIGNAL_ATTR);
+		if (!signalId) return;
+		const record = container.signals.get(signalId);
+		if (!record) return;
+		record.value = element;
+	};
+	if (isElementNode(root) && root.getAttribute(REF_SIGNAL_ATTR)) assignElement(root);
+	if (!("querySelectorAll" in root)) return;
+	for (const element of root.querySelectorAll(`[${REF_SIGNAL_ATTR}]`)) assignElement(element);
+};
+const evaluateProps = (props) => {
+	const result = {};
+	for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(props))) if (descriptor.get) result[key] = descriptor.get.call(props);
+	else result[key] = descriptor.value;
+	return result;
+};
+const hasProjectionSlotValue = (props, name) => Object.prototype.hasOwnProperty.call(props, name);
+const createRenderProps = (componentId, meta, props) => {
+	if (!meta.projectionSlots || Object.keys(meta.projectionSlots).length === 0) return props;
+	const nextProps = { ...props };
+	const counters = /* @__PURE__ */ new Map();
+	for (const [name, totalOccurrences] of Object.entries(meta.projectionSlots)) Object.defineProperty(nextProps, name, {
+		configurable: true,
+		enumerable: true,
+		get() {
+			if (!hasProjectionSlotValue(props, name)) return;
+			const current = counters.get(name) ?? 0;
+			counters.set(name, current + 1);
+			return createProjectionSlot(componentId, name, totalOccurrences > 0 ? current % totalOccurrences : current, props[name]);
+		}
+	});
+	return nextProps;
+};
+const preloadComponentProps = async (container, meta, props) => {
+	if (!props || typeof props !== "object" || !meta.projectionSlots) {
+		await preloadResumableValue(container, props);
+		return;
+	}
+	const projectionNames = new Set(Object.keys(meta.projectionSlots));
+	const entries = {};
+	for (const [key, value] of Object.entries(props)) {
+		if (projectionNames.has(key)) continue;
+		entries[key] = value;
+	}
+	await preloadResumableValue(container, entries);
+};
+const createContainer = (symbols, doc, asyncSignalSnapshotCache) => ({
+	actions: /* @__PURE__ */ new Map(),
+	actionStates: /* @__PURE__ */ new Map(),
+	asyncSignalStates: /* @__PURE__ */ new Map(),
+	asyncSignalSnapshotCache: asyncSignalSnapshotCache ?? /* @__PURE__ */ new Map(),
+	components: /* @__PURE__ */ new Map(),
+	dirty: /* @__PURE__ */ new Set(),
+	doc,
+	id: `rt${globalThis[CONTAINER_ID_KEY] = (globalThis[CONTAINER_ID_KEY] ?? 0) + 1}`,
+	imports: /* @__PURE__ */ new Map(),
+	loaderStates: /* @__PURE__ */ new Map(),
+	loaders: /* @__PURE__ */ new Map(),
+	nextComponentId: 0,
+	nextElementId: 0,
+	nextScopeId: 0,
+	nextSignalId: 0,
+	pendingSuspensePromises: /* @__PURE__ */ new Set(),
+	rootChildCursor: 0,
+	rootElement: doc?.body,
+	router: null,
+	scopes: /* @__PURE__ */ new Map(),
+	signals: /* @__PURE__ */ new Map(),
+	symbols: new Map(Object.entries(symbols)),
+	visibilityCheckQueued: false,
+	visibilityListenersCleanup: null,
+	visibles: /* @__PURE__ */ new Map(),
+	watches: /* @__PURE__ */ new Map()
+});
+const registerResumeContainer = (container) => {
+	const containers = getResumeContainers();
+	containers.add(container);
+	return () => {
+		containers.delete(container);
+	};
+};
+const createSignalHandle = (record, container) => {
+	const handle = {};
+	Object.defineProperty(handle, "value", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			recordSignalRead(record);
+			return record.value;
+		},
+		set(value) {
+			record.value = value;
+			notifySignalWrite(container, record);
+		}
+	});
+	setSignalMeta(handle, {
+		get: () => record.value,
+		id: record.id,
+		set: (value) => {
+			record.value = value;
+			notifySignalWrite(container, record);
+		}
+	});
+	return handle;
+};
+const ensureSignalRecord = (container, id, initialValue) => {
+	if (!container) {
+		const record = {
+			effects: /* @__PURE__ */ new Set(),
+			handle: void 0,
+			id,
+			subscribers: /* @__PURE__ */ new Set(),
+			value: initialValue
+		};
+		record.handle = createSignalHandle(record, null);
+		return record;
+	}
+	const existing = container.signals.get(id);
+	if (existing) return existing;
+	const record = {
+		effects: /* @__PURE__ */ new Set(),
+		handle: void 0,
+		id,
+		subscribers: /* @__PURE__ */ new Set(),
+		value: initialValue
+	};
+	record.handle = createSignalHandle(record, container);
+	container.signals.set(id, record);
+	return record;
+};
+const isRouterSignalId = (id) => id === ROUTER_CURRENT_PATH_SIGNAL_ID || id === ROUTER_IS_NAVIGATING_SIGNAL_ID;
+const createStandaloneNavigate = () => {
+	const navigate = (async (href, options) => {
+		if (typeof window === "undefined") return;
+		const url = new URL(href, window.location.href);
+		if (options?.replace) {
+			window.location.replace(url.href);
+			return;
+		}
+		window.location.assign(url.href);
+	});
+	Object.defineProperty(navigate, "isNavigating", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			return false;
+		}
+	});
+	return setNavigateMeta(navigate);
+};
+const recordSignalRead = (record) => {
+	if (currentEffect) {
+		currentEffect.signals.add(record);
+		record.effects.add(currentEffect);
+	}
+	const frame = getCurrentFrame();
+	if (!frame) return;
+	record.subscribers.add(frame.component.id);
+};
+const notifySignalWrite = (container, record) => {
+	for (const effect of [...record.effects]) effect.fn();
+	if (!container) return;
+	for (const componentId of record.subscribers) {
+		if (container.components.get(componentId)?.active) continue;
+		container.dirty.add(componentId);
+	}
+};
+const ensureRouterState = (container, manifest) => {
+	if (container.router) {
+		if (manifest) container.router.manifest = [...manifest];
+		return container.router;
+	}
+	const currentPath = ensureSignalRecord(container, ROUTER_CURRENT_PATH_SIGNAL_ID, normalizeRoutePath(container.doc?.location.pathname ?? "/")).handle;
+	const isNavigating = ensureSignalRecord(container, ROUTER_IS_NAVIGATING_SIGNAL_ID, false).handle;
+	const router = {
+		currentPath,
+		currentRoute: null,
+		defaultTitle: container.doc?.title ?? "",
+		isNavigating,
+		loadedRoutes: /* @__PURE__ */ new Map(),
+		manifest: [],
+		navigate: void 0,
+		prefetchedLoaders: /* @__PURE__ */ new Map(),
+		routePrefetches: /* @__PURE__ */ new Map(),
+		sequence: 0
+	};
+	container.router = router;
+	router.navigate = setNavigateMeta((async (href, options) => {
+		await navigateContainer(container, href, { mode: options?.replace ? "replace" : "push" });
+	}));
+	Object.defineProperty(router.navigate, "isNavigating", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			return ensureRouterState(container).isNavigating.value;
+		}
+	});
+	if (manifest) router.manifest = [...manifest];
+	return router;
+};
+const pushContainer = (container, fn) => {
+	const stack = getContainerStack();
+	stack.push(container);
+	try {
+		return fn();
+	} finally {
+		stack.pop();
+	}
+};
+const withRuntimeContainer = pushContainer;
+const pushFrame = (frame, fn) => {
+	const stack = getFrameStack();
+	stack.push(frame);
+	try {
+		return fn();
+	} finally {
+		stack.pop();
+	}
+};
+const allocateScopeId = (container) => `sc${container.nextScopeId++}`;
+const ensureRuntimeElementId = (container, element) => {
+	const existingId = element.getAttribute("data-eid");
+	if (existingId) return existingId;
+	const nextId = `e${container.nextElementId++}`;
+	element.setAttribute("data-eid", nextId);
+	return nextId;
+};
+const findRuntimeElement = (container, elementId) => {
+	const root = container.rootElement ?? container.doc?.body;
+	if (!root) return null;
+	if (root.getAttribute("data-eid") === elementId) return root;
+	return root.querySelector(`[data-eid="${elementId}"]`);
+};
+const registerScope = (container, values) => {
+	const id = allocateScopeId(container);
+	container.scopes.set(id, values.map((value) => serializeRuntimeValue(container, value)));
+	return id;
+};
+const registerSerializedScope = (container, values) => {
+	const id = allocateScopeId(container);
+	container.scopes.set(id, [...values]);
+	return id;
+};
+const materializeSymbolReference = (container, symbolId, scopeId) => {
+	const fn = (...args) => {
+		loadSymbol(container, symbolId).then((module) => module.default(materializeScope(container, scopeId), ...args));
+	};
+	Object.defineProperty(fn, "name", {
+		configurable: true,
+		value: `eclipsa$${symbolId}`
+	});
+	return fn;
+};
+const materializeScope = (container, scopeId) => {
+	const slots = container.scopes.get(scopeId);
+	if (!slots) throw new Error(`Missing scope ${scopeId}.`);
+	return slots.map((slot) => deserializeRuntimeValue(container, slot));
+};
+const createFrame = (container, component, mode, options) => ({
+	childCursor: 0,
+	component,
+	container,
+	mountCallbacks: [],
+	mode,
+	projectionState: {
+		counters: /* @__PURE__ */ new Map(),
+		reuseExistingDom: options?.reuseExistingDom ?? false
+	},
+	signalCursor: 0,
+	visibleCursor: 0,
+	visitedDescendants: /* @__PURE__ */ new Set(),
+	watchCursor: 0
+});
+const createComponentId = (container, parentId, childIndex) => {
+	if (!parentId || parentId === ROOT_COMPONENT_ID) return `c${childIndex}`;
+	return `${parentId}.${childIndex}`;
+};
+const getOrCreateComponentState = (container, id, symbol, parentId) => {
+	const existing = container.components.get(id);
+	if (existing) {
+		existing.parentId = parentId;
+		existing.symbol = symbol;
+		return existing;
+	}
+	const component = {
+		active: false,
+		didMount: false,
+		id,
+		mountCleanupSlots: [],
+		parentId,
+		props: {},
+		projectionSlots: null,
+		reuseExistingDomOnActivate: true,
+		scopeId: registerScope(container, []),
+		signalIds: [],
+		symbol,
+		suspensePromise: null,
+		visibleCount: 0,
+		watchCount: 0
+	};
+	container.components.set(id, component);
+	return component;
+};
+const resetComponentForSymbolChange = (container, component, meta) => {
+	disposeComponentMountCleanups(component);
+	component.didMount = false;
+	component.projectionSlots = meta.projectionSlots ?? null;
+	component.scopeId = registerScope(container, meta.captures());
+	component.signalIds = [];
+	component.suspensePromise = null;
+	pruneComponentVisibles(container, component, 0);
+	pruneComponentWatches(container, component, 0);
+};
+const createWatchId = (componentId, watchIndex) => `${componentId}:w${watchIndex}`;
+const createVisibleId = (componentId, visibleIndex) => `${componentId}:v${visibleIndex}`;
+const getOrCreateWatchState = (container, id, componentId) => {
+	const existing = container.watches.get(id);
+	if (existing) {
+		existing.componentId = componentId;
+		return existing;
+	}
+	const effect = {
+		fn() {},
+		signals: /* @__PURE__ */ new Set()
+	};
+	const watch = {
+		cleanupSlot: createCleanupSlot(),
+		componentId,
+		effect,
+		id,
+		mode: "dynamic",
+		pending: null,
+		run: null,
+		scopeId: registerScope(container, []),
+		symbol: "",
+		track: null
+	};
+	effect.fn = () => {
+		if (watch.run) {
+			watch.run();
+			return;
+		}
+		if (!container.doc) return;
+		const queued = (watch.pending ?? Promise.resolve()).then(async () => {
+			disposeCleanupSlot(watch.cleanupSlot);
+			const module = await loadSymbol(container, watch.symbol);
+			const scope = materializeScope(container, watch.scopeId);
+			await withClientContainer(container, () => {
+				if (watch.mode === "dynamic") {
+					collectTrackedDependencies(effect, () => {
+						withCleanupSlot(watch.cleanupSlot, () => {
+							module.default(scope);
+						});
+					});
+					return;
+				}
+				collectTrackedDependencies(effect, () => {
+					module.default(scope, "track");
+				});
+				withCleanupSlot(watch.cleanupSlot, () => {
+					module.default(scope, "run");
+				});
+			});
+			await flushDirtyComponents(container);
+		}).finally(() => {
+			if (watch.pending === queued) watch.pending = null;
+		});
+		watch.pending = queued;
+	};
+	container.watches.set(id, watch);
+	return watch;
+};
+const getOrCreateVisibleState = (container, id, componentId) => {
+	const existing = container.visibles.get(id);
+	if (existing) {
+		existing.componentId = componentId;
+		return existing;
+	}
+	const visible = {
+		cleanupSlot: createCleanupSlot(),
+		componentId,
+		done: false,
+		id,
+		pending: null,
+		run: null,
+		scopeId: registerScope(container, []),
+		symbol: ""
+	};
+	container.visibles.set(id, visible);
+	return visible;
+};
+const clearComponentSubscriptions = (container, componentId) => {
+	for (const record of container.signals.values()) record.subscribers.delete(componentId);
+};
+const disposeComponentMountCleanups = (component) => {
+	const cleanupSlots = [...component.mountCleanupSlots].reverse();
+	component.mountCleanupSlots = [];
+	for (const cleanupSlot of cleanupSlots) disposeCleanupSlot(cleanupSlot);
+};
+const removeWatchState = (container, watchId) => {
+	const watch = container.watches.get(watchId);
+	if (!watch) return;
+	disposeCleanupSlot(watch.cleanupSlot);
+	clearEffectSignals(watch.effect);
+	container.watches.delete(watchId);
+};
+const removeVisibleState = (container, visibleId) => {
+	const visible = container.visibles.get(visibleId);
+	if (visible) disposeCleanupSlot(visible.cleanupSlot);
+	container.visibles.delete(visibleId);
+};
+const resetVisibleState = (visible) => {
+	disposeCleanupSlot(visible.cleanupSlot);
+	visible.cleanupSlot = createCleanupSlot();
+	visible.done = false;
+	visible.pending = null;
+};
+const resetComponentVisibleStates = (container, componentId) => {
+	const targetIds = new Set([componentId, ...collectDescendantIds(container, componentId)]);
+	for (const visible of container.visibles.values()) {
+		if (!targetIds.has(visible.componentId)) continue;
+		resetVisibleState(visible);
+	}
+};
+const pruneComponentWatches = (container, component, nextCount) => {
+	for (let index = nextCount; index < component.watchCount; index++) removeWatchState(container, createWatchId(component.id, index));
+	component.watchCount = nextCount;
+};
+const pruneComponentVisibles = (container, component, nextCount) => {
+	for (let index = nextCount; index < component.visibleCount; index++) removeVisibleState(container, createVisibleId(component.id, index));
+	component.visibleCount = nextCount;
+};
+const isDescendantOf = (parentId, candidateId) => candidateId.startsWith(`${parentId}.`);
+const collectDescendantIds = (container, componentId) => [...container.components.keys()].filter((candidate) => isDescendantOf(componentId, candidate));
+const pruneRemovedComponents = (container, componentId, keep) => {
+	for (const descendantId of collectDescendantIds(container, componentId)) {
+		if (keep.has(descendantId)) continue;
+		clearComponentSubscriptions(container, descendantId);
+		const descendant = container.components.get(descendantId);
+		if (descendant) {
+			disposeComponentMountCleanups(descendant);
+			pruneComponentVisibles(container, descendant, 0);
+			pruneComponentWatches(container, descendant, 0);
+		}
+		container.components.delete(descendantId);
+	}
+};
+const scheduleMicrotask = (fn) => {
+	if (typeof queueMicrotask === "function") {
+		queueMicrotask(fn);
+		return;
+	}
+	Promise.resolve().then(fn);
+};
+const scheduleVisibleCallbacksCheck = (container) => {
+	if (container.visibilityCheckQueued || container.visibles.size === 0 || !container.doc) return;
+	ensureVisibilityListeners(container);
+	container.visibilityCheckQueued = true;
+	const run = () => {
+		container.visibilityCheckQueued = false;
+		flushVisibleCallbacks(container);
+	};
+	const view = container.doc.defaultView;
+	if (view && typeof view.requestAnimationFrame === "function") {
+		view.requestAnimationFrame(() => run());
+		return;
+	}
+	scheduleMicrotask(run);
+};
+const rectIntersectsViewport = (view, rect) => {
+	const viewportHeight = view.innerHeight ?? 0;
+	const viewportWidth = view.innerWidth ?? 0;
+	return rect.bottom > 0 && rect.right > 0 && rect.top < viewportHeight && rect.left < viewportWidth;
+};
+const isBoundaryVisible = (doc, start, end) => {
+	const view = doc.defaultView;
+	if (typeof doc.createRange !== "function" || !view) return false;
+	const range = doc.createRange();
+	range.setStartAfter(start);
+	range.setEndBefore(end);
+	const rects = range.getClientRects();
+	if (rects.length === 0) return rectIntersectsViewport(view, range.getBoundingClientRect());
+	for (let index = 0; index < rects.length; index++) {
+		const rect = rects[index];
+		if (rectIntersectsViewport(view, rect)) return true;
+	}
+	return false;
+};
+const runVisibleCallback = async (container, visible) => {
+	if (visible.done) return;
+	visible.done = true;
+	const pending = Promise.resolve().then(async () => {
+		if (visible.run) await withClientContainer(container, async () => {
+			await withCleanupSlot(visible.cleanupSlot, () => visible.run?.());
+		});
+		else {
+			const module = await loadSymbol(container, visible.symbol);
+			await withClientContainer(container, async () => {
+				await withCleanupSlot(visible.cleanupSlot, () => module.default(materializeScope(container, visible.scopeId)));
+			});
+		}
+		await flushDirtyComponents(container);
+		scheduleVisibleCallbacksCheck(container);
+	}).finally(() => {
+		if (visible.pending === pending) visible.pending = null;
+	});
+	visible.pending = pending;
+	await pending;
+};
+const flushVisibleCallbacks = async (container) => {
+	if (!container.doc || container.visibles.size === 0) return;
+	for (const visible of [...container.visibles.values()]) {
+		if (visible.done || visible.pending) continue;
+		const component = container.components.get(visible.componentId);
+		if (!component?.start || !component.end) continue;
+		if (!isBoundaryVisible(container.doc, component.start, component.end)) continue;
+		await runVisibleCallback(container, visible);
+	}
+};
+const ensureVisibilityListeners = (container) => {
+	if (container.visibilityListenersCleanup || !container.doc) return;
+	const doc = container.doc;
+	const onVisibilityChange = () => {
+		scheduleVisibleCallbacksCheck(container);
+	};
+	doc.addEventListener("scroll", onVisibilityChange, true);
+	doc.defaultView?.addEventListener("resize", onVisibilityChange);
+	container.visibilityListenersCleanup = () => {
+		doc.removeEventListener("scroll", onVisibilityChange, true);
+		doc.defaultView?.removeEventListener("resize", onVisibilityChange);
+		container.visibilityListenersCleanup = null;
+	};
+};
+const scheduleMountCallbacks = (container, component, callbacks) => {
+	if (component.didMount || callbacks.length === 0) return;
+	component.didMount = true;
+	scheduleMicrotask(() => {
+		withClientContainer(container, () => {
+			for (const callback of callbacks) {
+				const cleanupSlot = createCleanupSlot();
+				component.mountCleanupSlots.push(cleanupSlot);
+				withCleanupSlot(cleanupSlot, callback);
+			}
+		}).then(() => flushDirtyComponents(container)).then(() => {
+			scheduleVisibleCallbacksCheck(container);
+		});
+	});
+};
+const collectProjectionSlotRanges = (roots) => {
+	const starts = /* @__PURE__ */ new Map();
+	const ranges = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		if (typeof Comment !== "undefined" ? node instanceof Comment : node.nodeType === 8) {
+			const commentNode = node;
+			const marker = parseProjectionSlotMarker(commentNode.data);
+			if (marker) if (marker.kind === "start") starts.set(marker.key, commentNode);
+			else {
+				const startNode = starts.get(marker.key);
+				if (startNode) ranges.set(marker.key, {
+					end: commentNode,
+					start: startNode
+				});
+			}
+		}
+		for (const child of Array.from(node.childNodes ?? [])) visit(child);
+	};
+	for (const root of roots) visit(root);
+	return ranges;
+};
+const preserveProjectionSlotContents = (start, end, nodes) => {
+	const currentRanges = collectProjectionSlotRanges(getBoundaryChildren(start, end));
+	const nextRanges = collectProjectionSlotRanges(nodes);
+	for (const [key, nextRange] of nextRanges) {
+		const currentRange = currentRanges.get(key);
+		if (!currentRange) continue;
+		let cursor = currentRange.start.nextSibling;
+		while (cursor && cursor !== currentRange.end) {
+			const nextSibling = cursor.nextSibling;
+			nextRange.end.parentNode?.insertBefore(cursor, nextRange.end);
+			cursor = nextSibling;
+		}
+	}
+};
+const replaceBoundaryContents = (start, end, nodes, options) => {
+	if (options?.preserveProjectionSlots ?? true) preserveProjectionSlotContents(start, end, nodes);
+	let cursor = start.nextSibling;
+	while (cursor && cursor !== end) {
+		const next = cursor.nextSibling;
+		cursor.remove();
+		cursor = next;
+	}
+	for (const node of nodes) end.parentNode?.insertBefore(node, end);
+};
+const getBoundaryChildren = (start, end) => {
+	const nodes = [];
+	let cursor = start.nextSibling;
+	while (cursor && cursor !== end) {
+		nodes.push(cursor);
+		cursor = cursor.nextSibling;
+	}
+	return nodes;
+};
+const getNodePath = (root, target) => {
+	if (root === target) return [];
+	const path = [];
+	let cursor = target;
+	while (cursor && cursor !== root) {
+		const parent = cursor.parentNode;
+		if (!parent) return null;
+		const index = Array.prototype.indexOf.call(parent.childNodes, cursor);
+		if (index < 0) return null;
+		path.unshift(index);
+		cursor = parent;
+	}
+	return cursor === root ? path : null;
+};
+const getNodeByPath = (root, path) => {
+	let cursor = root;
+	for (const index of path) {
+		cursor = cursor?.childNodes.item(index) ?? null;
+		if (!cursor) return null;
+	}
+	return cursor;
+};
+const getElementPath = (root, target) => {
+	if (root === target) return [];
+	const path = [];
+	let cursor = target;
+	while (cursor && cursor !== root) {
+		const parent = cursor.parentElement;
+		if (!parent) return null;
+		const index = Array.prototype.indexOf.call(parent.children, cursor);
+		if (index < 0) return null;
+		path.unshift(index);
+		cursor = parent;
+	}
+	return cursor === root ? path : null;
+};
+const getElementByPath = (root, path) => {
+	let cursor = root;
+	for (const index of path) {
+		cursor = cursor?.children.item(index) ?? null;
+		if (!cursor) return null;
+	}
+	return cursor;
+};
+const captureBoundaryFocus = (doc, start, end) => {
+	const activeElement = doc.activeElement;
+	if (!isHTMLElementNode(activeElement)) return null;
+	const topLevelNodes = getBoundaryChildren(start, end);
+	for (let i = 0; i < topLevelNodes.length; i++) {
+		const candidate = topLevelNodes[i];
+		if (candidate !== activeElement && (!isElementNode(candidate) || !candidate.contains(activeElement))) continue;
+		const innerPath = getNodePath(candidate, activeElement);
+		if (!innerPath) continue;
+		return {
+			path: [i, ...innerPath],
+			selectionDirection: isTextEntryElement(activeElement) ? activeElement.selectionDirection : null,
+			selectionEnd: isTextEntryElement(activeElement) ? activeElement.selectionEnd : null,
+			selectionStart: isTextEntryElement(activeElement) ? activeElement.selectionStart : null
+		};
+	}
+	return null;
+};
+const restoreBoundaryFocus = (doc, start, end, snapshot) => {
+	if (!snapshot) return;
+	const [topLevelIndex, ...innerPath] = snapshot.path;
+	const root = getBoundaryChildren(start, end)[topLevelIndex];
+	if (!root) return;
+	const nextActive = innerPath.length > 0 ? getNodeByPath(root, innerPath) : root;
+	if (!isHTMLElementNode(nextActive)) return;
+	restoreFocusTarget(doc, nextActive, snapshot);
+};
+const restoreFocusTarget = (doc, nextActive, snapshot) => {
+	const restore = () => {
+		if (!nextActive.isConnected) return false;
+		nextActive.focus({ preventScroll: true });
+		if (isTextEntryElement(nextActive) && snapshot.selectionStart !== null && snapshot.selectionStart !== void 0) nextActive.setSelectionRange(snapshot.selectionStart, snapshot.selectionEnd ?? snapshot.selectionStart, snapshot.selectionDirection ?? void 0);
+		return doc.activeElement === nextActive;
+	};
+	if (restore()) return;
+	const win = doc.defaultView;
+	if (!win) return;
+	let remainingAttempts = 3;
+	const retry = () => {
+		if (remainingAttempts <= 0) return;
+		remainingAttempts--;
+		const run = () => {
+			if (restore()) return;
+			retry();
+		};
+		if (typeof win.requestAnimationFrame === "function") {
+			win.requestAnimationFrame(() => run());
+			return;
+		}
+		win.setTimeout(run, 16);
+	};
+	retry();
+};
+const captureDocumentFocus = (doc, focusSource) => {
+	const candidate = isHTMLElementNode(focusSource) ? focusSource : isHTMLElementNode(doc.activeElement) ? doc.activeElement : null;
+	if (!candidate) return null;
+	const path = getElementPath(doc.body, candidate);
+	if (!path) return null;
+	return {
+		path,
+		selectionDirection: isTextEntryElement(candidate) ? candidate.selectionDirection : null,
+		selectionEnd: isTextEntryElement(candidate) ? candidate.selectionEnd : null,
+		selectionStart: isTextEntryElement(candidate) ? candidate.selectionStart : null
+	};
+};
+const capturePendingFocusRestore = (container, focusSource) => {
+	if (!container.doc) return null;
+	const snapshot = captureDocumentFocus(container.doc, focusSource);
+	if (!snapshot) return null;
+	return { snapshot };
+};
+const restorePendingFocus = (container, pending) => {
+	if (!pending || !container.doc) return;
+	const nextActive = getElementByPath(container.doc.body, pending.snapshot.path);
+	if (!isHTMLElementNode(nextActive)) return;
+	restoreFocusTarget(container.doc, nextActive, pending.snapshot);
+};
+const EVENT_PROP_REGEX = /^on([A-Z].+)\$$/;
+const DANGEROUSLY_SET_INNER_HTML_PROP = "dangerouslySetInnerHTML";
+const resolveDangerouslySetInnerHTML = (value) => value === false || value === void 0 || value === null ? null : String(value);
+const toEventName = (propName) => {
+	const matched = propName.match(EVENT_PROP_REGEX);
+	if (!matched) return null;
+	const [first, ...rest] = matched[1];
+	return `${first.toLowerCase()}${rest.join("")}`;
+};
+const TEXT_ESCAPE_REGEX = /[&<>]/;
+const ATTR_ESCAPE_REGEX = /[&<>'"]/;
+const escapeString = (value, mode) => {
+	const escapePattern = mode === "attr" ? ATTR_ESCAPE_REGEX : TEXT_ESCAPE_REGEX;
+	const firstMatch = value.search(escapePattern);
+	if (firstMatch < 0) return value;
+	let output = "";
+	let lastIndex = 0;
+	for (let index = firstMatch; index < value.length; index += 1) {
+		let escaped = null;
+		switch (value.charCodeAt(index)) {
+			case 34:
+				escaped = mode === "attr" ? "&quot;" : null;
+				break;
+			case 38:
+				escaped = "&amp;";
+				break;
+			case 39:
+				escaped = mode === "attr" ? "&#39;" : null;
+				break;
+			case 60:
+				escaped = "&lt;";
+				break;
+			case 62:
+				escaped = "&gt;";
+				break;
+		}
+		if (!escaped) continue;
+		output += value.slice(lastIndex, index);
+		output += escaped;
+		lastIndex = index + 1;
+	}
+	return output + value.slice(lastIndex);
+};
+const escapeText = (value) => escapeString(value, "text");
+const escapeAttr = (value) => escapeString(value, "attr");
+const renderSSRAttr = (name, value) => {
+	if (value === false || value === void 0 || value === null) return "";
+	if (value === true) return ` ${name}`;
+	return ` ${name}="${escapeAttr(String(value))}"`;
+};
+const renderStringArray = (values) => {
+	let output = "";
+	for (let index = 0; index < values.length; index += 1) output += renderStringNode(values[index]);
+	return output;
+};
+const renderSSRTemplateValue = (value) => {
+	if (value === false || value === null || value === void 0) return "";
+	if (Array.isArray(value)) return renderStringArray(value);
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return escapeText(String(value));
+	if (isSSRTemplate(value)) return renderSSRTemplateNode(value);
+	if (isProjectionSlot(value)) return renderProjectionSlotToString(value);
+	if (isRouteSlot(value)) {
+		const routeElement = resolveRouteSlot(getCurrentContainer(), value);
+		return routeElement ? renderStringNode(routeElement) : "";
+	}
+	return renderStringNode(value);
+};
+const renderSSRTemplateNode = (template) => {
+	let output = template.strings[0] ?? "";
+	for (let index = 0; index < template.values.length; index += 1) {
+		const value = template.values[index];
+		output += isSSRAttrValue(value) ? renderSSRAttr(value.name, value.value) : renderSSRTemplateValue(value);
+		output += template.strings[index + 1] ?? "";
+	}
+	return output;
+};
+const resolveRenderable = (value) => {
+	let current = value;
+	while (typeof current === "function" && !getLazyMeta(current) && !getComponentMeta(current)) current = current();
+	return current;
+};
+const nextComponentPosition = (container) => {
+	const frame = getCurrentFrame();
+	if (!frame) return {
+		childIndex: container.rootChildCursor++,
+		parentId: ROOT_COMPONENT_ID
+	};
+	return {
+		childIndex: frame.childCursor++,
+		parentId: frame.component.id
+	};
+};
+const registerEventBinding = (container, descriptor) => {
+	const scopeId = registerScope(container, descriptor.captures());
+	return `${descriptor.symbol}:${scopeId}`;
+};
+const bindRuntimeEvent = (element, eventName, value) => {
+	const descriptor = getEventMeta(value);
+	if (!descriptor) return false;
+	const container = getCurrentContainer();
+	if (!container) return false;
+	element.setAttribute("data-eid", `e${container.nextElementId++}`);
+	element.setAttribute(`data-e-on${eventName}`, registerEventBinding(container, descriptor));
+	return true;
+};
+const renderProjectionSlotToString = (slot) => {
+	const frame = getCurrentFrame();
+	const start = createProjectionSlotMarker(slot.componentId, slot.name, slot.occurrence, "start");
+	const end = createProjectionSlotMarker(slot.componentId, slot.name, slot.occurrence, "end");
+	if (frame?.component.id === slot.componentId && frame.projectionState.reuseExistingDom) return `<!--${start}--><!--${end}-->`;
+	return `<!--${start}-->${renderStringNode(slot.source)}<!--${end}-->`;
+};
+const renderProjectionSlotToNodes = (slot, container) => {
+	if (!container.doc) throw new Error("Client rendering requires a document.");
+	const frame = getCurrentFrame();
+	const start = container.doc.createComment(createProjectionSlotMarker(slot.componentId, slot.name, slot.occurrence, "start"));
+	const end = container.doc.createComment(createProjectionSlotMarker(slot.componentId, slot.name, slot.occurrence, "end"));
+	if (frame?.component.id === slot.componentId && frame.projectionState.reuseExistingDom) return [start, end];
+	return [
+		start,
+		...renderClientInsertable(slot.source, container),
+		end
+	];
+};
+const renderStringNode = (inputElementLike) => {
+	if (Array.isArray(inputElementLike)) return renderStringArray(inputElementLike);
+	const resolved = resolveRenderable(inputElementLike);
+	if (resolved === false || resolved === null || resolved === void 0) return "";
+	if (Array.isArray(resolved)) return renderStringNode(resolved);
+	if (typeof resolved === "string" || typeof resolved === "number" || typeof resolved === "boolean") return escapeText(String(resolved));
+	if (isSSRTemplate(resolved)) return renderSSRTemplateNode(resolved);
+	if (isProjectionSlot(resolved)) return renderProjectionSlotToString(resolved);
+	if (isRouteSlot(resolved)) {
+		const routeElement = resolveRouteSlot(getCurrentContainer(), resolved);
+		return routeElement ? renderStringNode(routeElement) : "";
+	}
+	if (!isRenderObject(resolved)) return "";
+	if (isSuspenseType(resolved.type)) return renderSuspenseComponentToString(resolved.props);
+	if (typeof resolved.type === "function") {
+		const container = getCurrentContainer();
+		const componentFn = resolved.type;
+		const meta = getComponentMeta(componentFn);
+		if (!meta || !container) return renderStringNode(componentFn(resolved.props));
+		const evaluatedProps = evaluateProps(resolved.props);
+		const position = nextComponentPosition(container);
+		const componentId = createComponentId(container, position.parentId, position.childIndex);
+		const component = getOrCreateComponentState(container, componentId, meta.symbol, position.parentId);
+		component.scopeId = registerScope(container, meta.captures());
+		component.props = evaluatedProps;
+		component.projectionSlots = meta.projectionSlots ?? null;
+		const frame = createFrame(container, component, "ssr");
+		clearComponentSubscriptions(container, component.id);
+		const renderProps = createRenderProps(componentId, meta, evaluatedProps);
+		const body = pushFrame(frame, () => renderStringNode(componentFn(renderProps)));
+		pruneComponentVisibles(container, component, frame.visibleCursor);
+		pruneComponentWatches(container, component, frame.watchCursor);
+		return `<!--ec:c:${componentId}:start-->${body}<!--ec:c:${componentId}:end-->`;
+	}
+	const attrParts = [];
+	const container = getCurrentContainer();
+	let hasInnerHTML = false;
+	let innerHTML = null;
+	for (const name in resolved.props) {
+		if (!Object.hasOwn(resolved.props, name)) continue;
+		if (name === "children") continue;
+		const eventName = toEventName(name);
+		const value = resolved.props[name];
+		if (eventName) {
+			const eventMeta = getEventMeta(value);
+			if (!eventMeta || !container) continue;
+			attrParts.push(`data-eid="e${container.nextElementId++}"`);
+			attrParts.push(`data-e-on${eventName}="${escapeAttr(registerEventBinding(container, eventMeta))}"`);
+			continue;
+		}
+		if (name === "ref") {
+			const signalId = getRefSignalId(value);
+			if (signalId) attrParts.push(`${REF_SIGNAL_ATTR}="${escapeAttr(signalId)}"`);
+			continue;
+		}
+		if (name === DANGEROUSLY_SET_INNER_HTML_PROP) {
+			hasInnerHTML = true;
+			innerHTML = resolveDangerouslySetInnerHTML(value);
+			continue;
+		}
+		if (value === false || value === void 0 || value === null) continue;
+		if (resolved.type === "body" && name === "data-e-resume") continue;
+		if (value === true) {
+			attrParts.push(name);
+			continue;
+		}
+		attrParts.push(`${name}="${escapeAttr(String(value))}"`);
+	}
+	if (resolved.type === "body" && container) attrParts.push("data-e-resume=\"paused\"");
+	let childrenText = innerHTML ?? "";
+	if (!hasInnerHTML) {
+		const children = resolved.props.children;
+		if (Array.isArray(children)) for (const child of children) childrenText += renderStringNode(child);
+		else childrenText += renderStringNode(children);
+	}
+	if (resolved.type === "__ECLIPSA_FRAGMENT") return childrenText;
+	return `<${resolved.type}${attrParts.length > 0 ? ` ${attrParts.join(" ")}` : ""}>${childrenText}</${resolved.type}>`;
+};
+const createElementNode = (doc, tagName) => doc.createElement(tagName);
+const renderComponentToNodes = (componentFn, props, container, mode) => {
+	if (!container.doc) throw new Error("Client rendering requires a document.");
+	const meta = getComponentMeta(componentFn);
+	if (!meta) return renderClientNodes(componentFn(props), container);
+	const position = nextComponentPosition(container);
+	const componentId = createComponentId(container, position.parentId, position.childIndex);
+	const existing = container.components.get(componentId);
+	const symbolChanged = !!existing && existing.symbol !== meta.symbol;
+	const component = getOrCreateComponentState(container, componentId, meta.symbol, position.parentId);
+	component.active = mode === "client";
+	if (!existing || symbolChanged) resetComponentForSymbolChange(container, component, meta);
+	component.props = props;
+	component.projectionSlots = meta.projectionSlots ?? null;
+	const frame = createFrame(container, component, mode);
+	clearComponentSubscriptions(container, componentId);
+	const oldDescendants = collectDescendantIds(container, componentId);
+	const start = container.doc.createComment(`ec:c:${componentId}:start`);
+	const end = container.doc.createComment(`ec:c:${componentId}:end`);
+	component.start = start;
+	component.end = end;
+	const renderProps = createRenderProps(componentId, meta, props);
+	const rendered = pushFrame(frame, () => toMountedNodes(componentFn(renderProps), container));
+	pruneComponentVisibles(container, component, frame.visibleCursor);
+	pruneComponentWatches(container, component, frame.watchCursor);
+	pruneRemovedComponents(container, componentId, frame.visitedDescendants);
+	for (const descendantId of oldDescendants) {
+		if (frame.visitedDescendants.has(descendantId)) continue;
+		clearComponentSubscriptions(container, descendantId);
+	}
+	const currentFrame = getCurrentFrame();
+	if (currentFrame) {
+		currentFrame.visitedDescendants.add(componentId);
+		for (const descendantId of frame.visitedDescendants) currentFrame.visitedDescendants.add(descendantId);
+	}
+	scheduleMountCallbacks(container, component, frame.mountCallbacks);
+	scheduleVisibleCallbacksCheck(container);
+	return [
+		start,
+		...rendered,
+		end
+	];
+};
+const applyElementProp = (element, name, value, container) => {
+	const eventName = toEventName(name);
+	if (eventName) {
+		const eventMeta = getEventMeta(value);
+		if (!eventMeta) return;
+		element.setAttribute("data-eid", `e${container.nextElementId++}`);
+		element.setAttribute(`data-e-on${eventName}`, registerEventBinding(container, eventMeta));
+		return;
+	}
+	if (name === "ref") {
+		assignRuntimeRef(value, element, container);
+		return;
+	}
+	if (name === DANGEROUSLY_SET_INNER_HTML_PROP) {
+		const html = resolveDangerouslySetInnerHTML(value);
+		if (html !== null) element.innerHTML = html;
+		return;
+	}
+	if (value === false || value === void 0 || value === null) return;
+	if (name === "class") {
+		element.className = String(value);
+		return;
+	}
+	if (name === "style" && isPlainObject(value)) {
+		element.setAttribute("style", Object.entries(value).map(([styleName, styleValue]) => `${styleName}: ${styleValue}`).join("; "));
+		return;
+	}
+	if (name === "value" && "value" in element) element.value = String(value);
+	if (name === "checked" && isHTMLInputElementNode(element)) element.checked = Boolean(value);
+	if (value === true) {
+		element.setAttribute(name, "");
+		return;
+	}
+	element.setAttribute(name, String(value));
+};
+const renderClientNodes = (inputElementLike, container) => {
+	if (!container.doc) throw new Error("Client rendering requires a document.");
+	if (Array.isArray(inputElementLike)) return inputElementLike.flatMap((entry) => renderClientNodes(entry, container));
+	const resolved = resolveRenderable(inputElementLike);
+	if (resolved === false || resolved === null || resolved === void 0) return [];
+	if (Array.isArray(resolved)) return renderClientNodes(resolved, container);
+	if (typeof resolved === "string" || typeof resolved === "number" || typeof resolved === "boolean") return [container.doc.createTextNode(String(resolved))];
+	if (typeof Node !== "undefined" && resolved instanceof Node) return [resolved];
+	if (isProjectionSlot(resolved)) return renderProjectionSlotToNodes(resolved, container);
+	if (isRouteSlot(resolved)) {
+		const routeElement = resolveRouteSlot(container, resolved);
+		return routeElement ? renderClientNodes(routeElement, container) : [];
+	}
+	if (!isRenderObject(resolved)) return [];
+	if (isSuspenseType(resolved.type)) return renderSuspenseComponentToNodes(resolved.props, container, "client");
+	if (typeof resolved.type === "function") {
+		const evaluatedProps = evaluateProps(resolved.props);
+		const componentFn = resolved.type;
+		if (getComponentMeta(resolved.type)) return withoutTrackedEffect(() => renderComponentToNodes(componentFn, evaluatedProps, container, "client"));
+		return renderComponentToNodes(componentFn, evaluatedProps, container, "client");
+	}
+	if (resolved.type === "__ECLIPSA_FRAGMENT") {
+		const children = resolved.props.children;
+		return Array.isArray(children) ? children.flatMap((child) => renderClientNodes(child, container)) : renderClientNodes(children, container);
+	}
+	const element = createElementNode(container.doc, resolved.type);
+	let hasInnerHTML = false;
+	for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(resolved.props))) {
+		if (name === "children") continue;
+		const value = descriptor.get ? descriptor.get.call(resolved.props) : descriptor.value;
+		if (resolved.type === "body" && name === "data-e-resume") continue;
+		if (name === DANGEROUSLY_SET_INNER_HTML_PROP) hasInnerHTML = true;
+		applyElementProp(element, name, value, container);
+	}
+	if (hasInnerHTML) return [element];
+	const children = resolved.props.children;
+	const childNodes = Array.isArray(children) ? children.flatMap((child) => renderClientNodes(child, container)) : renderClientNodes(children, container);
+	for (const child of childNodes) element.appendChild(child);
+	return [element];
+};
+const scanComponentBoundaries = (root) => {
+	const walker = root.ownerDocument.createTreeWalker(root, NodeFilter.SHOW_COMMENT);
+	const boundaries = /* @__PURE__ */ new Map();
+	while (walker.nextNode()) {
+		const node = walker.currentNode;
+		if (!(node instanceof Comment)) continue;
+		const matched = node.data.match(/^ec:c:(.+):(start|end)$/);
+		if (!matched) continue;
+		const [, id, edge] = matched;
+		const boundary = boundaries.get(id) ?? {};
+		if (edge === "start") boundary.start = node;
+		else boundary.end = node;
+		boundaries.set(id, boundary);
+	}
+	return boundaries;
+};
+const loadSymbol = async (container, symbolId) => {
+	const resolved = getResolvedRuntimeSymbols(container).get(symbolId);
+	if (resolved) return resolved;
+	const existing = container.imports.get(symbolId);
+	if (existing) {
+		const module = await existing;
+		getResolvedRuntimeSymbols(container).set(symbolId, module);
+		return module;
+	}
+	const url = container.symbols.get(symbolId);
+	if (!url) throw new Error(`Missing symbol URL for ${symbolId}.`);
+	const loaded = import(
+		/* @vite-ignore */
+		url
+).then((module) => {
+		getResolvedRuntimeSymbols(container).set(symbolId, module);
+		return module;
+	});
+	container.imports.set(symbolId, loaded);
+	return loaded;
+};
+const toMountedNodes = (value, container) => {
+	if (!container.doc) throw new Error("Client rendering requires a document.");
+	let resolved = value;
+	while (typeof resolved === "function") resolved = resolved();
+	if (Array.isArray(resolved)) return resolved.flatMap((entry) => toMountedNodes(entry, container));
+	if (resolved === null || resolved === void 0 || resolved === false) return [container.doc.createComment("eclipsa-empty")];
+	if (resolved instanceof Node) return [resolved];
+	if (typeof resolved === "string" || typeof resolved === "number" || typeof resolved === "boolean") return [container.doc.createTextNode(String(resolved))];
+	return renderClientNodes(resolved, container);
+};
+const getRuntimeContainer = () => getCurrentContainer();
+const renderClientInsertable = (value, container = getCurrentContainer()) => {
+	const doc = container?.doc ?? (typeof document !== "undefined" ? document : null);
+	if (!doc) return [];
+	if (Array.isArray(value)) return value.flatMap((entry) => renderClientInsertable(entry, container));
+	let resolved = value;
+	while (typeof resolved === "function") resolved = resolved();
+	if (resolved === null || resolved === void 0 || resolved === false) return [doc.createComment("eclipsa-empty")];
+	if (resolved instanceof Node) return [resolved];
+	if (typeof resolved === "string" || typeof resolved === "number" || typeof resolved === "boolean") return [doc.createTextNode(String(resolved))];
+	if (isProjectionSlot(resolved)) return container ? renderProjectionSlotToNodes(resolved, container) : renderClientInsertable(resolved.source, container);
+	if (isRouteSlot(resolved)) {
+		const routeElement = resolveRouteSlot(container, resolved);
+		return routeElement ? renderClientInsertable(routeElement, container) : [doc.createComment("eclipsa-empty")];
+	}
+	if (container) return renderClientNodes(resolved, container);
+	return [doc.createTextNode(String(resolved))];
+};
+const resetContainerForRouteRender = (container) => {
+	for (const component of container.components.values()) {
+		disposeComponentMountCleanups(component);
+		pruneComponentVisibles(container, component, 0);
+		pruneComponentWatches(container, component, 0);
+	}
+	for (const watch of container.watches.values()) clearEffectSignals(watch.effect);
+	container.components.clear();
+	container.dirty.clear();
+	container.nextElementId = 0;
+	container.nextScopeId = 0;
+	container.nextSignalId = 0;
+	container.rootChildCursor = 0;
+	container.scopes.clear();
+	container.visibles.clear();
+	container.watches.clear();
+	for (const [id, record] of [...container.signals.entries()]) {
+		for (const effect of [...record.effects]) clearEffectSignals(effect);
+		record.effects.clear();
+		record.subscribers.clear();
+		if (!isRouterSignalId(id)) container.signals.delete(id);
+	}
+};
+const resolveRouteComponentSymbol = (Page, fallback) => getComponentMeta(Page)?.symbol ?? fallback;
+const isRouteSlot = (value) => isPlainObject(value) && value.__eclipsa_type === ROUTE_SLOT_TYPE;
+const createRouteSlot = (route, startLayoutIndex) => {
+	const slot = {
+		__eclipsa_type: ROUTE_SLOT_TYPE,
+		pathname: route.pathname,
+		startLayoutIndex
+	};
+	Object.defineProperty(slot, ROUTE_SLOT_ROUTE_KEY, {
+		configurable: true,
+		enumerable: false,
+		value: route,
+		writable: true
+	});
+	return slot;
+};
+const resolveRouteSlot = (container, slot) => {
+	const route = slot[ROUTE_SLOT_ROUTE_KEY] ?? container?.router?.loadedRoutes.get(routeCacheKey(slot.pathname, "page"));
+	if (!route) return null;
+	return createRouteElement(route, slot.startLayoutIndex);
+};
+const createRouteElement = (route, startLayoutIndex = 0) => {
+	const createRouteProps = (props) => {
+		const nextProps = { ...props };
+		Object.defineProperty(nextProps, ROUTE_PARAMS_PROP, {
+			configurable: true,
+			enumerable: false,
+			value: route.params,
+			writable: true
+		});
+		return nextProps;
+	};
+	if (startLayoutIndex >= route.layouts.length) return jsxDEV(route.page.renderer, createRouteProps({}), null, false, {});
+	let children = null;
+	for (let index = route.layouts.length - 1; index >= startLayoutIndex; index -= 1) {
+		const layout = route.layouts[index];
+		children = jsxDEV(layout.renderer, createRouteProps({ children: createRouteSlot(route, index + 1) }), null, false, {});
+	}
+	return children;
+};
+const trackSuspenseBoundaryPromise = (container, componentId, promise) => {
+	const component = container.components.get(componentId);
+	if (!component) return;
+	component.suspensePromise = promise;
+	promise.finally(() => {
+		const current = container.components.get(componentId);
+		if (!current || current.suspensePromise !== promise) return;
+		current.suspensePromise = null;
+		current.active = false;
+		container.dirty.add(componentId);
+		flushDirtyComponents(container);
+	});
+};
+const renderSuspenseContentToString = (props, container, componentId) => {
+	try {
+		return renderStringNode(typeof props.children === "function" ? props.children() : props.children ?? null);
+	} catch (error) {
+		if (!isPendingSignalError(error)) throw error;
+		container.pendingSuspensePromises.add(error.promise);
+		const component = container.components.get(componentId);
+		if (component) component.suspensePromise = error.promise;
+		return renderStringNode(props.fallback ?? null);
+	}
+};
+const collectPendingSuspenseBoundaryIds = (container) => [...container.components.values()].filter((component) => component.symbol === SUSPENSE_COMPONENT_SYMBOL && !!component.suspensePromise).map((component) => component.id).sort((left, right) => left.split(".").length - right.split(".").length);
+const renderSuspenseContentToNodes = (props, container, componentId) => {
+	try {
+		return toMountedNodes(typeof props.children === "function" ? props.children() : props.children ?? null, container);
+	} catch (error) {
+		if (!isPendingSignalError(error)) throw error;
+		trackSuspenseBoundaryPromise(container, componentId, error.promise);
+		return toMountedNodes(props.fallback ?? null, container);
+	}
+};
+const renderSuspenseComponentToString = (props) => {
+	const container = getCurrentContainer();
+	if (!container) return renderStringNode(props.children ?? null);
+	if (!getCurrentFrame()) return renderSuspenseContentToString(props, container, ROOT_COMPONENT_ID);
+	const position = nextComponentPosition(container);
+	const componentId = createComponentId(container, position.parentId, position.childIndex);
+	const component = getOrCreateComponentState(container, componentId, SUSPENSE_COMPONENT_SYMBOL, position.parentId);
+	component.props = {
+		children: props.children,
+		fallback: props.fallback
+	};
+	component.projectionSlots = null;
+	const frame = createFrame(container, component, "ssr");
+	clearComponentSubscriptions(container, component.id);
+	const body = pushFrame(frame, () => renderSuspenseContentToString(component.props, container, componentId));
+	pruneComponentVisibles(container, component, frame.visibleCursor);
+	pruneComponentWatches(container, component, frame.watchCursor);
+	return `<!--ec:c:${componentId}:start-->${body}<!--ec:c:${componentId}:end-->`;
+};
+const renderSuspenseComponentToNodes = (props, container, mode) => {
+	const parentFrame = getCurrentFrame();
+	if (!parentFrame) return renderSuspenseContentToNodes(props, container, ROOT_COMPONENT_ID);
+	const position = nextComponentPosition(container);
+	const componentId = createComponentId(container, position.parentId, position.childIndex);
+	const component = getOrCreateComponentState(container, componentId, SUSPENSE_COMPONENT_SYMBOL, position.parentId);
+	component.props = {
+		children: props.children,
+		fallback: props.fallback
+	};
+	component.projectionSlots = null;
+	component.active = true;
+	component.start = void 0;
+	component.end = void 0;
+	const frame = createFrame(container, component, mode);
+	clearComponentSubscriptions(container, component.id);
+	const bodyNodes = pushFrame(frame, () => renderSuspenseContentToNodes(component.props, container, componentId));
+	pruneComponentVisibles(container, component, frame.visibleCursor);
+	pruneComponentWatches(container, component, frame.watchCursor);
+	parentFrame.visitedDescendants.add(componentId);
+	scheduleMountCallbacks(container, component, frame.mountCallbacks);
+	scheduleVisibleCallbacksCheck(container);
+	if (!container.doc) return bodyNodes;
+	const start = container.doc.createComment(`ec:c:${componentId}:start`);
+	const end = container.doc.createComment(`ec:c:${componentId}:end`);
+	component.start = start;
+	component.end = end;
+	return [
+		start,
+		...bodyNodes,
+		end
+	];
+};
+const renderRouteIntoRoot = (container, Page, routeKey) => {
+	if (!container.doc || !container.rootElement) throw new Error("Client route rendering requires a document root.");
+	resetContainerForRouteRender(container);
+	const rootComponent = getOrCreateComponentState(container, "c0", resolveRouteComponentSymbol(Page, routeKey), ROOT_COMPONENT_ID);
+	rootComponent.active = true;
+	rootComponent.didMount = false;
+	rootComponent.end = void 0;
+	rootComponent.mountCleanupSlots = [];
+	rootComponent.props = {};
+	rootComponent.scopeId = registerScope(container, getComponentMeta(Page)?.captures() ?? []);
+	rootComponent.signalIds = [];
+	rootComponent.start = void 0;
+	rootComponent.watchCount = 0;
+	rootComponent.visibleCount = 0;
+	clearComponentSubscriptions(container, rootComponent.id);
+	const frame = createFrame(container, rootComponent, "client");
+	const nodes = pushContainer(container, () => pushFrame(frame, () => {
+		return toMountedNodes(Page({}), container);
+	}));
+	pruneComponentVisibles(container, rootComponent, frame.visibleCursor);
+	pruneComponentWatches(container, rootComponent, frame.watchCursor);
+	scheduleMountCallbacks(container, rootComponent, frame.mountCallbacks);
+	const root = container.rootElement;
+	while (root.firstChild) root.firstChild.remove();
+	const start = container.doc.createComment("ec:c:c0:start");
+	const end = container.doc.createComment("ec:c:c0:end");
+	root.appendChild(start);
+	for (const node of nodes) root.appendChild(node);
+	root.appendChild(end);
+	rootComponent.start = start;
+	rootComponent.end = end;
+	bindRouterLinks(container, root);
+	scheduleVisibleCallbacksCheck(container);
+};
+const loadRouteModule = async (url) => {
+	const module = await import(
+		/* @vite-ignore */
+		url
+);
+	if (typeof module.default !== "function") throw new TypeError(`Route module ${url} does not export a default component.`);
+	return {
+		metadata: module.metadata ?? null,
+		renderer: module.default,
+		symbol: getComponentMeta(module.default)?.symbol ?? null,
+		url
+	};
+};
+const createManagedHeadElement = (doc, tagName) => {
+	const element = doc.createElement(tagName);
+	element.setAttribute(ROUTE_METADATA_HEAD_ATTR, "");
+	return element;
+};
+const applyRouteMetadata = (doc, route, url, defaultTitle) => {
+	for (const element of [...doc.head.querySelectorAll(`[${ROUTE_METADATA_HEAD_ATTR}]`)]) element.remove();
+	const metadata = composeRouteMetadata([...route.layouts.map((layout) => layout.metadata ?? null), route.page.metadata ?? null], {
+		params: route.params,
+		url
+	});
+	doc.title = metadata?.title ?? defaultTitle;
+	const appendMeta = (name, content, attr) => {
+		const meta = createManagedHeadElement(doc, "meta");
+		meta.setAttribute(attr, name);
+		meta.setAttribute("content", content);
+		doc.head.appendChild(meta);
+	};
+	if (metadata?.description) appendMeta("description", metadata.description, "name");
+	if (metadata?.canonical) {
+		const link = createManagedHeadElement(doc, "link");
+		link.setAttribute("href", metadata.canonical);
+		link.setAttribute("rel", "canonical");
+		doc.head.appendChild(link);
+	}
+	if (metadata?.openGraph?.title) appendMeta("og:title", metadata.openGraph.title, "property");
+	if (metadata?.openGraph?.description) appendMeta("og:description", metadata.openGraph.description, "property");
+	if (metadata?.openGraph?.type) appendMeta("og:type", metadata.openGraph.type, "property");
+	if (metadata?.openGraph?.url) appendMeta("og:url", metadata.openGraph.url, "property");
+	for (const image of metadata?.openGraph?.images ?? []) appendMeta("og:image", image, "property");
+	if (metadata?.twitter?.card) appendMeta("twitter:card", metadata.twitter.card, "name");
+	if (metadata?.twitter?.title) appendMeta("twitter:title", metadata.twitter.title, "name");
+	if (metadata?.twitter?.description) appendMeta("twitter:description", metadata.twitter.description, "name");
+	for (const image of metadata?.twitter?.images ?? []) appendMeta("twitter:image", image, "name");
+};
+const loadResolvedRoute = async (container, matched, variant = "page") => {
+	const router = ensureRouterState(container);
+	const normalizedPath = normalizeRoutePath(matched.pathname);
+	const cacheKey = routeCacheKey(normalizedPath, variant);
+	const existing = router.loadedRoutes.get(cacheKey);
+	if (existing) return existing;
+	const moduleUrl = variant === "page" ? matched.entry.page : variant === "loading" ? matched.entry.loading : variant === "error" ? matched.entry.error : matched.entry.notFound;
+	if (!moduleUrl) return null;
+	const [page, ...layouts] = await Promise.all([loadRouteModule(moduleUrl), ...matched.entry.layouts.map((layoutUrl) => loadRouteModule(layoutUrl))]);
+	let route;
+	route = {
+		entry: matched.entry,
+		layouts,
+		params: matched.params,
+		pathname: normalizedPath,
+		page,
+		render: () => createRouteElement(route)
+	};
+	router.loadedRoutes.set(cacheKey, route);
+	return route;
+};
+const loadResolvedRouteFromSpecial = async (container, pathname, kind) => {
+	const matched = findSpecialManifestEntry(ensureRouterState(container).manifest, pathname, kind);
+	if (!matched) return null;
+	return loadResolvedRoute(container, matched, kind === "error" ? "error" : "not-found");
+};
+const loadRouteComponent = async (container, pathname) => {
+	const matched = matchRouteManifest(ensureRouterState(container).manifest, pathname);
+	if (!matched || !matched.entry.page) return null;
+	return loadResolvedRoute(container, matched, "page");
+};
+const findRouteComponentChain = (container, symbols, parentId = null) => {
+	if (symbols.length === 0) return [];
+	const [symbol, ...rest] = symbols;
+	const candidates = [...container.components.values()].filter((component) => {
+		if (!component.active || component.symbol !== symbol) return false;
+		if (parentId === null) return true;
+		return isDescendantOf(parentId, component.id);
+	}).sort((left, right) => left.id.split(".").length - right.id.split(".").length);
+	for (const candidate of candidates) {
+		const remainder = findRouteComponentChain(container, rest, candidate.id);
+		if (!remainder) continue;
+		return [candidate.id, ...remainder];
+	}
+	return null;
+};
+const collectSharedLayoutBoundaryIds = (container, route) => {
+	if (route.layouts.length === 0 || route.layouts.some((layout) => !layout.symbol)) return null;
+	const symbols = route.layouts.map((layout) => layout.symbol);
+	if (route.page.symbol) {
+		const chain = findRouteComponentChain(container, [...symbols, route.page.symbol]);
+		if (chain) return chain.slice(0, route.layouts.length);
+	}
+	return findRouteComponentChain(container, symbols);
+};
+const countSharedLayouts = (current, next) => {
+	if (!current) return 0;
+	let count = 0;
+	const limit = Math.min(current.layouts.length, next.layouts.length);
+	while (count < limit && current.layouts[count].url === next.layouts[count].url) count += 1;
+	return count;
+};
+const updateSharedLayoutBoundary = async (container, current, next, sharedLayoutCount) => {
+	if (sharedLayoutCount <= 0) return false;
+	const boundaryIds = collectSharedLayoutBoundaryIds(container, current);
+	if (!boundaryIds || boundaryIds.length < sharedLayoutCount) return false;
+	const boundaryId = boundaryIds[sharedLayoutCount - 1];
+	const boundary = container.components.get(boundaryId);
+	if (!boundary) return false;
+	boundary.props = { children: createRouteElement(next, sharedLayoutCount) };
+	boundary.active = false;
+	boundary.reuseExistingDomOnActivate = false;
+	container.dirty.add(boundaryId);
+	await flushDirtyComponents(container);
+	return true;
+};
+const commitBrowserNavigation = (doc, url, mode) => {
+	if (!doc.defaultView || mode === "pop") return;
+	if (mode === "replace") {
+		doc.defaultView.history.replaceState(null, "", url.href);
+		return;
+	}
+	doc.defaultView.history.pushState(null, "", url.href);
+};
+const fallbackDocumentNavigation = (doc, url, mode) => {
+	if (!doc.defaultView) return;
+	if (mode === "replace") {
+		doc.defaultView.location.replace(url.href);
+		return;
+	}
+	if (mode === "pop") {
+		doc.defaultView.location.assign(url.href);
+		return;
+	}
+	doc.defaultView.location.assign(url.href);
+};
+const parseResumePayloadFromHtml = (html) => {
+	if (typeof DOMParser === "undefined") return null;
+	const parsed = new DOMParser().parseFromString(html, "text/html");
+	const payloadNode = parsed.getElementById("eclipsa-resume-final") ?? parsed.getElementById("eclipsa-resume");
+	if (!payloadNode?.textContent) return null;
+	return JSON.parse(payloadNode.textContent);
+};
+const cachePrefetchedLoaders = (container, url, payload) => {
+	if (!payload) return;
+	const router = ensureRouterState(container);
+	const snapshots = /* @__PURE__ */ new Map();
+	for (const [id, loaderPayload] of Object.entries(payload.loaders ?? {})) snapshots.set(id, {
+		data: deserializeRuntimeValue(container, loaderPayload.data),
+		error: deserializeRuntimeValue(container, loaderPayload.error),
+		loaded: loaderPayload.loaded
+	});
+	router.prefetchedLoaders.set(routePrefetchKey(url), snapshots);
+};
+const applyPrefetchedLoaders = (container, url) => {
+	const prefetchedLoaders = ensureRouterState(container).prefetchedLoaders.get(routePrefetchKey(url));
+	if (!prefetchedLoaders) return;
+	for (const [id, snapshot] of prefetchedLoaders) container.loaderStates.set(id, {
+		data: snapshot.data,
+		error: snapshot.error,
+		loaded: snapshot.loaded
+	});
+};
+const requestRoutePreflight = async (href) => {
+	try {
+		const requestUrl = new URL(href, typeof window === "undefined" ? "http://localhost" : window.location.href);
+		const response = await fetch(requestUrl.href, { headers: { [ROUTE_PREFLIGHT_REQUEST_HEADER]: "1" } });
+		if (response.status < 200 || response.status >= 300) return {
+			document: true,
+			ok: false
+		};
+		const finalUrl = new URL(response.url || requestUrl.href, requestUrl.href);
+		if (finalUrl.origin !== requestUrl.origin || finalUrl.pathname !== requestUrl.pathname || finalUrl.search !== requestUrl.search) return {
+			location: finalUrl.href,
+			ok: false
+		};
+		return { ok: true };
+	} catch {
+		return {
+			document: true,
+			ok: false
+		};
+	}
+};
+const prefetchResolvedRouteModules = async (container, pathname, finalUrl) => {
+	const router = ensureRouterState(container);
+	const matched = matchRouteManifest(router.manifest, pathname);
+	if (matched?.entry.page) {
+		await loadResolvedRoute(container, matched);
+		return;
+	}
+	const notFoundMatched = findSpecialManifestEntry(router.manifest, pathname, "notFound");
+	if (notFoundMatched?.entry.notFound) await loadResolvedRoute(container, notFoundMatched, "not-found");
+	if (finalUrl.pathname !== pathname) {
+		const redirectedPath = normalizeRoutePath(finalUrl.pathname);
+		const redirectedMatched = matchRouteManifest(router.manifest, redirectedPath);
+		if (redirectedMatched?.entry.page) await loadResolvedRoute(container, redirectedMatched);
+	}
+};
+const prefetchRoute = async (container, href) => {
+	const doc = container.doc;
+	if (!doc) return;
+	const requestUrl = new URL(href, doc.location.href);
+	if (requestUrl.origin !== doc.location.origin) return;
+	const key = routePrefetchKey(requestUrl);
+	const router = ensureRouterState(container);
+	const existing = router.routePrefetches.get(key);
+	if (existing) {
+		await existing;
+		return;
+	}
+	const pathname = normalizeRoutePath(requestUrl.pathname);
+	const matched = matchRouteManifest(router.manifest, pathname);
+	const specialRoute = !matched ? findSpecialManifestEntry(router.manifest, pathname, "notFound") : null;
+	if (!matched?.entry.page && !specialRoute?.entry.notFound) return;
+	const prefetchPromise = (async () => {
+		try {
+			const response = await fetch(requestUrl.href);
+			if (response.status < 200 || response.status >= 300) return;
+			const finalUrl = new URL(response.url || requestUrl.href, requestUrl.href);
+			if (finalUrl.origin !== requestUrl.origin) return;
+			const html = (response.headers.get("content-type") ?? "").includes("text/html") ? await response.text() : "";
+			await prefetchResolvedRouteModules(container, normalizeRoutePath(finalUrl.pathname), finalUrl);
+			cachePrefetchedLoaders(container, new URL(`${finalUrl.pathname}${finalUrl.search}`, requestUrl.origin), html ? parseResumePayloadFromHtml(html) : null);
+		} catch {
+			return;
+		}
+	})();
+	router.routePrefetches.set(key, prefetchPromise);
+	await prefetchPromise;
+};
+const navigateContainer = async (container, href, options) => {
+	const doc = container.doc;
+	if (!doc) return;
+	const mode = options?.mode ?? "push";
+	const redirectDepth = options?.redirectDepth ?? 0;
+	const url = new URL(href, doc.location.href);
+	if (url.origin !== doc.location.origin) {
+		fallbackDocumentNavigation(doc, url, mode);
+		return;
+	}
+	const pathname = normalizeRoutePath(url.pathname);
+	const router = ensureRouterState(container);
+	const matched = matchRouteManifest(router.manifest, pathname);
+	const specialPreflightTarget = !matched ? findSpecialManifestEntry(router.manifest, pathname, "notFound") : null;
+	const currentHref = `${doc.location.pathname}${doc.location.search}${doc.location.hash}`;
+	const nextHref = `${url.pathname}${url.search}${url.hash}`;
+	if (nextHref === currentHref) return;
+	if (matched?.entry.page && matched.entry.hasMiddleware || !!specialPreflightTarget?.entry.notFound && specialPreflightTarget.entry.hasMiddleware) {
+		const preflight = await requestRoutePreflight(url.href);
+		if (!preflight.ok) {
+			if ("location" in preflight) {
+				if (redirectDepth >= 8) {
+					fallbackDocumentNavigation(doc, new URL(preflight.location, doc.location.href), mode);
+					return;
+				}
+				const redirectUrl = new URL(preflight.location, doc.location.href);
+				if (redirectUrl.origin !== doc.location.origin) {
+					fallbackDocumentNavigation(doc, redirectUrl, mode);
+					return;
+				}
+				await navigateContainer(container, redirectUrl.href, {
+					mode,
+					redirectDepth: redirectDepth + 1
+				});
+				return;
+			}
+			fallbackDocumentNavigation(doc, url, mode);
+			return;
+		}
+	}
+	if (!matched || !matched.entry.page) {
+		const notFoundRoute = !matched ? await loadResolvedRouteFromSpecial(container, pathname, "notFound") : null;
+		if (notFoundRoute) {
+			renderRouteIntoRoot(container, notFoundRoute.render, `route:${pathname}:not-found`);
+			router.currentRoute = notFoundRoute;
+			applyRouteMetadata(doc, notFoundRoute, url, router.defaultTitle);
+			commitBrowserNavigation(doc, url, mode);
+			router.currentPath.value = pathname;
+			return;
+		}
+		fallbackDocumentNavigation(doc, url, mode);
+		return;
+	}
+	if (pathname === router.currentPath.value) {
+		if (nextHref !== currentHref) commitBrowserNavigation(doc, url, mode);
+		return;
+	}
+	const pendingPrefetch = router.routePrefetches.get(routePrefetchKey(url));
+	if (pendingPrefetch) await pendingPrefetch;
+	applyPrefetchedLoaders(container, url);
+	const sequence = ++router.sequence;
+	router.isNavigating.value = true;
+	try {
+		const nextRoutePromise = loadResolvedRoute(container, matched);
+		if (matched.entry.loading) {
+			let settled = false;
+			nextRoutePromise.finally(() => {
+				settled = true;
+			});
+			await Promise.resolve();
+			if (!settled) {
+				const loadingRoute = await loadResolvedRoute(container, matched, "loading");
+				if (loadingRoute) {
+					renderRouteIntoRoot(container, loadingRoute.render, `route:${pathname}:loading`);
+					router.currentRoute = loadingRoute;
+				}
+			}
+		}
+		const [currentRoute, nextRoute] = await Promise.all([router.currentRoute ? Promise.resolve(router.currentRoute) : loadRouteComponent(container, router.currentPath.value), nextRoutePromise]);
+		if (!nextRoute) {
+			fallbackDocumentNavigation(doc, url, mode);
+			return;
+		}
+		if (sequence !== router.sequence) return;
+		const sharedLayoutCount = countSharedLayouts(currentRoute, nextRoute);
+		if (!(currentRoute && sharedLayoutCount > 0 ? await updateSharedLayoutBoundary(container, currentRoute, nextRoute, sharedLayoutCount) : false)) renderRouteIntoRoot(container, nextRoute.render, `route:${pathname}`);
+		router.currentRoute = nextRoute;
+		applyRouteMetadata(doc, nextRoute, url, router.defaultTitle);
+		commitBrowserNavigation(doc, url, mode);
+		router.currentPath.value = pathname;
+	} catch (error) {
+		if (sequence === router.sequence) {
+			const fallbackRoute = isRouteNotFoundError(error) ? await loadResolvedRouteFromSpecial(container, pathname, "notFound") : await loadResolvedRoute(container, matched, "error");
+			if (fallbackRoute) {
+				renderRouteIntoRoot(container, fallbackRoute.render, `route:${pathname}:${isRouteNotFoundError(error) ? "not-found" : "error"}`);
+				router.currentRoute = fallbackRoute;
+				applyRouteMetadata(doc, fallbackRoute, url, router.defaultTitle);
+				commitBrowserNavigation(doc, url, mode);
+				router.currentPath.value = pathname;
+				return;
+			}
+			fallbackDocumentNavigation(doc, url, mode);
+		}
+	} finally {
+		if (sequence === router.sequence) router.isNavigating.value = false;
+	}
+};
+const renderClientComponent = (componentFn, props) => {
+	const container = getCurrentContainer();
+	const parentFrame = getCurrentFrame();
+	const meta = getComponentMeta(componentFn);
+	if (!container || !parentFrame || !meta) return componentFn(props);
+	const position = nextComponentPosition(container);
+	const componentId = createComponentId(container, position.parentId, position.childIndex);
+	const existing = container.components.get(componentId);
+	const symbolChanged = !!existing && existing.symbol !== meta.symbol;
+	const component = getOrCreateComponentState(container, componentId, meta.symbol, position.parentId);
+	component.props = props && typeof props === "object" ? evaluateProps(props) : props;
+	component.projectionSlots = meta.projectionSlots ?? null;
+	if (!existing || symbolChanged) resetComponentForSymbolChange(container, component, meta);
+	component.active = true;
+	component.start = void 0;
+	component.end = void 0;
+	const frame = createFrame(container, component, "client");
+	const oldDescendants = collectDescendantIds(container, componentId);
+	clearComponentSubscriptions(container, componentId);
+	const renderProps = component.props && typeof component.props === "object" ? createRenderProps(componentId, meta, component.props) : component.props;
+	const rendered = pushFrame(frame, () => componentFn(renderProps));
+	pruneComponentVisibles(container, component, frame.visibleCursor);
+	pruneComponentWatches(container, component, frame.watchCursor);
+	pruneRemovedComponents(container, componentId, frame.visitedDescendants);
+	for (const descendantId of oldDescendants) {
+		if (frame.visitedDescendants.has(descendantId)) continue;
+		clearComponentSubscriptions(container, descendantId);
+	}
+	parentFrame.visitedDescendants.add(componentId);
+	for (const descendantId of frame.visitedDescendants) parentFrame.visitedDescendants.add(descendantId);
+	scheduleMountCallbacks(container, component, frame.mountCallbacks);
+	scheduleVisibleCallbacksCheck(container);
+	return rendered;
+};
+const activateComponent = async (container, componentId) => {
+	const component = container.components.get(componentId);
+	if (!component?.start || !component.end || component.active) return;
+	if (component.symbol === SUSPENSE_COMPONENT_SYMBOL) {
+		clearComponentSubscriptions(container, componentId);
+		const oldDescendants = collectDescendantIds(container, componentId);
+		const frame = createFrame(container, component, "client", { reuseExistingDom: component.reuseExistingDomOnActivate ?? true });
+		component.reuseExistingDomOnActivate = true;
+		const focusSnapshot = captureBoundaryFocus(container.doc, component.start, component.end);
+		const nodes = pushContainer(container, () => pushFrame(frame, () => renderSuspenseContentToNodes(component.props, container, componentId)));
+		pruneComponentVisibles(container, component, frame.visibleCursor);
+		pruneComponentWatches(container, component, frame.watchCursor);
+		replaceBoundaryContents(component.start, component.end, nodes, { preserveProjectionSlots: frame.projectionState.reuseExistingDom });
+		restoreBoundaryFocus(container.doc, component.start, component.end, focusSnapshot);
+		component.active = true;
+		pruneRemovedComponents(container, componentId, frame.visitedDescendants);
+		for (const descendantId of oldDescendants) {
+			if (frame.visitedDescendants.has(descendantId)) continue;
+			clearComponentSubscriptions(container, descendantId);
+		}
+		return;
+	}
+	clearComponentSubscriptions(container, componentId);
+	const oldDescendants = collectDescendantIds(container, componentId);
+	const scope = materializeScope(container, component.scopeId);
+	await preloadResumableValue(container, scope);
+	const module = await loadSymbol(container, component.symbol);
+	await preloadComponentProps(container, {
+		captures: () => [],
+		projectionSlots: component.projectionSlots ?? void 0,
+		symbol: component.symbol
+	}, component.props);
+	const frame = createFrame(container, component, "client", { reuseExistingDom: component.reuseExistingDomOnActivate ?? true });
+	component.reuseExistingDomOnActivate = true;
+	const focusSnapshot = captureBoundaryFocus(container.doc, component.start, component.end);
+	const nodes = pushContainer(container, () => pushFrame(frame, () => {
+		const renderProps = component.props && typeof component.props === "object" ? createRenderProps(component.id, {
+			captures: () => [],
+			projectionSlots: component.projectionSlots ?? void 0,
+			symbol: component.symbol
+		}, component.props) : component.props;
+		return toMountedNodes(module.default(scope, renderProps), container);
+	}));
+	pruneComponentVisibles(container, component, frame.visibleCursor);
+	pruneComponentWatches(container, component, frame.watchCursor);
+	replaceBoundaryContents(component.start, component.end, nodes, { preserveProjectionSlots: frame.projectionState.reuseExistingDom });
+	if (component.start.parentNode && "querySelectorAll" in component.start.parentNode) bindRouterLinks(container, component.start.parentNode);
+	restoreBoundaryFocus(container.doc, component.start, component.end, focusSnapshot);
+	component.active = true;
+	for (const descendantId of frame.visitedDescendants) {
+		const descendant = container.components.get(descendantId);
+		if (!descendant) continue;
+		descendant.active = true;
+		descendant.start = void 0;
+		descendant.end = void 0;
+	}
+	pruneRemovedComponents(container, componentId, frame.visitedDescendants);
+	for (const descendantId of oldDescendants) {
+		if (frame.visitedDescendants.has(descendantId)) continue;
+		clearComponentSubscriptions(container, descendantId);
+	}
+	clearComponentSubscriptions(container, componentId);
+	scheduleMountCallbacks(container, component, frame.mountCallbacks);
+	scheduleVisibleCallbacksCheck(container);
+};
+const sortDirtyComponents = (ids) => [...ids].sort((a, b) => a.split(".").length - b.split(".").length);
+const parseSymbolIdFromUrl = (url) => {
+	return new URL(url, "http://localhost").searchParams.get("eclipsa-symbol");
+};
+const findNearestMountedBoundary = (container, componentId) => {
+	let currentId = componentId;
+	while (currentId && currentId !== ROOT_COMPONENT_ID) {
+		const component = container.components.get(currentId);
+		if (!component) return null;
+		if (component.start && component.end) return component.id;
+		currentId = component.parentId;
+	}
+	return null;
+};
+const collectResumeHmrBoundaryIds = (container, symbolIds) => {
+	const targetSymbols = new Set(symbolIds);
+	const pendingBoundaries = /* @__PURE__ */ new Set();
+	for (const component of container.components.values()) {
+		if (!targetSymbols.has(component.symbol)) continue;
+		const boundaryId = findNearestMountedBoundary(container, component.id);
+		if (!boundaryId) {
+			if (component.active) return null;
+			continue;
+		}
+		pendingBoundaries.add(boundaryId);
+	}
+	const result = [];
+	for (const boundaryId of sortDirtyComponents(pendingBoundaries)) {
+		if (result.some((parentId) => boundaryId === parentId || isDescendantOf(parentId, boundaryId))) continue;
+		result.push(boundaryId);
+	}
+	return result;
+};
+const applyResumeHmrSymbolReplacements = (container, replacements) => {
+	for (const [oldSymbolId, url] of Object.entries(replacements)) {
+		const currentUrl = container.symbols.get(oldSymbolId);
+		const affectedIds = new Set([oldSymbolId]);
+		if (currentUrl) {
+			for (const [candidateId, candidateUrl] of container.symbols.entries()) if (candidateUrl === currentUrl) affectedIds.add(candidateId);
+		}
+		for (const affectedId of affectedIds) {
+			container.symbols.set(affectedId, url);
+			container.imports.delete(affectedId);
+		}
+		const nextSymbolId = parseSymbolIdFromUrl(url);
+		if (!nextSymbolId) continue;
+		for (const component of container.components.values()) if (affectedIds.has(component.symbol)) component.symbol = nextSymbolId;
+		for (const watch of container.watches.values()) if (affectedIds.has(watch.symbol)) watch.symbol = nextSymbolId;
+		for (const visible of container.visibles.values()) if (affectedIds.has(visible.symbol)) visible.symbol = nextSymbolId;
+		container.symbols.set(nextSymbolId, url);
+		container.imports.delete(nextSymbolId);
+	}
+};
+const applyResumeHmrUpdate = async (container, payload) => {
+	if (payload.fullReload) return "reload";
+	const boundaryIds = collectResumeHmrBoundaryIds(container, [...payload.rerenderComponentSymbols, ...payload.rerenderOwnerSymbols]);
+	if (boundaryIds === null) return "reload";
+	applyResumeHmrSymbolReplacements(container, payload.symbolUrlReplacements);
+	for (const boundaryId of boundaryIds) {
+		const component = container.components.get(boundaryId);
+		if (!component) continue;
+		resetComponentVisibleStates(container, boundaryId);
+		component.active = false;
+		container.dirty.add(boundaryId);
+	}
+	if (container.dirty.size > 0) await flushDirtyComponents(container);
+	return "updated";
+};
+const applyResumeHmrUpdateToRegisteredContainers = async (payload) => {
+	for (const container of getResumeContainers()) if (await applyResumeHmrUpdate(container, payload) === "reload") return "reload";
+	return "updated";
+};
+const flushDirtyComponents = async (container) => {
+	const globalRecord = globalThis;
+	const existing = globalRecord[DIRTY_FLUSH_PROMISE_KEY];
+	if (existing instanceof Promise) {
+		await existing;
+		return;
+	}
+	const flushing = (async () => {
+		while (container.dirty.size > 0) {
+			const batch = sortDirtyComponents(container.dirty);
+			container.dirty.clear();
+			const rerendered = /* @__PURE__ */ new Set();
+			for (const componentId of batch) {
+				if ([...rerendered].some((parentId) => componentId === parentId || isDescendantOf(parentId, componentId))) continue;
+				if (container.components.get(componentId)?.active) continue;
+				await activateComponent(container, componentId);
+				rerendered.add(componentId);
+			}
+		}
+	})();
+	globalRecord[DIRTY_FLUSH_PROMISE_KEY] = flushing;
+	try {
+		await flushing;
+	} finally {
+		delete globalRecord[DIRTY_FLUSH_PROMISE_KEY];
+	}
+};
+const beginSSRContainer = (symbols, render) => {
+	const container = createContainer(symbols);
+	const rootFrame = createFrame(container, {
+		active: false,
+		didMount: false,
+		id: ROOT_COMPONENT_ID,
+		mountCleanupSlots: [],
+		parentId: null,
+		props: {},
+		projectionSlots: null,
+		scopeId: registerScope(container, []),
+		signalIds: [],
+		symbol: ROOT_COMPONENT_ID,
+		suspensePromise: null,
+		visibleCount: 0,
+		watchCount: 0
+	}, "ssr");
+	return {
+		container,
+		result: pushContainer(container, () => pushFrame(rootFrame, render))
+	};
+};
+const beginAsyncSSRContainer = async (symbols, render, prepare, options) => {
+	const container = createContainer(symbols, void 0, options?.asyncSignalSnapshotCache);
+	const rootFrame = createFrame(container, {
+		active: false,
+		didMount: false,
+		id: ROOT_COMPONENT_ID,
+		mountCleanupSlots: [],
+		parentId: null,
+		props: {},
+		projectionSlots: null,
+		scopeId: registerScope(container, []),
+		signalIds: [],
+		symbol: ROOT_COMPONENT_ID,
+		suspensePromise: null,
+		visibleCount: 0,
+		watchCount: 0
+	}, "ssr");
+	await prepare?.(container);
+	return {
+		container,
+		result: pushContainer(container, () => pushFrame(rootFrame, render))
+	};
+};
+const createResumePayload = (container, componentIds) => {
+	const keepComponents = componentIds ? new Set(componentIds) : null;
+	const componentEntries = [...container.components.entries()].filter(([id]) => !keepComponents || keepComponents.has(id));
+	const keepSignals = new Set(componentEntries.flatMap(([, component]) => component.signalIds));
+	return {
+		actions: Object.fromEntries([...container.actionStates.entries()].map(([id, action]) => [id, {
+			error: serializeRuntimeValue(container, action.error),
+			input: serializeRuntimeValue(container, action.input),
+			result: serializeRuntimeValue(container, action.result)
+		}])),
+		components: Object.fromEntries(componentEntries.map(([id, component]) => [id, {
+			props: serializeRuntimeValue(container, component.props),
+			...component.projectionSlots ? { projectionSlots: { ...component.projectionSlots } } : {},
+			scope: component.scopeId,
+			signalIds: [...component.signalIds],
+			symbol: component.symbol,
+			visibleCount: component.visibleCount,
+			watchCount: component.watchCount
+		}])),
+		loaders: Object.fromEntries([...container.loaderStates.entries()].map(([id, loader]) => [id, {
+			data: serializeRuntimeValue(container, loader.data),
+			error: serializeRuntimeValue(container, loader.error),
+			loaded: loader.loaded
+		}])),
+		scopes: Object.fromEntries(container.scopes.entries()),
+		signals: Object.fromEntries([...container.signals.entries()].filter(([id]) => !keepComponents || keepSignals.has(id)).map(([id, record]) => [id, serializeRuntimeValue(container, record.value)])),
+		subscriptions: Object.fromEntries([...container.signals.entries()].filter(([id]) => !keepComponents || keepSignals.has(id)).map(([id, record]) => [id, [...record.subscribers].filter((componentId) => !keepComponents || keepComponents.has(componentId))])),
+		symbols: Object.fromEntries(container.symbols.entries()),
+		visibles: Object.fromEntries([...container.visibles.entries()].filter(([, visible]) => !keepComponents || keepComponents.has(visible.componentId)).map(([id, visible]) => [id, {
+			componentId: visible.componentId,
+			scope: visible.scopeId,
+			symbol: visible.symbol
+		}])),
+		watches: Object.fromEntries([...container.watches.entries()].filter(([, watch]) => !keepComponents || keepComponents.has(watch.componentId)).map(([id, watch]) => [id, {
+			componentId: watch.componentId,
+			mode: watch.mode,
+			scope: watch.scopeId,
+			signals: [...watch.effect.signals].map((signal) => signal.id),
+			symbol: watch.symbol
+		}]))
+	};
+};
+const toResumePayload = (container) => createResumePayload(container);
+const toResumePayloadSubset = (container, componentIds) => createResumePayload(container, componentIds);
+const bindComponentBoundaries = (container, root) => {
+	if (!hasOwnerDocument(root)) return;
+	for (const [id, boundary] of scanComponentBoundaries(root)) {
+		const component = container.components.get(id);
+		if (!component) continue;
+		component.start = boundary.start;
+		component.end = boundary.end;
+	}
+};
+const mergeResumePayload = (container, payload) => {
+	for (const [id, actionPayload] of Object.entries(payload.actions ?? {})) container.actionStates.set(id, {
+		error: deserializeRuntimeValue(container, actionPayload.error),
+		input: deserializeRuntimeValue(container, actionPayload.input),
+		result: deserializeRuntimeValue(container, actionPayload.result)
+	});
+	for (const [id, encodedValue] of Object.entries(payload.signals)) {
+		const decodedValue = deserializeRuntimeValue(container, encodedValue);
+		const record = ensureSignalRecord(container, id, decodedValue);
+		record.value = decodedValue;
+	}
+	for (const [id, loaderPayload] of Object.entries(payload.loaders ?? {})) container.loaderStates.set(id, {
+		data: deserializeRuntimeValue(container, loaderPayload.data),
+		error: deserializeRuntimeValue(container, loaderPayload.error),
+		loaded: loaderPayload.loaded
+	});
+	for (const [id, slots] of Object.entries(payload.scopes)) container.scopes.set(id, slots);
+	container.nextScopeId = findNextNumericId(container.scopes.keys(), "sc");
+	for (const [id, componentPayload] of Object.entries(payload.components)) container.components.set(id, {
+		active: false,
+		didMount: false,
+		id,
+		mountCleanupSlots: [],
+		parentId: id.includes(".") ? id.slice(0, id.lastIndexOf(".")) : ROOT_COMPONENT_ID,
+		props: deserializeRuntimeValue(container, componentPayload.props),
+		projectionSlots: componentPayload.projectionSlots ? { ...componentPayload.projectionSlots } : null,
+		scopeId: componentPayload.scope,
+		signalIds: [...componentPayload.signalIds],
+		symbol: componentPayload.symbol,
+		suspensePromise: null,
+		visibleCount: componentPayload.visibleCount ?? 0,
+		watchCount: componentPayload.watchCount
+	});
+	for (const [signalId, subscribers] of Object.entries(payload.subscriptions)) {
+		const record = container.signals.get(signalId);
+		if (!record) continue;
+		record.subscribers = new Set(subscribers);
+	}
+	container.nextSignalId = findNextNumericId(container.signals.keys(), "s");
+	for (const [id, watchPayload] of Object.entries(payload.watches)) {
+		const watch = getOrCreateWatchState(container, id, watchPayload.componentId);
+		watch.mode = watchPayload.mode;
+		watch.scopeId = watchPayload.scope;
+		watch.symbol = watchPayload.symbol;
+		watch.track = null;
+		watch.run = null;
+		clearEffectSignals(watch.effect);
+		for (const signalId of watchPayload.signals) {
+			const record = container.signals.get(signalId);
+			if (!record) continue;
+			watch.effect.signals.add(record);
+			record.effects.add(watch.effect);
+		}
+	}
+	for (const [id, visiblePayload] of Object.entries(payload.visibles ?? {})) {
+		const visible = getOrCreateVisibleState(container, id, visiblePayload.componentId);
+		visible.done = false;
+		visible.pending = null;
+		visible.run = null;
+		visible.scopeId = visiblePayload.scope;
+		visible.symbol = visiblePayload.symbol;
+	}
+};
+const pruneStreamedBoundaryDescendants = (container, boundaryId, payload) => {
+	pruneRemovedComponents(container, boundaryId, new Set(Object.keys(payload.components).filter((candidate) => isDescendantOf(boundaryId, candidate))));
+};
+const applyStreamedSuspenseBoundary = (container, chunk) => {
+	const doc = container.doc;
+	if (!doc) return;
+	const component = container.components.get(chunk.boundaryId);
+	if (!component?.start || !component.end) return;
+	const template = doc.getElementById(chunk.templateId);
+	const payloadScript = doc.getElementById(chunk.payloadScriptId);
+	if (!(template instanceof HTMLTemplateElement) || !payloadScript?.textContent) return;
+	const payload = JSON.parse(payloadScript.textContent);
+	const focusSnapshot = captureBoundaryFocus(doc, component.start, component.end);
+	const nodes = [...template.content.cloneNode(true).childNodes];
+	replaceBoundaryContents(component.start, component.end, nodes);
+	pruneStreamedBoundaryDescendants(container, chunk.boundaryId, payload);
+	mergeResumePayload(container, payload);
+	component.suspensePromise = null;
+	const parentRoot = component.start.parentNode;
+	if (parentRoot) {
+		bindComponentBoundaries(container, parentRoot);
+		restoreSignalRefs(container, parentRoot);
+		if ("querySelectorAll" in parentRoot) bindRouterLinks(container, parentRoot);
+	}
+	restoreBoundaryFocus(doc, component.start, component.end, focusSnapshot);
+	scheduleVisibleCallbacksCheck(container);
+	template.remove();
+	payloadScript.remove();
+};
+const getStreamState = () => {
+	const globalRecord = globalThis;
+	const existing = globalRecord[STREAM_STATE_KEY];
+	if (existing && typeof existing === "object" && "enqueue" in existing && "pending" in existing) return existing;
+	const created = {
+		enqueue(chunk) {
+			created.pending.push(chunk);
+			created.process?.();
+		},
+		pending: [],
+		processing: null
+	};
+	globalRecord[STREAM_STATE_KEY] = created;
+	return created;
+};
+const getStreamingResumeBootstrapScriptContent = () => "(()=>{const key=\"__eclipsa_stream\";const state=window[key]??={pending:[]};state.enqueue=state.enqueue??function(chunk){this.pending.push(chunk);if(this.process){void this.process();}};})();";
+const installStreamedSuspenseController = (container) => {
+	const state = getStreamState();
+	state.process = async () => {
+		if (state.processing) {
+			await state.processing;
+			return;
+		}
+		state.processing = (async () => {
+			while (state.pending.length > 0) {
+				const chunk = state.pending.shift();
+				if (!chunk) continue;
+				applyStreamedSuspenseBoundary(container, chunk);
+			}
+		})();
+		try {
+			await state.processing;
+		} finally {
+			state.processing = null;
+		}
+	};
+	if (state.pending.length > 0) state.process();
+};
+const createResumeContainer = (source, payload, options) => {
+	const doc = source instanceof Document ? source : source.ownerDocument;
+	const root = source instanceof Document ? doc.body : source;
+	const container = createContainer(payload.symbols, doc);
+	container.rootElement = root;
+	ensureRouterState(container, options?.routeManifest);
+	mergeResumePayload(container, payload);
+	bindComponentBoundaries(container, root);
+	restoreSignalRefs(container, root);
+	restoreRegisteredRpcHandles(container);
+	const router = ensureRouterState(container);
+	router.currentPath.value = normalizeRoutePath(doc.location.pathname);
+	router.isNavigating.value = false;
+	scheduleVisibleCallbacksCheck(container);
+	return container;
+};
+const restoreRegisteredRpcHandles = (container) => {
+	withRuntimeContainer(container, () => {
+		for (const id of getRegisteredActionHookIds()) getRegisteredActionHook(id)?.();
+		for (const id of getRegisteredLoaderHookIds()) getRegisteredLoaderHook(id)?.();
+	});
+};
+const primeRouteModules = async (container) => {
+	const router = ensureRouterState(container);
+	const currentRoute = await loadRouteComponent(container, router.currentPath.value);
+	if (currentRoute) {
+		router.currentRoute = currentRoute;
+		if (container.doc) applyRouteMetadata(container.doc, currentRoute, new URL(container.doc.location.href), router.defaultTitle);
+	}
+};
+const getRouterEventState = (event) => {
+	const eventRecord = event;
+	const existing = eventRecord[ROUTER_EVENT_STATE_KEY];
+	if (existing) return existing;
+	const originalPreventDefault = event.preventDefault.bind(event);
+	const state = {
+		originalPreventDefault,
+		routerPrevented: false,
+		userPrevented: false
+	};
+	eventRecord.preventDefault = () => {
+		if (state.routerPrevented) state.userPrevented = true;
+		originalPreventDefault();
+	};
+	eventRecord[ROUTER_EVENT_STATE_KEY] = state;
+	return state;
+};
+const findInteractiveTarget = (target, eventName) => {
+	let element = isElementNode(target) ? target : target instanceof Node ? target.parentElement : null;
+	while (element) {
+		if (element.hasAttribute(`data-e-on${eventName}`)) return element;
+		element = element.parentElement;
+	}
+	return null;
+};
+const getPendingLinkNavigationForLink = (container, event, link) => {
+	if (!(event instanceof MouseEvent)) return null;
+	if (event.defaultPrevented) return null;
+	if (event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return null;
+	if (link.hasAttribute("download")) return null;
+	if (link.target && link.target !== "_self") return null;
+	const href = link.getAttribute("href");
+	if (!href || !container.doc) return null;
+	const url = new URL(href, container.doc.location.href);
+	const pathname = normalizeRoutePath(url.pathname);
+	if (url.origin !== container.doc.location.origin) return null;
+	if (!matchRouteManifest(ensureRouterState(container).manifest, pathname)?.entry.page) return null;
+	const state = getRouterEventState(event);
+	state.routerPrevented = true;
+	state.originalPreventDefault();
+	return {
+		href: url.href,
+		replace: link.getAttribute(ROUTE_REPLACE_ATTR) === "true",
+		state
+	};
+};
+const getLinkPrefetchMode = (link) => {
+	const value = link.getAttribute(ROUTE_PREFETCH_ATTR);
+	if (value === "hover" || value === "focus" || value === "intent" || value === "none") return value;
+	return "intent";
+};
+const bindRouterLinkPrefetch = (container, link) => {
+	const boundLink = link;
+	if (boundLink[ROUTER_LINK_PREFETCH_BOUND_KEY]) return;
+	boundLink[ROUTER_LINK_PREFETCH_BOUND_KEY] = true;
+	const mode = getLinkPrefetchMode(link);
+	if (mode === "none") return;
+	const runPrefetch = () => {
+		const href = link.getAttribute("href");
+		if (!href) return;
+		prefetchRoute(container, href);
+	};
+	if (mode === "hover" || mode === "intent") link.addEventListener("mouseenter", runPrefetch);
+	if (mode === "focus" || mode === "intent") link.addEventListener("focus", runPrefetch);
+};
+const bindRouterLink = (container, link) => {
+	const boundLink = link;
+	if (boundLink[ROUTER_LINK_BOUND_KEY]) return;
+	boundLink[ROUTER_LINK_BOUND_KEY] = true;
+	link.addEventListener("click", (event) => {
+		const pendingLink = getPendingLinkNavigationForLink(container, event, link);
+		if (!pendingLink || pendingLink.state.userPrevented) return;
+		navigateContainer(container, pendingLink.href, { mode: pendingLink.replace ? "replace" : "push" });
+	});
+};
+const bindRouterLinks = (container, root) => {
+	const links = root.querySelectorAll(`a[${ROUTE_LINK_ATTR}]`);
+	for (const link of links) {
+		if (!isHTMLAnchorElementNode(link)) continue;
+		bindRouterLinkPrefetch(container, link);
+		bindRouterLink(container, link);
+	}
+};
+const parseBinding = (value) => {
+	const separatorIndex = value.indexOf(":");
+	if (separatorIndex < 0) throw new Error(`Invalid binding ${value}.`);
+	return {
+		symbolId: value.slice(0, separatorIndex),
+		scopeId: value.slice(separatorIndex + 1)
+	};
+};
+const withClientContainer = async (container, fn) => pushContainer(container, () => Promise.resolve(fn()));
+const createDelegatedEvent = (event, currentTarget) => Object.create(event, { currentTarget: { value: currentTarget } });
+const dispatchResumeEvent = async (container, event) => {
+	const interactiveTarget = findInteractiveTarget(event.target, event.type);
+	if (!interactiveTarget) return;
+	const pendingFocus = capturePendingFocusRestore(container, event.target);
+	const binding = interactiveTarget.getAttribute(`data-e-on${event.type}`);
+	if (!binding) return;
+	const { scopeId, symbolId } = parseBinding(binding);
+	const module = await loadSymbol(container, symbolId);
+	await withClientContainer(container, async () => {
+		await module.default(materializeScope(container, scopeId), createDelegatedEvent(event, interactiveTarget));
+	});
+	await flushDirtyComponents(container);
+	restorePendingFocus(container, pendingFocus);
+};
+const dispatchDocumentEvent = async (container, event) => {
+	await dispatchResumeEvent(container, event);
+	if (event.type === "submit" && !event.defaultPrevented && isHTMLFormElementNode(event.target)) {
+		const actionId = event.target.getAttribute(ACTION_FORM_ATTR$1);
+		if (actionId) {
+			const handle = container.actions.get(actionId);
+			if (handle) {
+				event.preventDefault();
+				const submitter = typeof SubmitEvent !== "undefined" && event instanceof SubmitEvent ? event.submitter ?? void 0 : void 0;
+				const formData = isHTMLElementNode(submitter) ? new FormData(event.target, submitter) : new FormData(event.target);
+				await handle.action(formData);
+				await flushDirtyComponents(container);
+			}
+		}
+	}
+};
+const installResumeListeners = (container) => {
+	const doc = container.doc;
+	if (!doc) return () => {};
+	bindRouterLinks(container, doc);
+	installStreamedSuspenseController(container);
+	ensureVisibilityListeners(container);
+	scheduleVisibleCallbacksCheck(container);
+	const listeners = [
+		"click",
+		"input",
+		"change",
+		"submit"
+	];
+	const onEvent = (event) => {
+		dispatchDocumentEvent(container, event);
+	};
+	const onPopState = () => {
+		navigateContainer(container, doc.location.href, { mode: "pop" });
+	};
+	for (const eventName of listeners) doc.addEventListener(eventName, onEvent, true);
+	doc.defaultView?.addEventListener("popstate", onPopState);
+	return () => {
+		for (const eventName of listeners) doc.removeEventListener(eventName, onEvent, true);
+		doc.defaultView?.removeEventListener("popstate", onPopState);
+		container.visibilityListenersCleanup?.();
+	};
+};
+const renderString = (inputElementLike) => renderStringNode(inputElementLike);
+const createStandaloneRuntimeSignal = (fallback) => {
+	const globalRecord = globalThis;
+	const nextId = (globalRecord[STANDALONE_SIGNAL_ID_KEY] ?? 0) + 1;
+	globalRecord[STANDALONE_SIGNAL_ID_KEY] = nextId;
+	return ensureSignalRecord(null, `$standalone:${nextId}`, fallback).handle;
+};
+const useRuntimeSignal = (fallback) => {
+	const container = getCurrentContainer();
+	const frame = getCurrentFrame();
+	if (!container || !frame || frame.component.id === ROOT_COMPONENT_ID) throw new Error("useSignal() can only be used while rendering a component.");
+	const signalIndex = frame.signalCursor++;
+	const existingId = frame.component.signalIds[signalIndex];
+	const signalId = existingId ?? `s${container.nextSignalId++}`;
+	if (!existingId) frame.component.signalIds.push(signalId);
+	const record = ensureSignalRecord(container, signalId, fallback);
+	recordSignalRead(record);
+	return record.handle;
+};
+const createDetachedRuntimeSignal = (container, id, fallback) => ensureSignalRecord(container, id, fallback).handle;
+const getRuntimeSignalId = (value) => getSignalMeta(value)?.id ?? null;
+const useRuntimeNavigate = () => {
+	const container = getCurrentContainer();
+	if (!container) return createStandaloneNavigate();
+	return ensureRouterState(container).navigate;
+};
+const useRuntimeRouteParams = () => {
+	const frame = getCurrentFrame();
+	if (frame?.component.props && typeof frame.component.props === "object") {
+		const candidate = frame.component.props[ROUTE_PARAMS_PROP];
+		if (candidate && typeof candidate === "object") return candidate;
+	}
+	return getCurrentContainer()?.router?.currentRoute?.params ?? EMPTY_ROUTE_PARAMS;
+};
+const notFound = () => {
+	throw {
+		__eclipsa_not_found__: true,
+		[ROUTE_NOT_FOUND_KEY]: true
+	};
+};
+const isRouteNotFoundError = (error) => !!error && typeof error === "object" && (error.__eclipsa_not_found__ === true || error[ROUTE_NOT_FOUND_KEY] === true);
+const createEffect = (fn) => {
+	const effect = {
+		fn() {
+			collectTrackedDependencies(effect, fn);
+		},
+		signals: /* @__PURE__ */ new Set()
+	};
+	effect.fn();
+};
+const createOnCleanup = (fn) => {
+	if (!currentCleanupSlot) throw new Error("onCleanup() can only be used while running onMount(), onVisible(), or useWatch() callbacks.");
+	currentCleanupSlot.callbacks.push(fn);
+};
+const createOnMount = (fn) => {
+	const frame = getCurrentFrame();
+	if (!frame || frame.component.id === ROOT_COMPONENT_ID || frame.mode !== "client") return;
+	frame.mountCallbacks.push(fn);
+};
+const createOnVisible = (fn) => {
+	const container = getCurrentContainer();
+	const frame = getCurrentFrame();
+	const lazyMeta = getLazyMeta(fn);
+	if (!container || !frame || frame.component.id === ROOT_COMPONENT_ID) return;
+	if (!lazyMeta && frame.mode === "ssr") return;
+	const visibleIndex = frame.visibleCursor++;
+	const visible = getOrCreateVisibleState(container, createVisibleId(frame.component.id, visibleIndex), frame.component.id);
+	visible.scopeId = lazyMeta ? registerScope(container, lazyMeta.captures()) : registerScope(container, []);
+	visible.symbol = lazyMeta?.symbol ?? "";
+	visible.run = lazyMeta ? null : fn;
+	scheduleVisibleCallbacksCheck(container);
+};
+const createWatch = (fn, dependencies) => {
+	const container = getCurrentContainer();
+	const frame = getCurrentFrame();
+	const watchMeta = getWatchMeta(fn);
+	if (!container || !frame || frame.component.id === ROOT_COMPONENT_ID || !watchMeta) {
+		const cleanupSlot = createCleanupSlot();
+		const effect = {
+			fn() {
+				createLocalWatchRunner(effect, cleanupSlot, fn, dependencies)();
+			},
+			signals: /* @__PURE__ */ new Set()
+		};
+		effect.fn();
+		return;
+	}
+	const watchIndex = frame.watchCursor++;
+	const watch = getOrCreateWatchState(container, createWatchId(frame.component.id, watchIndex), frame.component.id);
+	watch.mode = dependencies ? "explicit" : "dynamic";
+	watch.scopeId = registerScope(container, watchMeta.captures());
+	watch.symbol = watchMeta.symbol;
+	watch.track = dependencies ? () => trackWatchDependencies(dependencies) : null;
+	watch.run = createLocalWatchRunner(watch.effect, watch.cleanupSlot, fn, dependencies);
+	watch.effect.fn();
+};
+const getResumePayloadScriptContent = (payload) => escapeJSONScriptText(JSON.stringify(payload));
+//#endregion
+//#region core/action.ts
+const ACTION_REGISTRY_KEY = Symbol.for("eclipsa.action-registry");
+const ACTION_CONTENT_TYPE = "application/eclipsa-action+json";
+const ACTION_STREAM_CONTENT_TYPE = "application/eclipsa-action-stream+json";
+const ACTION_FORM_ATTR = "data-e-action-form";
+const ACTION_FORM_FIELD = "__e_action";
+const ACTION_INPUT_CACHE_KEY = Symbol.for("eclipsa.action-input-cache");
+const getActionRegistry = () => {
+	const globalRecord = globalThis;
+	const existing = globalRecord[ACTION_REGISTRY_KEY];
+	if (existing instanceof Map) return existing;
+	const created = /* @__PURE__ */ new Map();
+	globalRecord[ACTION_REGISTRY_KEY] = created;
+	return created;
+};
+const isFormDataValue = (value) => typeof FormData !== "undefined" && value instanceof FormData;
+const formDataToInputObject = (value) => {
+	const result = {};
+	for (const [key, entry] of value.entries()) {
+		const existing = result[key];
+		if (existing === void 0) {
+			result[key] = entry;
+			continue;
+		}
+		result[key] = Array.isArray(existing) ? [...existing, entry] : [existing, entry];
+	}
+	return result;
+};
+const normalizeFormSubmissionInput = (value) => {
+	if (!isFormDataValue(value)) return value;
+	const normalized = formDataToInputObject(value);
+	return Object.fromEntries(Object.entries(normalized).flatMap(([key, entry]) => {
+		if (key === "__e_action") return [];
+		if (Array.isArray(entry)) {
+			const values = entry.filter((candidate) => typeof candidate === "string").map((candidate) => candidate);
+			return values.length > 0 ? [[key, values.length === 1 ? values[0] : values]] : [];
+		}
+		return typeof entry === "string" ? [[key, entry]] : [];
+	}));
+};
+const getActionInputCache = (c) => {
+	const record = c;
+	if (!record[ACTION_INPUT_CACHE_KEY]) record[ACTION_INPUT_CACHE_KEY] = (async () => {
+		const contentType = c.req.header("content-type") ?? "";
+		if (contentType.startsWith("application/eclipsa-action+json")) {
+			let parsedBody;
+			try {
+				parsedBody = await c.req.json();
+			} catch {
+				throw new TypeError("Action input must be valid JSON.");
+			}
+			if (!parsedBody || typeof parsedBody !== "object" || !("input" in parsedBody)) throw new TypeError("Action request body must contain an input field.");
+			return deserializeActionServerValue(parsedBody.input);
+		}
+		if (contentType.startsWith("application/x-www-form-urlencoded") || contentType.startsWith("multipart/form-data")) return c.req.formData();
+	})();
+	return record[ACTION_INPUT_CACHE_KEY];
+};
+const createActionRefScope = (container) => container ? serializeValue({ container: container.id }) : void 0;
+const readActionRefContainerId = (reference) => {
+	if (!reference.data) return null;
+	const decoded = deserializeValue(reference.data);
+	if (!decoded || typeof decoded !== "object") return null;
+	const containerId = decoded.container;
+	return typeof containerId === "string" ? containerId : null;
+};
+const serializeActionClientValue = (container, value) => serializeValue(value, { serializeReference(candidate) {
+	const signalId = getRuntimeSignalId(candidate);
+	if (signalId) return {
+		__eclipsa_type: "ref",
+		data: createActionRefScope(container),
+		kind: "signal",
+		token: signalId
+	};
+	if (container && typeof Element !== "undefined" && candidate instanceof Element) return {
+		__eclipsa_type: "ref",
+		data: createActionRefScope(container),
+		kind: "dom",
+		token: ensureRuntimeElementId(container, candidate)
+	};
+	return null;
+} });
+const deserializeActionServerValue = (value) => deserializeValue(value, { deserializeReference(reference) {
+	const containerId = readActionRefContainerId(reference);
+	if (reference.kind === "signal") return {
+		containerId,
+		kind: "signal-ref",
+		token: reference.token
+	};
+	if (reference.kind === "dom") return {
+		containerId,
+		kind: "dom-ref",
+		token: reference.token
+	};
+	throw new TypeError(`Unsupported action input reference kind "${reference.kind}".`);
+} });
+const deserializeActionClientValue = (container, value) => deserializeValue(value, { deserializeReference(reference) {
+	if (!container) throw new TypeError("Action references require an active runtime container.");
+	if (readActionRefContainerId(reference) !== container.id) throw new TypeError("Action reference does not belong to the active runtime container.");
+	if (reference.kind === "signal") {
+		const signal = container.signals.get(reference.token);
+		if (!signal) throw new Error(`Missing action signal ${reference.token}.`);
+		return signal.handle;
+	}
+	if (reference.kind === "dom") {
+		const element = findRuntimeElement(container, reference.token);
+		if (!element) throw new Error(`Missing action DOM ref ${reference.token}.`);
+		return element;
+	}
+	throw new TypeError(`Unsupported action output reference kind "${reference.kind}".`);
+} });
+const isOpaqueSignalRef = (value) => !!value && typeof value === "object" && value.kind === "signal-ref" && typeof value.token === "string";
+const isOpaqueDomRef = (value) => !!value && typeof value === "object" && value.kind === "dom-ref" && typeof value.token === "string";
+const serializeActionServerValue = (value) => serializeValue(value, { serializeReference(candidate) {
+	if (isOpaqueSignalRef(candidate)) return {
+		__eclipsa_type: "ref",
+		data: candidate.containerId === null ? void 0 : serializeValue({ container: candidate.containerId }),
+		kind: "signal",
+		token: candidate.token
+	};
+	if (isOpaqueDomRef(candidate)) return {
+		__eclipsa_type: "ref",
+		data: candidate.containerId === null ? void 0 : serializeValue({ container: candidate.containerId }),
+		kind: "dom",
+		token: candidate.token
+	};
+	return null;
+} });
+const isReadableStreamValue = (value) => typeof ReadableStream !== "undefined" && value instanceof ReadableStream;
+const isAsyncGeneratorValue = (value) => !!value && typeof value === "object" && Symbol.asyncIterator in value;
+const toSerializedActionError = (error) => {
+	if (error instanceof Error) return serializeActionServerValue({
+		message: error.message,
+		name: error.name
+	});
+	try {
+		return serializeActionServerValue(error);
+	} catch {
+		return serializeActionServerValue({ message: "Action failed." });
+	}
+};
+const toAsyncIterable = async function* (value) {
+	if (isReadableStreamValue(value)) {
+		const reader = value.getReader();
+		try {
+			while (true) {
+				const next = await reader.read();
+				if (next.done) return;
+				yield next.value;
+			}
+		} finally {
+			reader.releaseLock();
+		}
+	}
+	yield* value;
+};
+const encodeStreamFrame = (frame) => `${JSON.stringify(frame)}
+`;
+const streamActionValue = (value, serializeChunk) => {
+	const encoder = new TextEncoder();
+	return new ReadableStream({ async start(controller) {
+		try {
+			for await (const chunk of toAsyncIterable(value)) controller.enqueue(encoder.encode(encodeStreamFrame({
+				type: "chunk",
+				value: serializeChunk(chunk)
+			})));
+			controller.enqueue(encoder.encode(encodeStreamFrame({ type: "done" })));
+		} catch (error) {
+			controller.enqueue(encoder.encode(encodeStreamFrame({
+				error: toSerializedActionError(error),
+				type: "error"
+			})));
+		} finally {
+			controller.close();
+		}
+	} });
+};
+const parseJsonActionResponse = async (response, container) => {
+	const body = await response.json();
+	if (!body || typeof body !== "object" || typeof body.ok !== "boolean") throw new TypeError("Malformed action response.");
+	if (!body.ok) throw deserializeActionClientValue(container, body.error);
+	return deserializeActionClientValue(container, body.value);
+};
+const iterateStreamFrames = async function* (body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const next = await reader.read();
+			if (next.done) break;
+			buffer += decoder.decode(next.value, { stream: true });
+			while (true) {
+				const newlineIndex = buffer.indexOf("\n");
+				if (newlineIndex < 0) break;
+				const line = buffer.slice(0, newlineIndex).trim();
+				buffer = buffer.slice(newlineIndex + 1);
+				if (!line) continue;
+				yield JSON.parse(line);
+			}
+		}
+		const trailing = buffer.trim();
+		if (trailing) yield JSON.parse(trailing);
+	} finally {
+		reader.releaseLock();
+	}
+};
+const toClientStream = (response, container) => {
+	if (!response.body) throw new TypeError("Missing action stream body.");
+	return new ReadableStream({ async start(controller) {
+		try {
+			for await (const frame of iterateStreamFrames(response.body)) {
+				if (frame.type === "chunk") {
+					controller.enqueue(deserializeActionClientValue(container, frame.value));
+					continue;
+				}
+				if (frame.type === "done") {
+					controller.close();
+					return;
+				}
+				controller.error(deserializeActionClientValue(container, frame.error));
+				return;
+			}
+			controller.close();
+		} catch (error) {
+			controller.error(error);
+		}
+	} });
+};
+const toClientAsyncGenerator = async function* (response, container) {
+	if (!response.body) throw new TypeError("Missing action stream body.");
+	for await (const frame of iterateStreamFrames(response.body)) {
+		if (frame.type === "chunk") {
+			yield deserializeActionClientValue(container, frame.value);
+			continue;
+		}
+		if (frame.type === "done") return;
+		throw deserializeActionClientValue(container, frame.error);
+	}
+};
+const invokeAction = async (id, input, container) => {
+	const isFormSubmission = isFormDataValue(input);
+	const response = await fetch(`/__eclipsa/action/${encodeURIComponent(id)}`, {
+		body: isFormSubmission ? input : JSON.stringify({ input: serializeActionClientValue(container, input) }),
+		headers: {
+			accept: `${ACTION_STREAM_CONTENT_TYPE}, ${ACTION_CONTENT_TYPE}`,
+			...isFormSubmission ? {} : { "content-type": ACTION_CONTENT_TYPE }
+		},
+		method: "POST"
+	});
+	const contentType = response.headers.get("content-type") ?? "";
+	const streamKind = response.headers.get("x-eclipsa-stream-kind");
+	if (contentType.startsWith(ACTION_STREAM_CONTENT_TYPE)) {
+		if (streamKind === "async-generator") return toClientAsyncGenerator(response, container);
+		return toClientStream(response, container);
+	}
+	return parseJsonActionResponse(response, container);
+};
+const composeMiddlewares = async (c, middlewares, handler) => {
+	let index = -1;
+	const dispatch = async (nextIndex) => {
+		if (nextIndex <= index) throw new Error("Action middleware called next() multiple times.");
+		index = nextIndex;
+		const middleware = middlewares[nextIndex];
+		if (!middleware) return handler(c);
+		let nextResult = void 0;
+		const result = await middleware(c, (async () => {
+			nextResult = await dispatch(nextIndex + 1);
+		}));
+		if (result !== void 0) return result;
+		return nextResult;
+	};
+	return dispatch(0);
+};
+const toActionResponse = (value) => {
+	if (value instanceof Response) return value;
+	if (isReadableStreamValue(value)) return new Response(streamActionValue(value, (entry) => serializeActionServerValue(entry)), { headers: {
+		"content-type": ACTION_STREAM_CONTENT_TYPE,
+		"x-eclipsa-stream-kind": "readable-stream"
+	} });
+	if (isAsyncGeneratorValue(value)) return new Response(streamActionValue(value, (entry) => serializeActionServerValue(entry)), { headers: {
+		"content-type": ACTION_STREAM_CONTENT_TYPE,
+		"x-eclipsa-stream-kind": "async-generator"
+	} });
+	return new Response(JSON.stringify({
+		ok: true,
+		value: serializeActionServerValue(value)
+	}), { headers: { "content-type": ACTION_CONTENT_TYPE } });
+};
+const createHandleSignal = (container, id, key, initialValue) => {
+	if (!container) throw new Error("Action handles require an active runtime container.");
+	return createDetachedRuntimeSignal(container, `$action:${id}:${key}`, initialValue);
+};
+const readActionSubmissionInput = async (c) => {
+	const cached = await getActionInputCache(c);
+	const actionVars = c.var;
+	return normalizeFormSubmissionInput(actionVars.__e_action_raw_input ?? cached);
+};
+const getNormalizedActionInput = (c) => readActionSubmissionInput(c);
+const getActionFormSubmissionId = async (c) => {
+	const input = await getActionInputCache(c);
+	if (!isFormDataValue(input)) return null;
+	const actionId = input.get(ACTION_FORM_FIELD);
+	return typeof actionId === "string" && actionId ? actionId : null;
+};
+const executeActionSubmission = async (id, c) => {
+	const action = getActionRegistry().get(id);
+	if (!action) throw new Error(`Unknown action ${id}.`);
+	const input = await readActionSubmissionInput(c);
+	const result = await composeMiddlewares(c, action.middlewares, action.handler);
+	if (result instanceof Response) return {
+		input,
+		kind: "response",
+		response: result
+	};
+	return {
+		input,
+		kind: "value",
+		value: result
+	};
+};
+const primeActionState = (container, id, snapshot) => {
+	container.actionStates.set(id, {
+		error: snapshot.error,
+		input: snapshot.input,
+		result: snapshot.result
+	});
+};
+const appendClientChildren = (parent, value) => {
+	let resolved = value;
+	while (typeof resolved === "function") resolved = resolved();
+	if (Array.isArray(resolved)) {
+		for (const entry of resolved) appendClientChildren(parent, entry);
+		return;
+	}
+	if (resolved === null || resolved === void 0 || resolved === false) return;
+	if (resolved instanceof Node) {
+		parent.appendChild(resolved);
+		return;
+	}
+	parent.appendChild(document.createTextNode(String(resolved)));
+};
+const createActionFormNode = (id, props) => {
+	const form = document.createElement("form");
+	form.setAttribute(ACTION_FORM_ATTR, id);
+	form.setAttribute("method", "post");
+	const hiddenInput = document.createElement("input");
+	hiddenInput.name = ACTION_FORM_FIELD;
+	hiddenInput.type = "hidden";
+	hiddenInput.value = id;
+	form.appendChild(hiddenInput);
+	for (const [name, value] of Object.entries(props)) {
+		if (name === "children" || name === "action" || name === "method" || value === false || value === void 0 || value === null) continue;
+		if (name === "class") {
+			form.className = String(value);
+			continue;
+		}
+		if (name === "style" && value && typeof value === "object") {
+			form.setAttribute("style", Object.entries(value).map(([styleName, styleValue]) => `${styleName}: ${styleValue}`).join("; "));
+			continue;
+		}
+		if (value === true) {
+			form.setAttribute(name, "");
+			continue;
+		}
+		form.setAttribute(name, String(value));
+	}
+	appendClientChildren(form, props.children);
+	return form;
+};
+const action$ = (() => {
+	throw new Error("action$() must be compiled by the Eclipsa analyzer before it can run.");
+});
+const validator = (schema) => {
+	const middleware = async (c, next) => {
+		let parsedBody;
+		try {
+			parsedBody = await getActionInputCache(c);
+		} catch (error) {
+			return c.json({
+				error: serializeValue({ issues: [{ message: error instanceof Error && error.message ? error.message : "Action input could not be parsed." }] }),
+				ok: false
+			}, 400);
+		}
+		const rawInput = normalizeFormSubmissionInput(parsedBody);
+		const validated = await schema["~standard"].validate(rawInput);
+		if ("issues" in validated) return c.json({
+			error: serializeValue({ issues: validated.issues }),
+			ok: false
+		}, 400);
+		c.set("__e_action_raw_input", rawInput);
+		c.set("input", validated.value);
+		await next();
+	};
+	return middleware;
+};
+function registerAction(id, middlewares, handler) {
+	getActionRegistry().set(id, {
+		handler,
+		id,
+		middlewares: [...middlewares]
+	});
+}
+const hasAction = (id) => getActionRegistry().has(id);
+const executeAction = async (id, c) => {
+	try {
+		const result = await executeActionSubmission(id, c);
+		return result.kind === "response" ? result.response : toActionResponse(result.value);
+	} catch (error) {
+		return new Response(JSON.stringify({
+			error: toSerializedActionError(error),
+			ok: false
+		}), {
+			headers: { "content-type": ACTION_CONTENT_TYPE },
+			status: 500
+		});
+	}
+};
+const __eclipsaAction = (id, middlewares, handler) => {
+	if (typeof window === "undefined") getActionRegistry().set(id, {
+		handler,
+		id,
+		middlewares: [...middlewares]
+	});
+	return registerActionHook(id, setActionHookMeta(() => {
+		const container = getRuntimeContainer();
+		const existing = container?.actions.get(id);
+		if (existing) return existing;
+		const initialState = container?.actionStates.get(id);
+		const pending = createHandleSignal(container, id, "pending", false);
+		const result = createHandleSignal(container, id, "result", initialState?.result);
+		const error = createHandleSignal(container, id, "error", initialState?.error);
+		const lastSubmission = createHandleSignal(container, id, "last-submission", initialState ? {
+			error: initialState.error,
+			input: initialState.input,
+			result: initialState.result
+		} : void 0);
+		const syncSnapshot = () => {
+			if (!container) return;
+			const submission = lastSubmission.value;
+			if (!submission) {
+				container.actionStates.delete(id);
+				return;
+			}
+			container.actionStates.set(id, {
+				error: submission.error,
+				input: submission.input,
+				result: submission.result
+			});
+		};
+		const invoke = async (input) => {
+			pending.value = true;
+			error.value = void 0;
+			const normalizedInput = normalizeFormSubmissionInput(input);
+			try {
+				const value = await invokeAction(id, input, container);
+				result.value = value;
+				lastSubmission.value = {
+					error: void 0,
+					input: normalizedInput,
+					result: value
+				};
+				syncSnapshot();
+				return value;
+			} catch (caught) {
+				error.value = caught;
+				lastSubmission.value = {
+					error: caught,
+					input: normalizedInput,
+					result: void 0
+				};
+				syncSnapshot();
+				throw caught;
+			} finally {
+				pending.value = false;
+			}
+		};
+		const actionHandle = setActionHandleMeta({
+			Form: component$((props) => {
+				if (typeof document !== "undefined") return createActionFormNode(id, props);
+				const nextProps = {
+					...props,
+					[ACTION_FORM_ATTR]: id,
+					method: "post",
+					children: [{
+						isStatic: true,
+						props: {
+							name: ACTION_FORM_FIELD,
+							type: "hidden",
+							value: id
+						},
+						type: "input"
+					}, props.children]
+				};
+				delete nextProps.action;
+				delete nextProps.method;
+				return {
+					isStatic: true,
+					props: nextProps,
+					type: "form"
+				};
+			}),
+			action: invoke,
+			get error() {
+				return error.value;
+			},
+			get formActionId() {
+				return id;
+			},
+			get isPending() {
+				return pending.value;
+			},
+			get lastSubmission() {
+				return lastSubmission.value;
+			},
+			get result() {
+				return result.value;
+			}
+		}, id);
+		container?.actions.set(id, actionHandle);
+		syncSnapshot();
+		return actionHandle;
+	}, id));
+};
+//#endregion
+export { getActionHandleMeta as $, getRuntimeContainer as A, registerLoader as At, renderString as B, serializeValue as Bt, createOnCleanup as C, executeLoader as Ct, createStandaloneRuntimeSignal as D, loader_exports as Dt, createResumeContainer as E, loader$ as Et, primeRouteModules as F, isSuspenseType as Ft, useRuntimeRouteParams as G, toResumePayload as H, component$ as Ht, readAsyncSignalSnapshot as I, deserializeValue as It, writeAsyncSignalSnapshot as J, useRuntimeSignal as K, registerResumeContainer as L, escapeJSONScriptText as Lt, getStreamingResumeBootstrapScriptContent as M, Suspense as Mt, installResumeListeners as N, createPendingSignalError as Nt, createWatch as O, markPendingSsrLoader as Ot, notFound as P, isPendingSignalError as Pt, __eclipsaWatch as Q, renderClientComponent as R, parseSerializedJSON as Rt, createEffect as S, consumePendingSsrLoaderIds as St, createOnVisible as T, isPendingSsrLoaderError as Tt, toResumePayloadSubset as U, restoreRegisteredRpcHandles as V, $ as Vt, useRuntimeNavigate as W, __eclipsaEvent as X, __eclipsaComponent as Y, __eclipsaLazy as Z, assignRuntimeRef as _, setLoaderHandleMeta as _t, action$ as a, getLoaderHookMeta as at, bindRuntimeEvent as b, setSignalMeta as bt, getActionFormSubmissionId as c, getRegisteredActionHookIds as ct, primeActionState as d, getSignalMeta as dt, getActionHookMeta as et, registerAction as f, getWatchMeta as ft, applyResumeHmrUpdateToRegisteredContainers as g, setActionHookMeta as gt, RESUME_STATE_ELEMENT_ID as h, setActionHandleMeta as ht, __eclipsaAction as i, getLoaderHandleMeta as it, getRuntimeSignalId as j, resolvePendingLoaders as jt, getResumePayloadScriptContent as k, primeLoaderState as kt, getNormalizedActionInput as l, getRegisteredLoaderHook as lt, RESUME_FINAL_STATE_ELEMENT_ID as m, registerLoaderHook as mt, ACTION_FORM_ATTR as n, getEventMeta as nt, executeAction as o, getNavigateMeta as ot, validator as p, registerActionHook as pt, withRuntimeContainer as q, ACTION_FORM_FIELD as r, getLazyMeta as rt, executeActionSubmission as s, getRegisteredActionHook as st, ACTION_CONTENT_TYPE as t, getComponentMeta as tt, hasAction as u, getRegisteredLoaderHookIds as ut, beginAsyncSSRContainer as v, setLoaderHookMeta as vt, createOnMount as w, hasLoader as wt, collectPendingSuspenseBoundaryIds as x, __eclipsaLoader as xt, beginSSRContainer as y, setNavigateMeta as yt, renderClientInsertable as z, serializeJSONScriptContent as zt };
+
+//# sourceMappingURL=action-LXy_7T1f.mjs.map