@qwik.dev/router 2.0.0-beta.43 → 2.0.0-beta.47

package/lib/chunks/head.qwik.mjs

@@ -1,21 +1,34 @@
 import { t as ensureSlash } from "./pathname.mjs";
 import { o as getLoaderName } from "./request-path.mjs";
 import { i as RedirectMessage, n as throwIfControlFlowSignal, t as ServerError } from "./server-error.mjs";
-import { _captures, createComputedQrl, createContextId, implicit$FirstArg, inlinedQrl, isDev, isServer, withLocale } from "@qwik.dev/core";
-import * as qwikRouterConfig from "@qwik-router-config";
-import { SerializerSymbol, _UNINITIALIZED, _deserialize, _getAsyncLocalStorage, _getContextEvent, _injectAsyncSignalValue, _markSignalAsExternallyOwned, _resolveContextWithoutSequentialScope, _verifySerializable } from "@qwik.dev/core/internal";
+import { r as unescapeStaticTrieKey, t as escapeStaticTrieKey } from "./route-trie-key.mjs";
+import { _capturesObj, createComputedQrl, createContextId, implicit$FirstArg, inlinedQrl, isBrowser, isDev, isServer, untrack, useServerData, withLocale } from "@qwik.dev/core";
+import { SerializerSymbol, _UNINITIALIZED, _deserialize, _getAsyncLocalStorage, _injectAsyncSignalValue, _markSignalAsExternallyOwned, _qwikSymbol, _registerSingleton, _resolveContextWithoutSequentialScope, _verifySerializable } from "@qwik.dev/core/internal";
 import { isServer as isServer$1 } from "@qwik.dev/core/build";
-/** @internal */ var _asyncRequestStore;
-if (isServer$1) {
+var createRequestStore = () => {
 	const AsyncLocalStorage = _getAsyncLocalStorage();
-	if (AsyncLocalStorage) _asyncRequestStore = new AsyncLocalStorage();
-	else console.warn("\n=====================\n  Qwik Router Warning:\n    AsyncLocalStorage is not available, continuing without it.\n    This impacts concurrent async server calls, where they lose access to the ServerRequestEv object.\n=====================\n\n");
-}
+	if (AsyncLocalStorage) return new AsyncLocalStorage();
+	console.warn("\n=====================\n  Qwik Router Warning:\n    AsyncLocalStorage is not available, continuing without it.\n    This impacts concurrent async server calls, where they lose access to the ServerRequestEv object.\n=====================\n\n");
+};
+/**
+* Shared with the router copy of a Qwik library kept external on the server, so its
+* `getRequestEvent()` and `server$` see the request the app is serving.
+*
+* @internal
+*/
+var _asyncRequestStore = isServer$1 ? _registerSingleton("routerRequestStore", createRequestStore) : void 0;
+/** The request event's key for the config of the app serving it. */
+var RequestEvRouterConfig = /*#__PURE__*/ _qwikSymbol("router.config");
+/** The config of the app serving the current request, for a router copy that holds none. */
+var getServingRouterConfig = () => _asyncRequestStore?.getStore()?.[RequestEvRouterConfig];
 var QACTION_KEY = "qaction";
 var QFN_KEY = "qfunc";
 var QDATA_KEY = "qdata";
-/** @public */ var Q_ROUTE = "q:route";
-var DEFAULT_LOADERS_SERIALIZATION_STRATEGY = globalThis.__DEFAULT_LOADERS_SERIALIZATION_STRATEGY__ || "never";
+/** @public */
+var Q_ROUTE = "q:route";
+function DEFAULT_LOADERS_SERIALIZATION_STRATEGY() {
+	return globalThis.__DEFAULT_LOADERS_SERIALIZATION_STRATEGY__ || "never";
+}
 var RouteStateContext = /*#__PURE__*/ createContextId("qr-s");
 var RouteLoaderCtxContext = /*#__PURE__*/ createContextId("qr-lc");
 var ContentContext = /*#__PURE__*/ createContextId("qr-c");
@@ -26,28 +39,97 @@ var RouteNavigateContext = /*#__PURE__*/ createContextId("qr-n");
 var RouteActionContext = /*#__PURE__*/ createContextId("qr-a");
 var RoutePreventNavigateContext = /*#__PURE__*/ createContextId("qr-p");
 var HttpStatusContext = /*#__PURE__*/ createContextId("qr-hs");
+var holder = {};
+/** The config this router copy holds, else the one of the app serving the current request. */
+var findRouterConfig = () => holder.config ?? getServingRouterConfig();
+/**
+* Registers the app's route config with the router copy bundled into the app. The generated
+* `@qwik-router-config` module calls this on the server; the client loads that module lazily
+* instead, since it is a separate chunk.
+*
+* @internal
+*/
+var _setRouterConfig = (config) => {
+	holder.config = config;
+	holder.ready = void 0;
+};
+/**
+* The app's route config: the route trie, server plugins and build options that the Qwik Router
+* Vite plugin generated. Resolves once the config is loaded and its `server$` modules are
+* registered. On the server, the router copy of a Qwik library kept external reads the config of
+* the app serving the current request.
+*
+* @public
+*/
+var getRouterConfig = () => {
+	const servingConfig = !holder.config && getServingRouterConfig();
+	if (servingConfig) return Promise.resolve(servingConfig);
+	if (!holder.ready) holder.ready = loadRouterConfig().catch((error) => {
+		holder.ready = void 0;
+		throw error;
+	});
+	return holder.ready;
+};
+var loadRouterConfig = async () => {
+	if (!holder.config) {
+		const configModule = await import("@qwik-router-config").catch((error) => {
+			throw isBrowser ? error : new Error("Qwik Router config not found. Import \"@qwik-router-config\" in the server entry that the Qwik Router Vite plugin builds.", { cause: error });
+		});
+		holder.config ??= configModule;
+	}
+	await holder.config.importEagerModules?.();
+	return holder.config;
+};
+/**
+* The route trie of the app, as generated by the Qwik Router Vite plugin.
+*
+* @public
+*/
+var getRoutes = async () => (await getRouterConfig()).routes;
+/**
+* The base pathname the app is served under, such as `/` or `/docs/`.
+*
+* @public
+*/
+var getBasePathname = () => findRouterConfig()?.basePathname ?? globalThis.__QWIK_ROUTER_BASE_PATHNAME__ ?? "/";
+/**
+* Whether the app's URLs end with a trailing slash.
+*
+* @public
+*/
+var getTrailingSlash = () => findRouterConfig()?.trailingSlash ?? !globalThis.__NO_TRAILING_SLASH__;
+/** @internal */
+var _getServiceWorkerUrl = () => findRouterConfig()?.serviceWorkerUrl;
 /**
 * Route loaders read data before the route rendering starts, based on the route being navigated to.
 * They automatically update when the route changes on the client.
 *
 * They are represented by a ComputedSignal.
-*/ var REQUEST_ROUTE_LOADER_STATE = "@routeLoaderState";
+*/
+var REQUEST_ROUTE_LOADER_STATE = "@routeLoaderState";
 var REQUEST_LOADER_PATHS_STORE = "@loaderPathsStore";
+var REQUEST_LOADER_PARAMS_STORE = "@loaderParamsStore";
 var REQUEST_ROUTE_LOADERS = "@routeLoaders";
 var REQUEST_ROUTE_LOADER_PROMISES = "@routeLoaderPromises";
 var REQUEST_ROUTE_LOADER_EVENTS = "@routeLoaderEvents";
 var REQUEST_ROUTE_LOADER_ROOT_EVENT = "@routeLoaderRootEvent";
 var ROUTE_LOADER_VALUE_PREFIX = "__qwik_route_loader_value__";
-/** Header name sent by client to tell the server the actual page URL for loader requests. */ var FULLPATH_HEADER = "X-Qwik-fullpath";
-/** Dev route hint that preserves the loader URL. */ var ROUTE_PATH_HEADER = "X-Qwik-route-path";
+/** Header name sent by client to tell the server the actual page URL for loader requests. */
+var FULLPATH_HEADER = "X-Qwik-fullpath";
+/** Dev route hint that preserves the loader URL. */
+var ROUTE_PATH_HEADER = "X-Qwik-route-path";
 /**
 * Per-navigation fetch dedupe: shares in-flight and completed fetches (hover prefetch → click nav)
 * and prevents repeat hover fetches. Cleared after each navigation kicks off its loader fetches;
 * across navigations the browser HTTP cache is the freshness authority.
-*/ var navFetchCache = /* @__PURE__ */ new Map();
-var clearNavFetchCache = () => navFetchCache.clear();
+*/
+var navFetchCache = /* @__PURE__ */ new Map();
+var clearNavFetchCache = () => {
+	navFetchCache = /* @__PURE__ */ new Map();
+};
 var isRedirectStatus = (status) => status >= 300 && status < 400;
-/** We don't have aborts when preloading so we just pretend we do */ var wrapWithAbort = (promise, signal) => {
+/** We don't have aborts when preloading so we just pretend we do */
+var wrapWithAbort = (promise, signal) => {
 	if (signal.aborted) return Promise.reject(signal.reason);
 	return new Promise((resolve, reject) => {
 		const abort = () => reject(signal.reason);
@@ -55,14 +137,79 @@ var isRedirectStatus = (status) => status >= 300 && status < 400;
 		promise.finally(() => signal.removeEventListener("abort", abort)).then(resolve, reject);
 	});
 };
+var clientRouteLoaders = /* @__PURE__ */ new WeakMap();
+function getClientRouteLoaders(ctx, pageUrl) {
+	let client = clientRouteLoaders.get(ctx);
+	if (!client) {
+		const current = {
+			requests: /* @__PURE__ */ new Map(),
+			paths: { ...ctx.loaderPaths },
+			pageUrl: pageUrl || location.href
+		};
+		client = {
+			current,
+			committed: current
+		};
+		clientRouteLoaders.set(ctx, client);
+	}
+	return client;
+}
+function getLoaderRequest(ctx, state, id, hash1) {
+	return untrack(() => {
+		const client = getClientRouteLoaders(ctx);
+		const { requests, paths, pageUrl } = client.current;
+		let request = requests.get(state[id]);
+		if (!request) {
+			const path = paths[id] || paths[hash1];
+			request = {
+				routePath: path || new URL(pageUrl).pathname,
+				pageUrl,
+				active: client.navCount === void 0 || !!path,
+				hash: hash1
+			};
+			requests.set(state[id], request);
+		}
+		return request;
+	});
+}
+function assertCurrentLoaderRequest(ctx, signal, request, abortSignal) {
+	abortSignal.throwIfAborted();
+	if (!request.active || clientRouteLoaders.get(ctx)?.current.requests.get(signal) !== request) throw new DOMException(isDev ? "Route loader navigation was superseded" : "", "AbortError");
+}
 var getRouteLoaderValueStateKey = (loaderId) => `${ROUTE_LOADER_VALUE_PREFIX}${loaderId}`;
+var ServerRouteLoaderCapture = class {
+	hash;
+	qrl;
+	validators;
+	blockSSR;
+	requestEv;
+	constructor(hash2, qrl1, validators1, blockSSR1, requestEv1) {
+		this.hash = hash2;
+		this.qrl = qrl1;
+		this.validators = validators1;
+		this.blockSSR = blockSSR1;
+		this.requestEv = requestEv1;
+	}
+	load() {
+		const requestEv2 = this.requestEv;
+		if (!requestEv2) throw new Error("Unable to determine the current RequestEvent.");
+		const values = getRouteLoaderValues(requestEv2);
+		if (this.hash in values) return values[this.hash];
+		const ev = this.blockSSR ? requestEv2 : detachResponseFromEvent(requestEv2);
+		return loadRouteLoaderByQrl(this.hash, this.qrl, this.validators, ev);
+	}
+	[SerializerSymbol]() {
+		return this.hash;
+	}
+};
 var isRequestEvent = (value) => !!value && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, "sharedMap") && Object.prototype.hasOwnProperty.call(value, "cookie");
 var isLoaderInternal = (value) => typeof value === "function" && value.__brand === "server_loader";
 /**
 * Fetch a single loader's raw JSON response from the server.
 *
 * URL pattern: `{basePath}{routePath}/q-loader-{loaderId}.{manifestHash}.json`
-*/ var fetchRouteLoaderData = async (loaderId, routePath, manifestHash, opts) => {
+*/
+var fetchRouteLoaderData = async (loaderId, routePath, manifestHash, opts) => {
 	if (!routePath) return;
 	let resolvedPath = routePath;
 	const basePath = opts?.basePath ?? "/";
@@ -77,40 +224,120 @@ var isLoaderInternal = (value) => typeof value === "function" && value.__brand =
 		else if (isDev) headers[ROUTE_PATH_HEADER] = pageUrl.pathname;
 	}
 	const cacheKey = `${url}\n${headers["X-Qwik-fullpath"] ?? ""}`;
+	const cache = navFetchCache;
 	if (!opts?.ignoreCache) {
-		const entry = navFetchCache.get(cacheKey);
+		const entry = cache.get(cacheKey);
 		if (entry) return opts?.signal ? wrapWithAbort(entry, opts.signal) : entry;
 	}
 	const request = async () => {
+		opts?.signal?.throwIfAborted();
 		const response = await fetch(url, {
 			signal: opts?.signal,
 			cache: opts?.ignoreCache ? "reload" : "default",
 			headers
 		});
+		opts?.signal?.throwIfAborted();
 		if (response.redirected) return { r: response.url };
 		if (isRedirectStatus(response.status)) {
 			const location1 = response.headers.get("Location");
 			if (location1) return { r: location1 };
 		}
 		if (!response.ok) return;
-		return { raw: await response.text() };
+		const raw = await response.text();
+		opts?.signal?.throwIfAborted();
+		return { raw };
 	};
 	if (opts?.ignoreCache) return request();
 	if (opts?.signal) return request().then((value) => {
-		if (value !== void 0 && !navFetchCache.has(cacheKey)) navFetchCache.set(cacheKey, Promise.resolve(value));
+		opts.signal.throwIfAborted();
+		if (value !== void 0 && !cache.has(cacheKey)) cache.set(cacheKey, Promise.resolve(value));
 		return value;
 	});
 	const promise = request().then((value) => {
-		if (value === void 0) navFetchCache.delete(cacheKey);
+		if (value === void 0) cache.delete(cacheKey);
 		return value;
 	}, (err) => {
-		navFetchCache.delete(cacheKey);
+		cache.delete(cacheKey);
 		throw err;
 	});
-	navFetchCache.set(cacheKey, promise);
+	cache.set(cacheKey, promise);
 	return promise;
 };
-/** Build a sorted, stable search string from only the allowed param names. */ var filterSearchParams = (params, allowed) => {
+var createRouteLoaderSignal = (loader, routeLoaderCtx, state, requestEv3) => {
+	const id = loader.__id;
+	const stateValues = state;
+	const resumeValueKey = getRouteLoaderValueStateKey(id);
+	const capture = isServer ? new ServerRouteLoaderCapture(id, loader.__qrl, loader.__validators, loader.__blockSSR, requestEv3 ?? useServerData("qwikrouter")?.ev) : id;
+	const searchFilter = loader.__search;
+	const loaderHash = isDev ? loader.__qrl.getHash() : id;
+	const signal = createComputedQrl(/*#__PURE__*/ inlinedQrl(async (ctx) => {
+		let capture = _capturesObj._[0], id = _capturesObj._[1], lastFetch = _capturesObj._[2], loaderHash = _capturesObj._[3], resumeValueKey = _capturesObj._[4], routeLoaderCtx = _capturesObj._[5], searchFilter = _capturesObj._[6], state = _capturesObj._[7], stateValues = _capturesObj._[8];
+		if (!!ctx.info && typeof ctx.info === "object" && "__v" in ctx.info) {
+			const value = ctx.info.__v;
+			if (!isServer && resumeValueKey in stateValues) stateValues[resumeValueKey] = value;
+			lastFetch.raw = void 0;
+			return value;
+		}
+		if (isServer) return capture.load();
+		const request = getLoaderRequest(routeLoaderCtx, state, id, loaderHash);
+		if (!request.active) {
+			if (ctx.previous === void 0) return new Promise((_, reject) => {
+				ctx.abortSignal.throwIfAborted();
+				ctx.abortSignal.addEventListener("abort", () => reject(ctx.abortSignal.reason), { once: true });
+			});
+			return ctx.previous;
+		}
+		const pageUrl = new URL(request.pageUrl);
+		const mHash = untrack(() => routeLoaderCtx.manifestHash) || "dev";
+		const basePath = getBasePathname();
+		const needsResumeFetch = stateValues[resumeValueKey] === _UNINITIALIZED;
+		let fetchUrl = pageUrl;
+		if (searchFilter) {
+			fetchUrl = new URL(pageUrl.href);
+			fetchUrl.search = filterSearchParams(pageUrl.searchParams, searchFilter);
+		}
+		const result = await fetchRouteLoaderData(id, request.routePath, mHash, {
+			pageUrl: fetchUrl,
+			basePath,
+			ignoreCache: ctx.info === true,
+			signal: ctx.abortSignal
+		});
+		assertCurrentLoaderRequest(routeLoaderCtx, state[id], request, ctx.abortSignal);
+		if (!result) throw new Error(`Loader ${id} returned empty response`);
+		let response;
+		if (result.raw === void 0) response = result;
+		else {
+			if (result.raw === lastFetch.raw && ctx.previous !== void 0) return ctx.previous;
+			response = await _deserialize(result.raw);
+			if (!response) throw new Error(`Loader ${id} returned empty response`);
+		}
+		assertCurrentLoaderRequest(routeLoaderCtx, state[id], request, ctx.abortSignal);
+		if (response.r) {
+			const goto = routeLoaderCtx.goto;
+			if (goto) goto(response.r, { replaceState: true });
+			else location.href = response.r;
+			return ctx.previous;
+		}
+		if (response.e) throw response.e;
+		lastFetch.raw = result.raw;
+		if (needsResumeFetch) stateValues[resumeValueKey] = response.d;
+		return response.d;
+	}, "createRouteLoaderSignal_signal_createComputed_4s4ZDCYhDOA", [
+		capture,
+		id,
+		{},
+		loaderHash,
+		resumeValueKey,
+		routeLoaderCtx,
+		searchFilter,
+		state,
+		stateValues
+	]), { serializationStrategy: loader.__serializationStrategy });
+	_markSignalAsExternallyOwned(signal);
+	return signal;
+};
+/** Build a sorted, stable search string from only the allowed param names. */
+var filterSearchParams = (params, allowed) => {
 	const filtered = new URLSearchParams();
 	for (let i = 0; i < allowed.length; i++) {
 		const name = allowed[i];
@@ -120,23 +347,23 @@ var isLoaderInternal = (value) => typeof value === "function" && value.__brand =
 	filtered.sort();
 	return filtered.toString() ? `?${filtered.toString()}` : "";
 };
-var getLoaderOptions = (rest) => {
+function getLoaderOptions(rest) {
 	let id;
-	let serializationStrategy = DEFAULT_LOADERS_SERIALIZATION_STRATEGY;
+	let serializationStrategy = DEFAULT_LOADERS_SERIALIZATION_STRATEGY();
 	let cacheControl;
 	let eTag;
 	let cacheKey;
 	let search;
-	let blockSSR = true;
-	const validators = [];
+	let blockSSR2 = true;
+	const validators2 = [];
 	if (rest.length === 1) {
 		const options = rest[0];
 		if (options && typeof options === "object") {
-			if ("validate" in options) validators.push(options);
+			if ("validate" in options) validators2.push(options);
 			else {
 				if (options.id) id = options.id;
 				if (options.serializationStrategy) serializationStrategy = options.serializationStrategy;
-				if (options.validation) validators.push(...options.validation);
+				if (options.validation) validators2.push(...options.validation);
 				if ("cacheControl" in options) cacheControl = options.cacheControl;
 				if ("eTag" in options) eTag = options.eTag;
 				if ("cacheKey" in options) cacheKey = options.cacheKey;
@@ -144,77 +371,84 @@ var getLoaderOptions = (rest) => {
 				else if (globalThis.__STRICT_LOADERS__) search = [];
 				if (options.blockSSR === false) {
 					if (!__EXPERIMENTAL__.blockSSR) throw new Error("`blockSSR: false` is an experimental feature and is not enabled. Please enable the feature flag by adding `experimental: [\"blockSSR\"]` to your qwikVite plugin options.");
-					blockSSR = false;
+					blockSSR2 = false;
 				}
 			}
 		}
-	} else if (rest.length > 1) validators.push(...rest.filter(Boolean));
+	} else if (rest.length > 1) validators2.push(...rest.filter(Boolean));
 	return {
 		id,
-		validators: validators.reverse(),
+		validators: validators2.reverse(),
 		serializationStrategy,
 		cacheControl,
 		eTag,
 		cacheKey,
 		search,
-		blockSSR
+		blockSSR: blockSSR2
 	};
-};
+}
 /**
 * Returns the current RequestEvent if possible. Only usable on the server, and only during request
 * processing.
 *
 * @public
-*/ var getRequestEvent = (thisArg) => {
+*/
+var getRequestEvent = (thisArg) => {
 	if (!isServer) throw new Error("getRequestEvent() can only be used on the server.");
-	return _asyncRequestStore?.getStore() || [thisArg, _getContextEvent()].find(isRequestEvent);
+	return _asyncRequestStore?.getStore() ?? (isRequestEvent(thisArg) ? thisArg : void 0);
 };
 var REQUEST_ROUTE_LOADER_VALUES = "@routeLoaderValues";
-/** Get/create the record of pre-loaded loader values (used by middleware before component). */ function getRouteLoaderValues(requestEv) {
-	let values = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_VALUES);
+/** Get/create the record of pre-loaded loader values (used by middleware before component). */
+function getRouteLoaderValues(requestEv5) {
+	let values = requestEv5.sharedMap.get(REQUEST_ROUTE_LOADER_VALUES);
 	if (!values) {
 		values = {};
-		requestEv.sharedMap.set(REQUEST_ROUTE_LOADER_VALUES, values);
+		requestEv5.sharedMap.set(REQUEST_ROUTE_LOADER_VALUES, values);
 	}
 	return values;
 }
-function getRouteLoaderPromises(requestEv) {
-	let promises = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_PROMISES);
+function getRouteLoaderPromises(requestEv6) {
+	let promises = requestEv6.sharedMap.get(REQUEST_ROUTE_LOADER_PROMISES);
 	if (!promises) {
 		promises = {};
-		requestEv.sharedMap.set(REQUEST_ROUTE_LOADER_PROMISES, promises);
+		requestEv6.sharedMap.set(REQUEST_ROUTE_LOADER_PROMISES, promises);
 	}
 	return promises;
 }
-/** Clear loader state before rendering a route-independent error boundary. */ function clearRouteLoaderData(requestEv) {
-	requestEv.sharedMap.delete(REQUEST_ROUTE_LOADER_STATE);
-	requestEv.sharedMap.delete(REQUEST_ROUTE_LOADER_VALUES);
-	requestEv.sharedMap.delete(REQUEST_ROUTE_LOADER_PROMISES);
-	requestEv.sharedMap.delete(REQUEST_ROUTE_LOADER_EVENTS);
-	requestEv.sharedMap.delete(REQUEST_ROUTE_LOADER_ROOT_EVENT);
-	requestEv.sharedMap.delete(REQUEST_ROUTE_LOADERS);
+/** Clear loader state before rendering a route-independent error boundary. */
+function clearRouteLoaderData(requestEv7) {
+	requestEv7.sharedMap.delete(REQUEST_ROUTE_LOADER_STATE);
+	requestEv7.sharedMap.delete(REQUEST_ROUTE_LOADER_VALUES);
+	requestEv7.sharedMap.delete(REQUEST_ROUTE_LOADER_PROMISES);
+	requestEv7.sharedMap.delete(REQUEST_ROUTE_LOADER_EVENTS);
+	requestEv7.sharedMap.delete(REQUEST_ROUTE_LOADER_ROOT_EVENT);
+	requestEv7.sharedMap.delete(REQUEST_ROUTE_LOADERS);
 }
-/** Store the route loader internals on the request for SSG to read. */ function setRouteLoaders(requestEv, loaders) {
-	requestEv.sharedMap.set(REQUEST_ROUTE_LOADERS, loaders);
+/** Store the route loader internals on the request for SSG to read. */
+function setRouteLoaders(requestEv8, loaders) {
+	requestEv8.sharedMap.set(REQUEST_ROUTE_LOADERS, loaders);
 }
-/** Get the route loader internals stored on the request. */ function getRouteLoaders(requestEv) {
-	return requestEv.sharedMap.get(REQUEST_ROUTE_LOADERS) ?? [];
+/** Get the route loader internals stored on the request. */
+function getRouteLoaders(requestEv9) {
+	return requestEv9.sharedMap.get(REQUEST_ROUTE_LOADERS) ?? [];
 }
-function getRouteLoaderCtx(requestEv) {
-	let ctx = requestEv.sharedMap.get(REQUEST_LOADER_PATHS_STORE);
+function getRouteLoaderCtx(requestEv10) {
+	let ctx = requestEv10.sharedMap.get(REQUEST_LOADER_PATHS_STORE);
 	if (!ctx) {
 		ctx = { loaderPaths: {} };
-		requestEv.sharedMap.set(REQUEST_LOADER_PATHS_STORE, ctx);
+		requestEv10.sharedMap.set(REQUEST_LOADER_PATHS_STORE, ctx);
 	}
 	return ctx;
 }
-/** Update route loader matching state on navigation. */ var updateRouteLoaderPaths = (ctx, loaderPaths, pageUrl) => {
-	if (!isServer) {
-		ctx.pagePathname = pageUrl.pathname;
-		ctx.pageSearch = pageUrl.search;
-		ctx.routeLoaderCandidates = loaderPaths;
-	} else if (loaderPaths) for (const key in loaderPaths) ctx.loaderPaths[key] = loaderPaths[key];
-};
+/** Server-only loader ID → params matched at its loader path; never serialized to the client. */
+function getRouteLoaderParams(requestEv11) {
+	let params = requestEv11.sharedMap.get(REQUEST_LOADER_PARAMS_STORE);
+	if (!params) {
+		params = {};
+		requestEv11.sharedMap.set(REQUEST_LOADER_PARAMS_STORE, params);
+	}
+	return params;
+}
 var getModuleRouteLoaders = (mods) => {
 	const routeLoaders = [];
 	const seen = /* @__PURE__ */ new Map();
@@ -238,22 +472,109 @@ var getModuleRouteLoaders = (mods) => {
 };
 /**
 * Loader ids declared `cacheControl: 'immutable'`. Their data cannot change until a rebuild, so
-* nav-wide invalidation skips them; they still re-fetch when their tracked URL inputs change.
-* Registered on every nav via ensureRouteLoaderSignal, so resumed signals are covered too.
-*/ var immutableLoaderIds = /* @__PURE__ */ new Set();
+* navigation skips them unless their request inputs change. Registered on every nav via
+* ensureRouteLoaderSignal, so resumed signals are covered too.
+*/
+var immutableLoaderIds = /* @__PURE__ */ new Set();
 var isImmutableLoader = (loaderId) => immutableLoaderIds.has(loaderId);
-/**
-* Invalidate every loader signal on navigation: the browser HTTP cache (driven by each loader's
-* cacheControl) decides freshness. Unsubscribed signals only mark stale and refetch lazily when
-* read again. Immutable loaders are skipped — their data cannot change until a rebuild; tracked URL
-* inputs still invalidate them.
-*/ var invalidateNavRouteLoaders = (state) => {
-	for (const id in state) if (!id.startsWith(ROUTE_LOADER_VALUE_PREFIX) && !immutableLoaderIds.has(id)) state[id].invalidate();
+function abortRouteLoaderNavigation(ctx) {
+	for (const [signal, request] of clientRouteLoaders.get(ctx)?.current.requests ?? []) {
+		if (signal.untrackedPending) request.isAborted = true;
+		signal.abort();
+	}
+}
+/** Search-filtered loaders ignore changes to unlisted params. */
+function hasSameListedSearch(previous, next, search) {
+	return !!search && previous.pathname === next.pathname && filterSearchParams(previous.searchParams, search) === filterSearchParams(next.searchParams, search);
+}
+function prepareRouteLoaders(mods, state, ctx, paths, pageUrl, previousUrl, navCount, forceIds, navigationKey) {
+	const client = getClientRouteLoaders(ctx, previousUrl.href);
+	if (navigationKey && client.navigationKey === navigationKey) return ensureRouteLoaderSignals(mods, state, ctx);
+	const previous = client.current;
+	if (client.navCount === void 0) {
+		for (const id in state) if (!id.startsWith(ROUTE_LOADER_VALUE_PREFIX)) getLoaderRequest(ctx, state, id, id);
+	}
+	client.navCount = navCount;
+	client.navigationKey = navigationKey;
+	const current = client.current = {
+		requests: /* @__PURE__ */ new Map(),
+		paths: { ...paths },
+		pageUrl: pageUrl.href
+	};
+	const loaders = ensureRouteLoaderSignals(mods, state, ctx);
+	const routeLoaders = /* @__PURE__ */ new Map();
+	for (const loader of loaders) {
+		routeLoaders.set(loader.__id, loader);
+		current.paths[loader.__id] ||= current.paths[loader.__qrl.getHash()] || pageUrl.pathname;
+	}
+	for (const id in state) {
+		if (id.startsWith(ROUTE_LOADER_VALUE_PREFIX)) continue;
+		const signal = state[id];
+		const old = previous.requests.get(signal);
+		const loader = routeLoaders.get(id);
+		const hash3 = loader?.__qrl.getHash() || old?.hash;
+		const routePath = current.paths[id] || hash3 && current.paths[hash3];
+		if (!routePath) {
+			if (old) current.requests.set(signal, {
+				...old,
+				active: false
+			});
+			signal.abort();
+			continue;
+		}
+		const keepRequest = old?.active && !old.isAborted && old.routePath === routePath && (old.pageUrl === pageUrl.href ? isImmutableLoader(id) : hasSameListedSearch(new URL(old.pageUrl), pageUrl, loader?.__search));
+		current.requests.set(signal, keepRequest ? old : {
+			routePath,
+			pageUrl: pageUrl.href,
+			active: true,
+			hash: hash3
+		});
+		ctx.loaderPaths[id] = routePath;
+		if (forceIds === null || forceIds?.some((value) => value === id || value === hash3)) signal.invalidate(true);
+		else if (old && !keepRequest) signal.invalidate();
+	}
+	return loaders;
+}
+function pruneRouteLoaders(state, ctx) {
+	const { requests } = clientRouteLoaders.get(ctx).current;
+	const paths = {};
+	for (const id in state) {
+		if (id.startsWith(ROUTE_LOADER_VALUE_PREFIX)) continue;
+		const signal = state[id];
+		const request = requests.get(signal);
+		if (request?.active) paths[id] = request.routePath;
+		else {
+			signal.$dispose();
+			requests.delete(signal);
+			delete state[id];
+			delete state[getRouteLoaderValueStateKey(id)];
+		}
+	}
+	ctx.loaderPaths = paths;
+}
+function commitRouteLoaders(state, ctx, navCount) {
+	const client = clientRouteLoaders.get(ctx);
+	if (!client || client.navCount !== navCount) return;
+	pruneRouteLoaders(state, ctx);
+	client.committed = client.current;
+}
+function restoreRouteLoaders(state, ctx, navCount) {
+	const client = clientRouteLoaders.get(ctx);
+	if (!client || client.navCount !== navCount) return;
+	client.navigationKey = void 0;
+	client.current = client.committed;
+	pruneRouteLoaders(state, ctx);
+	for (const signal of client.current.requests.keys()) signal.invalidate();
+}
+var ensureRouteLoaderSignal = (loader, state, routeLoaderCtx, requestEv12) => {
+	if (loader.__cacheControl === "immutable") immutableLoaderIds.add(loader.__id);
+	if (isServer && loader.__serializationStrategy === "never") state[getRouteLoaderValueStateKey(loader.__id)] = _UNINITIALIZED;
+	return state[loader.__id] ||= createRouteLoaderSignal(loader, routeLoaderCtx, state, requestEv12);
 };
-var applyClientRouteLoaderPath = (loaderId, ctx) => {
-	const currentPath = ctx.routeLoaderCandidates?.[loaderId];
-	if (currentPath) ctx.loaderPaths[loaderId] = currentPath;
-	else if (isDev && ctx.pagePathname) ctx.loaderPaths[loaderId] = ctx.pagePathname;
+var ensureRouteLoaderSignals = (mods, state, routeLoaderCtx, requestEv13) => {
+	const loaders = getModuleRouteLoaders(mods);
+	for (let i = 0; i < loaders.length; i++) ensureRouteLoaderSignal(loaders[i], state, routeLoaderCtx, requestEv13);
+	return loaders;
 };
 /**
 * Inject a pre-loaded value into a ComputedSignal while preserving subscriptions. Delegates to the
@@ -261,25 +582,56 @@ var applyClientRouteLoaderPath = (loaderId, ctx) => {
 * synchronously and returns the pre-loaded value without fetching. Must go through the core helper
 * because `$computeIfNeeded$` is mangled in core builds and not directly callable from this
 * package.
-*/ var setLoaderSignalValue = (signal, value) => {
+*/
+var setLoaderSignalValue = (signal, value) => {
 	_injectAsyncSignalValue(signal, value);
 };
+var resolveRouteLoaderByHash = (routeLoaders, loaderId) => {
+	return routeLoaders.find((loader) => matchesRouteLoaderId(loader, loaderId));
+};
 var matchesRouteLoaderId = (loader, loaderId) => {
 	return typeof loaderId === "string" && (loader.__id === loaderId || isDev && loader.__qrl.getHash() === loaderId);
 };
-var resolveRouteLoaderByHash = (routeLoaders, loaderId) => {
-	return routeLoaders.find((loader) => matchesRouteLoaderId(loader, loaderId));
+/** Run a loader and return its raw value. Errors/redirects propagate as exceptions. */
+var getRouteLoaderData = async (loaderQrl, validators3, requestEv14) => {
+	const loaderRequestEv = requestEv14;
+	const result = await runValidators(requestEv14, validators3, void 0);
+	if (!result.success) return loaderRequestEv.fail(result.status ?? 500, result.error);
+	const resolved = await loaderQrl.call(loaderRequestEv, loaderRequestEv);
+	const value = typeof resolved === "function" ? resolved() : resolved;
+	throwIfControlFlowSignal(value);
+	if (isDev) verifySerializable(value, loaderQrl);
+	return value;
 };
-/** @internal */ var getLoaderRequestEvent = (loader, requestEv) => {
-	let rootRequestEv = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_ROOT_EVENT);
+var loadRouteLoaderByQrl = (loaderId, loaderQrl, validators4, requestEv15) => {
+	const values = getRouteLoaderValues(requestEv15);
+	if (loaderId in values) return Promise.resolve(values[loaderId]);
+	const promises = getRouteLoaderPromises(requestEv15);
+	let promise = promises[loaderId];
+	if (!promise) {
+		promise = getRouteLoaderData(loaderQrl, validators4, requestEv15).then((value) => {
+			values[loaderId] = value;
+			return value;
+		}, (err) => {
+			delete promises[loaderId];
+			throw err;
+		});
+		promises[loaderId] = promise;
+	}
+	return promise;
+};
+/** @internal */
+var getLoaderRequestEvent = (loader, requestEv16) => {
+	let rootRequestEv = requestEv16.sharedMap.get(REQUEST_ROUTE_LOADER_ROOT_EVENT);
 	if (!rootRequestEv) {
-		rootRequestEv = requestEv;
-		requestEv.sharedMap.set(REQUEST_ROUTE_LOADER_ROOT_EVENT, rootRequestEv);
+		rootRequestEv = requestEv16;
+		requestEv16.sharedMap.set(REQUEST_ROUTE_LOADER_ROOT_EVENT, rootRequestEv);
 	}
 	const url = new URL(rootRequestEv.url);
 	const pathname = globalThis.__STRICT_LOADERS__ ? getRouteLoaderCtx(rootRequestEv).loaderPaths[loader.__id] || rootRequestEv.url.pathname : rootRequestEv.url.pathname;
 	const filteredSearch = loader.__search ? filterSearchParams(url.searchParams, loader.__search) : rootRequestEv.url.search;
 	if (pathname === rootRequestEv.url.pathname && filteredSearch === rootRequestEv.url.search) return rootRequestEv;
+	const params = pathname === rootRequestEv.url.pathname ? rootRequestEv.params : getRouteLoaderParams(rootRequestEv)[loader.__id] || {};
 	let events = rootRequestEv.sharedMap.get(REQUEST_ROUTE_LOADER_EVENTS);
 	if (!events) {
 		events = /* @__PURE__ */ new Map();
@@ -297,7 +649,7 @@ var resolveRouteLoaderByHash = (routeLoaders, loaderId) => {
 				enumerable: true
 			},
 			params: {
-				value: rootRequestEv.params,
+				value: params,
 				enumerable: true
 			},
 			pathname: {
@@ -326,10 +678,11 @@ var resolveRouteLoaderByHash = (routeLoaders, loaderId) => {
 * are captured locally, so a background (`blockSSR: false`) loader's status/redirect/error surfaces
 * on its own signal instead of mutating the page response. The originals also call `check()`, which
 * throws once SSR streaming has started — a background loader must fail on its signal, not crash.
-*/ var detachResponseFromEvent = (requestEv) => {
+*/
+var detachResponseFromEvent = (requestEv17) => {
 	let status = 200;
 	const headers = new Headers();
-	return Object.create(requestEv, {
+	return Object.create(requestEv17, {
 		headers: {
 			value: headers,
 			enumerable: true
@@ -372,174 +725,33 @@ var resolveRouteLoaderByHash = (routeLoaders, loaderId) => {
 		}
 	});
 };
-async function runValidators(requestEv, validators, data) {
-	let lastResult = {
-		success: true,
-		data
-	};
-	if (validators) for (let i = 0; i < validators.length; i++) {
-		lastResult = await validators[i].validate(requestEv, data);
-		if (!lastResult.success) return lastResult;
-		data = lastResult.data;
-	}
-	return lastResult;
-}
-function verifySerializable(data, qrl) {
-	try {
-		_verifySerializable(data, void 0);
-	} catch (error) {
-		if (error instanceof Error && qrl.dev) error.loc = qrl.dev;
-		throw error;
-	}
-}
-/** Run a loader and return its raw value. Errors/redirects propagate as exceptions. */ var getRouteLoaderData = async (loaderQrl, validators, requestEv) => {
-	const loaderRequestEv = requestEv;
-	const result = await runValidators(requestEv, validators, void 0);
-	if (!result.success) return loaderRequestEv.fail(result.status ?? 500, result.error);
-	const resolved = await loaderQrl.call(loaderRequestEv, loaderRequestEv);
-	const value = typeof resolved === "function" ? resolved() : resolved;
-	throwIfControlFlowSignal(value);
-	if (isDev) verifySerializable(value, loaderQrl);
-	return value;
-};
-var loadRouteLoaderByQrl = (loaderId, loaderQrl, validators, requestEv) => {
-	const values = getRouteLoaderValues(requestEv);
-	if (loaderId in values) return Promise.resolve(values[loaderId]);
-	const promises = getRouteLoaderPromises(requestEv);
-	let promise = promises[loaderId];
-	if (!promise) {
-		promise = getRouteLoaderData(loaderQrl, validators, requestEv).then((value) => {
-			values[loaderId] = value;
-			return value;
-		}, (err) => {
-			delete promises[loaderId];
-			throw err;
-		});
-		promises[loaderId] = promise;
-	}
-	return promise;
-};
-var ServerRouteLoaderCapture = class {
-	hash;
-	qrl;
-	validators;
-	blockSSR;
-	constructor(hash, qrl, validators, blockSSR) {
-		this.hash = hash;
-		this.qrl = qrl;
-		this.validators = validators;
-		this.blockSSR = blockSSR;
-	}
-	load() {
-		const requestEv = getRequestEvent();
-		if (!requestEv) throw new Error("Unable to determine the current RequestEvent.");
-		const values = getRouteLoaderValues(requestEv);
-		if (this.hash in values) return values[this.hash];
-		const ev = this.blockSSR ? requestEv : detachResponseFromEvent(requestEv);
-		return loadRouteLoaderByQrl(this.hash, this.qrl, this.validators, ev);
-	}
-	[SerializerSymbol]() {
-		return this.hash;
-	}
-};
-var createRouteLoaderSignal = (loader, routeLoaderCtx, state) => {
-	const id = loader.__id;
-	const stateValues = state;
-	const resumeValueKey = getRouteLoaderValueStateKey(id);
-	const capture = isServer ? new ServerRouteLoaderCapture(id, loader.__qrl, loader.__validators, loader.__blockSSR) : id;
-	const searchFilter = loader.__search;
-	const signal = createComputedQrl(/*#__PURE__*/ inlinedQrl(async (ctx) => {
-		const capture = _captures[0], id = _captures[1], lastFetch = _captures[2], resumeValueKey = _captures[3], routeLoaderCtx = _captures[4], searchFilter = _captures[5], stateValues = _captures[6];
-		const hasInjectedValue = !!ctx.info && typeof ctx.info === "object" && "__v" in ctx.info;
-		const trackedRoutePath = ctx.track(routeLoaderCtx.loaderPaths, id);
-		const trackedPagePathname = ctx.track(routeLoaderCtx, "pagePathname");
-		const trackedPageSearch = ctx.track(routeLoaderCtx, "pageSearch");
-		if (hasInjectedValue) {
-			const value = ctx.info.__v;
-			if (!isServer && resumeValueKey in stateValues) stateValues[resumeValueKey] = value;
-			lastFetch.raw = void 0;
-			return value;
-		}
-		if (isServer) return capture.load();
-		const pagePathname = trackedPagePathname || location.pathname;
-		const pageSearch = trackedPageSearch || location.search;
-		const pageUrl = new URL(pagePathname + pageSearch, location.href);
-		const mHash = routeLoaderCtx.manifestHash || "dev";
-		const basePath = qwikRouterConfig.basePathname ?? "/";
-		const needsResumeFetch = stateValues[resumeValueKey] === _UNINITIALIZED;
-		const fetchRoutePath = trackedRoutePath || (needsResumeFetch ? pageUrl.pathname : void 0);
-		if (!fetchRoutePath) return ctx.previous;
-		let fetchUrl = pageUrl;
-		if (searchFilter) {
-			fetchUrl = new URL(pageUrl.href);
-			fetchUrl.search = filterSearchParams(pageUrl.searchParams, searchFilter);
-		}
-		const result = await fetchRouteLoaderData(id, fetchRoutePath, mHash, {
-			pageUrl: fetchUrl,
-			basePath,
-			ignoreCache: ctx.info === true,
-			signal: ctx.abortSignal
-		});
-		if (!result) throw new Error(`Loader ${id} returned empty response`);
-		let response;
-		if (result.raw === void 0) response = result;
-		else {
-			if (result.raw === lastFetch.raw && ctx.previous !== void 0) return ctx.previous;
-			response = await _deserialize(result.raw);
-			if (!response) throw new Error(`Loader ${id} returned empty response`);
-		}
-		if (response.r) {
-			const goto = routeLoaderCtx.goto;
-			if (goto) goto(response.r, { replaceState: true });
-			else location.href = response.r;
-			return ctx.previous;
-		}
-		if (response.e) throw response.e;
-		lastFetch.raw = result.raw;
-		if (needsResumeFetch) stateValues[resumeValueKey] = response.d;
-		return response.d;
-	}, "createRouteLoaderSignal_signal_createComputed_4s4ZDCYhDOA", [
-		capture,
-		id,
-		{},
-		resumeValueKey,
-		routeLoaderCtx,
-		searchFilter,
-		stateValues
-	]), { serializationStrategy: loader.__serializationStrategy });
-	_markSignalAsExternallyOwned(signal);
-	return signal;
-};
-var ensureRouteLoaderSignal = (loader, state, routeLoaderCtx) => {
-	if (!isServer && routeLoaderCtx.pagePathname) applyClientRouteLoaderPath(loader.__id, routeLoaderCtx);
-	if (loader.__cacheControl === "immutable") immutableLoaderIds.add(loader.__id);
-	if (isServer && loader.__serializationStrategy === "never") state[getRouteLoaderValueStateKey(loader.__id)] = _UNINITIALIZED;
-	return state[loader.__id] ||= createRouteLoaderSignal(loader, routeLoaderCtx, state);
-};
-var ensureRouteLoaderSignals = (mods, state, routeLoaderCtx) => {
-	const loaders = getModuleRouteLoaders(mods);
-	for (let i = 0; i < loaders.length; i++) ensureRouteLoaderSignal(loaders[i], state, routeLoaderCtx);
-	return loaders;
-};
-var loadRouteLoader = (loader, requestEv) => {
-	const loaderEv = getLoaderRequestEvent(loader, requestEv);
+var loadRouteLoader = (loader, requestEv18) => {
+	const loaderEv = getLoaderRequestEvent(loader, requestEv18);
 	return loadRouteLoaderByQrl(loader.__id, loader.__qrl, loader.__validators, loader.__blockSSR ? loaderEv : detachResponseFromEvent(loaderEv));
 };
-/** Run a loader and wrap the result in a LoaderResponse envelope. Catches redirects/errors. */ var getRouteLoaderResponse = async (loaderQrl, validators, requestEv) => {
+/** Run a loader and wrap the result in a LoaderResponse envelope. Catches redirects/errors. */
+var getRouteLoaderResponse = async (loaderQrl, validators5, requestEv19) => {
 	try {
-		return { d: await getRouteLoaderData(loaderQrl, validators, requestEv) };
+		return { d: await getRouteLoaderData(loaderQrl, validators5, requestEv19) };
 	} catch (err) {
 		if (err instanceof RedirectMessage) {
-			const location1 = requestEv.headers.get("Location") || "/";
-			requestEv.headers.delete("Location");
-			return { r: location1 };
+			const location2 = requestEv19.headers.get("Location") || "/";
+			requestEv19.headers.delete("Location");
+			return { r: location2 };
 		}
 		if (err instanceof ServerError) return { e: err };
 		throw err;
 	}
 };
-/** @internal */ var routeLoaderQrl = (loaderQrl, ...rest) => {
-	const { id, validators, serializationStrategy, cacheControl, eTag, cacheKey, search, blockSSR } = getLoaderOptions(rest);
+/**
+* A hoisted function declaration on purpose: the app's route modules call `routeLoaderQrl` at their
+* own eval, and a bundle may execute them before this module, where a `const` binding would throw a
+* TDZ ReferenceError.
+*
+* @internal
+*/
+function routeLoaderQrl(loaderQrl, ...rest) {
+	const { id, validators: validators6, serializationStrategy, cacheControl, eTag, cacheKey, search, blockSSR: blockSSR3 } = getLoaderOptions(rest);
 	function loader() {
 		const signal = ensureRouteLoaderSignal(loader, _resolveContextWithoutSequentialScope(RouteStateContext), _resolveContextWithoutSequentialScope(RouteLoaderCtxContext));
 		signal.promise();
@@ -547,17 +759,17 @@ var loadRouteLoader = (loader, requestEv) => {
 	}
 	loader.__brand = "server_loader";
 	loader.__qrl = loaderQrl;
-	loader.__validators = validators;
+	loader.__validators = validators6;
 	loader.__id = id ?? loaderQrl.getHash();
 	loader.__serializationStrategy = serializationStrategy;
 	loader.__cacheControl = cacheControl;
 	loader.__eTag = eTag;
 	loader.__cacheKey = cacheKey;
 	loader.__search = search;
-	loader.__blockSSR = blockSSR;
+	loader.__blockSSR = blockSSR3;
 	Object.freeze(loader);
 	return loader;
-};
+}
 /**
 * Define a route loader that fetches data before the route renders.
 *
@@ -584,7 +796,28 @@ var loadRouteLoader = (loader, requestEv) => {
 * specify an explicit `search` option.
 *
 * @public
-*/ var routeLoader$ = /*#__PURE__*/ implicit$FirstArg(routeLoaderQrl);
+*/
+var routeLoader$ = /*#__PURE__*/ implicit$FirstArg(routeLoaderQrl);
+async function runValidators(requestEv20, validators7, data) {
+	let lastResult = {
+		success: true,
+		data
+	};
+	if (validators7) for (let i = 0; i < validators7.length; i++) {
+		lastResult = await validators7[i].validate(requestEv20, data);
+		if (!lastResult.success) return lastResult;
+		data = lastResult.data;
+	}
+	return lastResult;
+}
+function verifySerializable(data, qrl2) {
+	try {
+		_verifySerializable(data, void 0);
+	} catch (error) {
+		if (error instanceof Error && qrl2.dev) error.loc = qrl2.dev;
+		throw error;
+	}
+}
 var deepFreeze = (obj) => {
 	if (obj == null) return obj;
 	Object.getOwnPropertyNames(obj).forEach((prop) => {
@@ -597,52 +830,119 @@ var deepFreeze = (obj) => {
 	});
 	return Object.freeze(obj);
 };
-/** LoadRoute() runs in both client and server. */ var MODULE_CACHE = /*#__PURE__*/ new WeakMap();
-/** Built-in fallback error component loader */ var httpErrorLoader = () => import("./http-error.qwik.mjs");
-/**
-* Walk trie keys from root, gathering `_L` layouts along the way. Returns the final node and
-* collected layouts, or undefined if any key is missing.
-*/ function walkTrieKeys(root, keys) {
+/** LoadRoute() runs in both client and server. */
+var MODULE_CACHE = /*#__PURE__*/ new WeakMap();
+var loadRoute = async (routes, cacheModules, pathname) => {
+	const { loaders, params, routeParts, notFound, routeBundleNames, loaderPathsByHash, loaderParamsByHash, menuLoader, errorLoader } = matchRouteTree(routes, pathname);
+	const routeName = "/" + routeParts.join("/");
+	const modules = new Array(loaders.length);
+	const pendingLoads = [];
+	for (let i = 0; i < loaders.length; i++) {
+		const moduleLoader = loaders[i];
+		loadModule(moduleLoader, pendingLoads, (routeModule) => modules[i] = routeModule, cacheModules);
+	}
+	let menu = void 0;
+	loadModule(menuLoader, pendingLoads, (menuModule) => menu = menuModule?.default, cacheModules);
+	if (pendingLoads.length > 0) await Promise.all(pendingLoads);
+	return {
+		$routeName$: routeName,
+		$params$: params,
+		$mods$: modules,
+		$menu$: deepFreeze(menu),
+		$routeBundleNames$: routeBundleNames,
+		$notFound$: notFound,
+		$errorLoader$: errorLoader,
+		$loaders$: loaderPathsByHash && Object.keys(loaderPathsByHash),
+		$loaderPaths$: loaderPathsByHash,
+		$loaderParams$: loaderParamsByHash
+	};
+};
+/** Built-in fallback error component loader */
+var httpErrorLoader = (() => import("./http-error.qwik.mjs"));
+/** Collect the rewrite target's layouts, loader endpoint paths, and params at those paths. */
+function walkTrieKeys(root, keys, params) {
 	let node = root;
+	let pathname = "/";
+	let pathParams = {};
 	const layouts = [];
-	if (node._L) layouts.push(node._L);
-	for (let i = 0; i < keys.length; i++) {
-		const key = keys[i];
-		let next = node[key];
-		if (!next && node._M) for (let j = 0; j < node._M.length; j++) {
-			const group = node._M[j];
-			next = group[key];
-			if (next) {
-				if (group._L) layouts.push(group._L);
-				break;
-			}
-		}
-		if (!next) return;
-		node = next;
+	const loaderPaths = {};
+	const loaderParams = {};
+	const collect = (node) => {
 		if (node._L) layouts.push(node._L);
+		for (const hash of node._R ?? []) {
+			loaderPaths[hash] = pathname;
+			loaderParams[hash] = pathParams;
+		}
+	};
+	collect(root);
+	for (const key of keys) {
+		const match = descendGroups(node, (candidate) => candidate[key]);
+		if (!match) return;
+		for (const group of match.groups) collect(group);
+		node = match.value;
+		const segment = node._P ? `${node._0 ?? ""}${params[node._P] ?? ""}${node._9 ?? ""}` : unescapeStaticTrieKey(key);
+		const segments = key === "_A" ? segment.split("/") : [segment];
+		pathname = ensureSlash(pathname + segments.map(encodeURIComponent).join("/"));
+		if (node._P) pathParams = {
+			...pathParams,
+			[node._P]: params[node._P] ?? ""
+		};
+		collect(node);
+	}
+	if (!node._I && node._G == null) {
+		const index = findIndexNode(node);
+		if (index) {
+			for (const group of index.groups) collect(group);
+			node = index.target;
+			collect(node);
+		}
 	}
 	return {
 		node,
-		layouts
+		layouts,
+		loaderPaths,
+		loaderParams
+	};
+}
+/** Resolve the page and its modules, following rewrite targets. */
+function resolveLoaders(root, node, gatheredLayouts, params) {
+	if (node._G != null) {
+		const target = walkTrieKeys(root, node._G.split("/").filter((p) => p.length > 0), params);
+		if (!target) return;
+		const resolved = resolveLoaders(root, target.node, target.layouts, params);
+		if (resolved && !resolved.loaderPaths) {
+			resolved.loaderPaths = target.loaderPaths;
+			resolved.loaderParams = target.loaderParams;
+		}
+		return resolved;
+	}
+	const index = node._I;
+	if (!index) return;
+	if (Array.isArray(index)) return {
+		loaders: index,
+		node
+	};
+	return {
+		loaders: [...gatheredLayouts, index],
+		node
 	};
 }
 /**
 * The full chain to render for a boundary: a bare loader in its snapshot layouts, an override
 * as-is.
-*/ var boundaryChain = (ref) => ref.v ? Array.isArray(ref.v) ? ref.v : [...ref.layouts, ref.v] : void 0;
+*/
+var boundaryChain = (ref) => ref.v ? Array.isArray(ref.v) ? ref.v : [...ref.layouts, ref.v] : void 0;
 /**
 * Collect layouts, the nearest error (`_E`) and not-found (`_4`) boundaries, and the menu from a
 * node and the group ancestors entered to reach it.
-*/ function collectNodeMeta(node, groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, matchedPathname = "/") {
+*/
+function collectNodeMeta(node, groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderPathsByHash, matchedPathname = "/", loaderParamsByHash, matchedParams = {}) {
 	for (let j = 0; j < groups.length; j++) {
 		const g = groups[j];
 		if (g._L) layouts.push(g._L);
-		if (g._R && loaderHashes) {
-			loaderHashes.push(...g._R);
-			if (loaderPathsByHash) for (let i = 0; i < g._R.length; i++) {
-				const hash = g._R[i];
-				loaderPathsByHash[hash] = matchedPathname;
-			}
+		if (g._R && loaderPathsByHash) for (const hash of g._R) {
+			loaderPathsByHash[hash] = matchedPathname;
+			if (loaderParamsByHash) loaderParamsByHash[hash] = matchedParams;
 		}
 		if (g._E) {
 			errorLoaderRef.v = g._E;
@@ -655,12 +955,9 @@ var deepFreeze = (obj) => {
 		if (g._N) menuLoaderRef.v = g._N;
 	}
 	if (node._L) layouts.push(node._L);
-	if (node._R && loaderHashes) {
-		loaderHashes.push(...node._R);
-		if (loaderPathsByHash) for (let i = 0; i < node._R.length; i++) {
-			const hash = node._R[i];
-			loaderPathsByHash[hash] = matchedPathname;
-		}
+	if (node._R && loaderPathsByHash) for (const hash of node._R) {
+		loaderPathsByHash[hash] = matchedPathname;
+		if (loaderParamsByHash) loaderParamsByHash[hash] = matchedParams;
 	}
 	if (node._E) {
 		errorLoaderRef.v = node._E;
@@ -672,7 +969,45 @@ var deepFreeze = (obj) => {
 	}
 	if (node._N) menuLoaderRef.v = node._N;
 }
-/** Try to match a segment against a node's wildcard children (_W, _A). */ function tryWildcardMatch(node, part, partLower, parts, partIndex) {
+var ChildMatchKind = /* @__PURE__ */ function(ChildMatchKind) {
+	ChildMatchKind[ChildMatchKind["Exact"] = 0] = "Exact";
+	ChildMatchKind[ChildMatchKind["Wildcard"] = 1] = "Wildcard";
+	ChildMatchKind[ChildMatchKind["Rest"] = 2] = "Rest";
+	return ChildMatchKind;
+}(ChildMatchKind || {});
+/**
+* Try to find a child matching `partLower` in `node`, including inside group children (_M). Returns
+* the matched child node, the groups entered to reach it, what to push to routeParts, and which
+* kind of edge matched. Returns undefined if no match.
+*
+* Priority: exact match → _M groups (recursively) → _W wildcard → _A rest wildcard. This ensures
+* exact matches inside nested groups take precedence over wildcards at parent level.
+*/
+function findChild(node, part, partLower, parts, partIndex) {
+	const exact = node[escapeStaticTrieKey(partLower)];
+	if (exact) return {
+		next: exact,
+		groups: [],
+		routePart: part,
+		done: false,
+		kind: ChildMatchKind.Exact
+	};
+	if (node._M) for (let j = 0; j < node._M.length; j++) {
+		const group = node._M[j];
+		const groupResult = findChild(group, part, partLower, parts, partIndex);
+		if (groupResult) {
+			groupResult.groups.unshift(group);
+			return groupResult;
+		}
+	}
+	const wildcard = tryWildcardMatch(node, part, partLower, parts, partIndex);
+	if (wildcard) return {
+		...wildcard,
+		groups: []
+	};
+}
+/** Try to match a segment against a node's wildcard children (_W, _A). */
+function tryWildcardMatch(node, part, partLower, parts, partIndex) {
 	let next = node._W;
 	if (next) {
 		const prefix = next._0;
@@ -687,7 +1022,7 @@ var deepFreeze = (obj) => {
 					next,
 					routePart: `${pre}[${paramName}]${suf}`,
 					done: false,
-					kind: 1,
+					kind: ChildMatchKind.Wildcard,
 					paramName,
 					paramValue: value
 				};
@@ -698,7 +1033,7 @@ var deepFreeze = (obj) => {
 				next,
 				routePart: `[${paramName}]`,
 				done: false,
-				kind: 1,
+				kind: ChildMatchKind.Wildcard,
 				paramName,
 				paramValue: part
 			};
@@ -712,47 +1047,18 @@ var deepFreeze = (obj) => {
 			next,
 			routePart: `[...${paramName}]`,
 			done: true,
-			kind: 2,
+			kind: ChildMatchKind.Rest,
 			paramName,
 			paramValue: restValue
 		};
 	}
 }
 /**
-* Try to find a child matching `partLower` in `node`, including inside group children (_M). Returns
-* the matched child node, the groups entered to reach it, what to push to routeParts, and which
-* kind of edge matched. Returns undefined if no match.
-*
-* Priority: exact match → _M groups (recursively) → _W wildcard → _A rest wildcard. This ensures
-* exact matches inside nested groups take precedence over wildcards at parent level.
-*/ function findChild(node, part, partLower, parts, partIndex) {
-	const exact = node[partLower];
-	if (exact) return {
-		next: exact,
-		groups: [],
-		routePart: part,
-		done: false,
-		kind: 0
-	};
-	if (node._M) for (let j = 0; j < node._M.length; j++) {
-		const group = node._M[j];
-		const groupResult = findChild(group, part, partLower, parts, partIndex);
-		if (groupResult) {
-			groupResult.groups.unshift(group);
-			return groupResult;
-		}
-	}
-	const wildcard = tryWildcardMatch(node, part, partLower, parts, partIndex);
-	if (wildcard) return {
-		...wildcard,
-		groups: []
-	};
-}
-/**
 * Descend through a node and its pathless `_M` groups (depth-first, in `_M` order), returning the
 * first node for which `hit` yields a value, plus the chain of groups entered to reach it. The
 * shared traversal behind the index / rest / boundary lookups inside groups.
-*/ function descendGroups(node, hit) {
+*/
+function descendGroups(node, hit) {
 	const value = hit(node);
 	if (value !== void 0) return {
 		value,
@@ -772,7 +1078,8 @@ var deepFreeze = (obj) => {
 * Find a node with `_I`/`_G` at the current level, including inside `_M` groups. Returns it and the
 * groups entered to reach it — excluding the target itself, whose `_L` the caller applies (so it
 * isn't double-counted).
-*/ function findIndexNode(node) {
+*/
+function findIndexNode(node) {
 	const r = descendGroups(node, (n) => n._I || n._G != null ? n : void 0);
 	return r ? {
 		target: r.node,
@@ -780,39 +1087,10 @@ var deepFreeze = (obj) => {
 	} : void 0;
 }
 /**
-* Given a matched node that has `_I` or `_G`, resolve the final loaders array.
-*
-* - `_G`: re-walk from root to gather target's layouts and `_I`
-* - `_I` array: use as-is (override, e.g. layout stop)
-* - `_I` function: prepend gathered layouts
-*/ function resolveLoaders(root, node, gatheredLayouts) {
-	if (node._G != null) {
-		const target = walkTrieKeys(root, node._G.split("/").filter((p) => p.length > 0));
-		if (!target) return;
-		let targetNode = target.node;
-		const targetLayouts = target.layouts;
-		if (!targetNode._I && targetNode._G == null) {
-			const indexResult = findIndexNode(targetNode);
-			if (indexResult) {
-				for (let j = 0; j < indexResult.groups.length; j++) {
-					const g = indexResult.groups[j];
-					if (g._L) targetLayouts.push(g._L);
-				}
-				targetNode = indexResult.target;
-				if (targetNode._L) targetLayouts.push(targetNode._L);
-			}
-		}
-		return resolveLoaders(root, targetNode, targetLayouts);
-	}
-	const index = node._I;
-	if (!index) return;
-	if (Array.isArray(index)) return index;
-	return [...gatheredLayouts, index];
-}
-/**
 * Find a rest wildcard (`_A`) at the current node or inside its `_M` groups, with the groups
 * entered to reach it. Used to save fallback checkpoints during matching.
-*/ function findRestNode(node) {
+*/
+function findRestNode(node) {
 	const r = descendGroups(node, (n) => n._A);
 	return r ? {
 		next: r.value,
@@ -822,7 +1100,8 @@ var deepFreeze = (obj) => {
 /**
 * Find a `_4`/`_E` boundary inside a node's pathless `_M` groups (first in `_M` order), wrapped in
 * those groups' layouts.
-*/ function findGroupBoundary(node, layouts, kind) {
+*/
+function findGroupBoundary(node, layouts, kind) {
 	const r = descendGroups(node, (n) => n[kind]);
 	if (!r) return;
 	const groupLayouts = [...layouts];
@@ -841,13 +1120,14 @@ var deepFreeze = (obj) => {
 * Group nodes (in `_M` arrays) are pathless — they don't consume a URL segment but contribute their
 * `_L` layout to the chain. The matcher transparently enters groups when searching for a matching
 * child.
-*/ function matchRouteTree(root = {}, pathname) {
+*/
+function matchRouteTree(root = {}, pathname) {
 	let node = root;
 	const params = {};
 	const routeParts = [];
 	const layouts = [];
-	const loaderHashes = [];
 	const loaderPathsByHash = {};
+	const loaderParamsByHash = {};
 	const errorLoaderRef = {
 		v: void 0,
 		layouts: []
@@ -858,7 +1138,7 @@ var deepFreeze = (obj) => {
 	};
 	const menuLoaderRef = { v: void 0 };
 	const groupNodes = [];
-	collectNodeMeta(root, [], layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash);
+	collectNodeMeta(root, [], layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderPathsByHash, "/", loaderParamsByHash);
 	if (root._M) groupNodes.push({
 		node: root,
 		depth: layouts.length
@@ -877,7 +1157,7 @@ var deepFreeze = (obj) => {
 			matched = false;
 			break;
 		}
-		const restInfo = found.kind === 1 ? findRestNode(node) : void 0;
+		const restInfo = found.kind === ChildMatchKind.Wildcard ? findRestNode(node) : void 0;
 		if (restInfo) restFallback = {
 			aNode: restInfo.next,
 			groups: restInfo.groups,
@@ -887,6 +1167,7 @@ var deepFreeze = (obj) => {
 			params: { ...params },
 			layouts: [...layouts],
 			loaderPathsByHash: { ...loaderPathsByHash },
+			loaderParamsByHash: { ...loaderParamsByHash },
 			errorLoader: errorLoaderRef.v,
 			errorLayouts: errorLoaderRef.layouts,
 			notFoundLoader: notFoundLoaderRef.v,
@@ -898,7 +1179,7 @@ var deepFreeze = (obj) => {
 		done = found.done;
 		node = found.next;
 		const matchedPathname = `/${parts.slice(0, found.done ? len : i + 1).join("/")}/`;
-		collectNodeMeta(node, found.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, matchedPathname);
+		collectNodeMeta(node, found.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderPathsByHash, matchedPathname, loaderParamsByHash, { ...params });
 		if (node._M) groupNodes.push({
 			node,
 			depth: layouts.length
@@ -908,7 +1189,7 @@ var deepFreeze = (obj) => {
 		if (!node._I && node._G == null) {
 			const indexResult = findIndexNode(node);
 			if (indexResult) {
-				collectNodeMeta(indexResult.target, indexResult.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, pathname);
+				collectNodeMeta(indexResult.target, indexResult.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderPathsByHash, pathname, loaderParamsByHash, { ...params });
 				node = indexResult.target;
 			}
 		}
@@ -919,12 +1200,13 @@ var deepFreeze = (obj) => {
 				const paramName = next._P;
 				params[paramName] = "";
 				routeParts.push(`[...${paramName}]`);
-				collectNodeMeta(next, restInfo.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, pathname);
+				collectNodeMeta(next, restInfo.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderPathsByHash, pathname, loaderParamsByHash, { ...params });
 				node = next;
 			}
 		}
 	}
-	const loaders = matched && (done || i >= len) ? resolveLoaders(root, node, layouts) : void 0;
+	const resolved = matched && (done || i >= len) ? resolveLoaders(root, node, layouts, params) : void 0;
+	const loaders = resolved?.loaders;
 	if (!loaders && restFallback) {
 		const fb = restFallback;
 		const fbParams = {
@@ -934,6 +1216,7 @@ var deepFreeze = (obj) => {
 		const fbRouteParts = [...fb.routeParts, `[...${fb.paramName}]`];
 		const fbLayouts = [...fb.layouts];
 		const fbLoaderPathsByHash = { ...fb.loaderPathsByHash };
+		const fbLoaderParamsByHash = { ...fb.loaderParamsByHash };
 		const fbErrorRef = {
 			v: fb.errorLoader,
 			layouts: fb.errorLayouts
@@ -943,20 +1226,22 @@ var deepFreeze = (obj) => {
 			layouts: fb.notFoundLayouts
 		};
 		const fbMenuRef = { v: fb.menuLoader };
-		const fbLoaderHashes = [];
-		collectNodeMeta(fb.aNode, fb.groups, fbLayouts, fbErrorRef, fbNotFoundRef, fbMenuRef, fbLoaderHashes, fbLoaderPathsByHash, pathname);
-		const fbLoaders = resolveLoaders(root, fb.aNode, fbLayouts);
-		if (fbLoaders) return {
-			loaders: fbLoaders,
-			params: fbParams,
-			routeParts: fbRouteParts,
-			notFound: false,
-			routeBundleNames: fb.aNode._B,
-			loaderHashes: fbLoaderHashes.length > 0 ? fbLoaderHashes : void 0,
-			loaderPathsByHash: Object.keys(fbLoaderPathsByHash).length > 0 ? fbLoaderPathsByHash : void 0,
-			menuLoader: fbMenuRef.v,
-			errorLoader: boundaryChain(fbErrorRef)
-		};
+		collectNodeMeta(fb.aNode, fb.groups, fbLayouts, fbErrorRef, fbNotFoundRef, fbMenuRef, fbLoaderPathsByHash, pathname, fbLoaderParamsByHash, fbParams);
+		const fallback = resolveLoaders(root, fb.aNode, fbLayouts, fbParams);
+		if (fallback) {
+			collectPageLoaders(fallback, fbLoaderPathsByHash, fbLoaderParamsByHash, pathname, fbParams);
+			return {
+				loaders: fallback.loaders,
+				params: fbParams,
+				routeParts: fbRouteParts,
+				notFound: false,
+				routeBundleNames: fb.aNode._B,
+				loaderPathsByHash: Object.keys(fbLoaderPathsByHash).length > 0 ? fbLoaderPathsByHash : void 0,
+				loaderParamsByHash: Object.keys(fbLoaderParamsByHash).length > 0 ? fbLoaderParamsByHash : void 0,
+				menuLoader: fbMenuRef.v,
+				errorLoader: boundaryChain(fbErrorRef)
+			};
+		}
 		errorLoaderRef.v = fbErrorRef.v;
 		errorLoaderRef.layouts = fbErrorRef.layouts;
 		notFoundLoaderRef.v = fbNotFoundRef.v;
@@ -993,28 +1278,21 @@ var deepFreeze = (obj) => {
 			routeParts,
 			notFound: true,
 			routeBundleNames: void 0,
-			loaderHashes: void 0,
 			loaderPathsByHash: void 0,
+			loaderParamsByHash: void 0,
 			menuLoader: menuLoaderRef.v,
 			errorLoader: boundaryChain(errorLoaderRef)
 		};
 	}
-	if (node._R) {
-		loaderHashes.push(...node._R);
-		const matchedPathname = ensureSlash(pathname);
-		for (let i = 0; i < node._R.length; i++) {
-			const hash = node._R[i];
-			loaderPathsByHash[hash] = matchedPathname;
-		}
-	}
+	collectPageLoaders(resolved, loaderPathsByHash, loaderParamsByHash, pathname, params);
 	return {
 		loaders,
 		params,
 		routeParts,
 		notFound: false,
 		routeBundleNames: node._B,
-		loaderHashes: loaderHashes.length > 0 ? loaderHashes : void 0,
 		loaderPathsByHash: Object.keys(loaderPathsByHash).length > 0 ? loaderPathsByHash : void 0,
+		loaderParamsByHash: Object.keys(loaderParamsByHash).length > 0 ? loaderParamsByHash : void 0,
 		menuLoader: menuLoaderRef.v,
 		errorLoader: boundaryChain(errorLoaderRef)
 	};
@@ -1033,39 +1311,42 @@ var loadModule = (moduleLoader, pendingLoads, moduleSetter, cacheModules) => {
 		}
 	}
 };
-var loadRoute = async (routes, cacheModules, pathname) => {
-	const { loaders, params, routeParts, notFound, routeBundleNames, loaderHashes, loaderPathsByHash, menuLoader, errorLoader } = matchRouteTree(routes, pathname);
-	const routeName = "/" + routeParts.join("/");
-	const modules = new Array(loaders.length);
-	const pendingLoads = [];
-	for (let i = 0; i < loaders.length; i++) {
-		const moduleLoader = loaders[i];
-		loadModule(moduleLoader, pendingLoads, (routeModule) => modules[i] = routeModule, cacheModules);
+function collectPageLoaders({ node, loaderPaths, loaderParams }, paths, pathParams, pathname, params) {
+	if (loaderPaths) {
+		for (const hash in paths) {
+			delete paths[hash];
+			delete pathParams[hash];
+		}
+		Object.assign(paths, loaderPaths);
+		Object.assign(pathParams, loaderParams);
 	}
-	let menu = void 0;
-	loadModule(menuLoader, pendingLoads, (menuModule) => menu = menuModule?.default, cacheModules);
-	if (pendingLoads.length > 0) await Promise.all(pendingLoads);
-	return {
-		$routeName$: routeName,
-		$params$: params,
-		$mods$: modules,
-		$menu$: deepFreeze(menu),
-		$routeBundleNames$: routeBundleNames,
-		$notFound$: notFound,
-		$errorLoader$: errorLoader,
-		$loaders$: loaderHashes,
-		$loaderPaths$: loaderPathsByHash
-	};
-};
-/** Gets an absolute url path string (url.pathname + url.search + url.hash) */ var toPath = (url) => url.pathname + url.search + url.hash;
-/** Create a URL from a string and baseUrl */ var toUrl = (url, baseUrl) => new URL(url, baseUrl.href);
-/** Checks only if the origins are the same. */ var isSameOrigin = (a, b) => a.origin === b.origin;
-/** Checks only if the pathnames are the same for the URLs (doesn't include search and hash) */ var isSamePathname = ({ pathname: a }, { pathname: b }) => {
+	const pageHashes = node._D ?? [];
+	if (Array.isArray(node._I)) {
+		for (const hash in paths) if (!pageHashes.includes(hash)) {
+			delete paths[hash];
+			delete pathParams[hash];
+		}
+	}
+	for (const hash of pageHashes) if (!paths[hash]) {
+		paths[hash] = ensureSlash(pathname);
+		pathParams[hash] = { ...params };
+	}
+}
+/** Gets an absolute url path string (url.pathname + url.search + url.hash) */
+var toPath = (url) => url.pathname + url.search + url.hash;
+/** Create a URL from a string and baseUrl */
+var toUrl = (url, baseUrl) => new URL(url, baseUrl.href);
+/** Checks only if the origins are the same. */
+var isSameOrigin = (a, b) => a.origin === b.origin;
+/** Checks only if the pathnames are the same for the URLs (doesn't include search and hash) */
+var isSamePathname = ({ pathname: a }, { pathname: b }) => {
 	const lDiff = Math.abs(a.length - b.length);
 	return lDiff === 0 ? a === b : lDiff === 1 && ensureSlash(a) === ensureSlash(b);
 };
-/** Checks only if the search query strings are the same for the URLs */ var isSameSearchQuery = (a, b) => a.search === b.search;
-/** Checks only if the pathname + search are the same for the URLs. */ var isSamePath = (a, b) => isSameSearchQuery(a, b) && isSamePathname(a, b);
+/** Checks only if the search query strings are the same for the URLs */
+var isSameSearchQuery = (a, b) => a.search === b.search;
+/** Checks only if the pathname + search are the same for the URLs. */
+var isSamePath = (a, b) => isSameSearchQuery(a, b) && isSamePathname(a, b);
 var getClientNavPath = (props, baseUrl) => {
 	const href = props.href;
 	if (typeof href === "string" && typeof props.target !== "string" && !props.reload) try {
@@ -1084,40 +1365,12 @@ var shouldPreload = (clientNavPath, currentLoc) => {
 var isPromise = (value) => {
 	return value && typeof value.then === "function";
 };
-var mergeArray = (existingArr, newArr) => {
-	if (Array.isArray(newArr)) for (const newItem of newArr) {
-		if (typeof newItem.key === "string") {
-			const existingIndex = existingArr.findIndex((i) => i.key === newItem.key);
-			if (existingIndex > -1) {
-				existingArr[existingIndex] = newItem;
-				continue;
-			}
-		}
-		existingArr.push(newItem);
-	}
-};
-var resolveDocumentHead = (resolvedHead, updatedHead) => {
-	if (typeof updatedHead.title === "string") resolvedHead.title = updatedHead.title;
-	mergeArray(resolvedHead.meta, updatedHead.meta);
-	mergeArray(resolvedHead.links, updatedHead.links);
-	mergeArray(resolvedHead.styles, updatedHead.styles);
-	mergeArray(resolvedHead.scripts, updatedHead.scripts);
-	Object.assign(resolvedHead.frontmatter, updatedHead.frontmatter);
-};
-var createDocumentHead = (defaults, manifestHash) => ({
-	title: defaults?.title || "",
-	meta: [...defaults?.meta || []],
-	links: [...defaults?.links || []],
-	styles: [...defaults?.styles || []],
-	scripts: [...defaults?.scripts || []],
-	frontmatter: { ...defaults?.frontmatter },
-	manifestHash: manifestHash || "dev"
-});
 /**
 * Resolve the full route config (head + eTag + cacheKey) from all content modules. Uses the same
 * resolution rules as DocumentHead: objects are merged immediately, functions are queued and
 * executed inner-before-outer.
-*/ var resolveRouteConfig = (resolveValue, routeLocation, contentModules, locale, status, defaults) => withLocale(locale, () => {
+*/
+var resolveRouteConfig = (resolveValue, routeLocation, contentModules, locale, status, defaults) => withLocale(locale, () => {
 	const head = createDocumentHead(defaults);
 	let eTag;
 	let cacheKey;
@@ -1190,13 +1443,43 @@ var createDocumentHead = (defaults, manifestHash) => ({
 *
 * Signal values may throw a promise on the client when still loading — callers should wrap this in
 * `retryOnPromise` to handle that.
-*/ var resolveHead = (actionData, loaderState, routeLocation, contentModules, locale, defaults) => {
-	const getData = (loaderOrAction) => {
+*/
+var resolveHead = (actionData, loaderState, routeLocation, contentModules, locale, defaults) => {
+	const getData = ((loaderOrAction) => {
 		const id = loaderOrAction.__id;
 		const signal = loaderState?.[id];
 		if (signal) return signal.value;
 		if (actionData?.action === id) return actionData.actionResult;
-	};
+	});
 	return resolveRouteConfig(getData, routeLocation, contentModules, locale, actionData?.status ?? 200, defaults).head;
 };
-export { routeLoader$ as A, RouteLoaderCtxContext as B, getRouteLoaderValues as C, loadRouteLoader as D, isImmutableLoader as E, ContentContext as F, QACTION_KEY as G, RouteNavigateContext as H, ContentInternalContext as I, Q_ROUTE as J, QDATA_KEY as K, DocumentHeadContext as L, setLoaderSignalValue as M, setRouteLoaders as N, matchesRouteLoaderId as O, updateRouteLoaderPaths as P, HttpStatusContext as R, getRouteLoaderResponse as S, invalidateNavRouteLoaders as T, RoutePreventNavigateContext as U, RouteLocationContext as V, RouteStateContext as W, _asyncRequestStore as Y, fetchRouteLoaderData as _, isPromise as a, getRequestEvent as b, shouldPreload as c, loadRoute as d, FULLPATH_HEADER as f, ensureRouteLoaderSignals as g, clearRouteLoaderData as h, getClientNavPath as i, routeLoaderQrl as j, resolveRouteLoaderByHash as k, toPath as l, clearNavFetchCache as m, resolveHead as n, isSameOrigin as o, ROUTE_PATH_HEADER as p, QFN_KEY as q, resolveRouteConfig as r, isSamePath as s, createDocumentHead as t, toUrl as u, getLoaderRequestEvent as v, getRouteLoaders as w, getRouteLoaderCtx as x, getModuleRouteLoaders as y, RouteActionContext as z };
+var resolveDocumentHead = (resolvedHead, updatedHead) => {
+	if (typeof updatedHead.title === "string") resolvedHead.title = updatedHead.title;
+	mergeArray(resolvedHead.meta, updatedHead.meta);
+	mergeArray(resolvedHead.links, updatedHead.links);
+	mergeArray(resolvedHead.styles, updatedHead.styles);
+	mergeArray(resolvedHead.scripts, updatedHead.scripts);
+	Object.assign(resolvedHead.frontmatter, updatedHead.frontmatter);
+};
+var mergeArray = (existingArr, newArr) => {
+	if (Array.isArray(newArr)) for (const newItem of newArr) {
+		if (typeof newItem.key === "string") {
+			const existingIndex = existingArr.findIndex((i) => i.key === newItem.key);
+			if (existingIndex > -1) {
+				existingArr[existingIndex] = newItem;
+				continue;
+			}
+		}
+		existingArr.push(newItem);
+	}
+};
+var createDocumentHead = (defaults, manifestHash) => ({
+	title: defaults?.title || "",
+	meta: [...defaults?.meta || []],
+	links: [...defaults?.links || []],
+	styles: [...defaults?.styles || []],
+	scripts: [...defaults?.scripts || []],
+	frontmatter: { ...defaults?.frontmatter },
+	manifestHash: manifestHash || "dev"
+});
+export { RoutePreventNavigateContext as $, loadRouteLoader as A, _setRouterConfig as B, getRequestEvent as C, getRouteLoaderValues as D, getRouteLoaderResponse as E, routeLoader$ as F, ContentContext as G, getRouterConfig as H, routeLoaderQrl as I, HttpStatusContext as J, ContentInternalContext as K, setLoaderSignalValue as L, prepareRouteLoaders as M, resolveRouteLoaderByHash as N, getRouteLoaders as O, restoreRouteLoaders as P, RouteNavigateContext as Q, setRouteLoaders as R, getModuleRouteLoaders as S, getRouteLoaderParams as T, getRoutes as U, getBasePathname as V, getTrailingSlash as W, RouteLoaderCtxContext as X, RouteActionContext as Y, RouteLocationContext as Z, commitRouteLoaders as _, isPromise as a, RequestEvRouterConfig as at, getClientRouteLoaders as b, shouldPreload as c, loadRoute as d, RouteStateContext as et, FULLPATH_HEADER as f, clearRouteLoaderData as g, clearNavFetchCache as h, getClientNavPath as i, Q_ROUTE as it, matchesRouteLoaderId as j, isImmutableLoader as k, toPath as l, abortRouteLoaderNavigation as m, resolveHead as n, QDATA_KEY as nt, isSameOrigin as o, _asyncRequestStore as ot, ROUTE_PATH_HEADER as p, DocumentHeadContext as q, resolveRouteConfig as r, QFN_KEY as rt, isSamePath as s, createDocumentHead as t, QACTION_KEY as tt, toUrl as u, ensureRouteLoaderSignals as v, getRouteLoaderCtx as w, getLoaderRequestEvent as x, fetchRouteLoaderData as y, _getServiceWorkerUrl as z };