@qwik.dev/router 2.0.0-beta.39 → 2.0.0-beta.40

package/lib/chunks/head.qwik.mjs

@@ -1,1425 +1,1217 @@
-import { e as ensureSlash } from './pathname.mjs';
-import { createContextId, isServer as isServer$1, implicit$FirstArg, isDev, createComputedQrl, inlinedQrl, _captures, withLocale } from '@qwik.dev/core';
-import * as qwikRouterConfig from '@qwik-router-config';
-import { _getAsyncLocalStorage, _getContextEvent, _resolveContextWithoutSequentialScope, _injectAsyncSignalValue, _UNINITIALIZED, _deserialize, _markSignalAsExternallyOwned, SerializerSymbol, _verifySerializable } from '@qwik.dev/core/internal';
-import { isServer } from '@qwik.dev/core/build';
-import { g as getLoaderName } from './request-path.mjs';
-import { R as RedirectMessage, S as ServerError, t as throwIfControlFlowSignal } from './server-error.mjs';
-
-let _asyncRequestStore;
-if (isServer) {
-  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");
-  }
+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 { isServer as isServer$1 } from "@qwik.dev/core/build";
+/** @internal */ var _asyncRequestStore;
+if (isServer$1) {
+	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");
 }
-
-const deepFreeze = (obj) => {
-  if (obj == null) {
-    return obj;
-  }
-  Object.getOwnPropertyNames(obj).forEach((prop) => {
-    const value = obj[prop];
-    if (value && typeof value === "object" && !Object.isFrozen(value)) {
-      try {
-        deepFreeze(value);
-      } catch {
-        return obj;
-      }
-    }
-  });
-  return Object.freeze(obj);
+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";
+var RouteStateContext = /*#__PURE__*/ createContextId("qr-s");
+var RouteLoaderCtxContext = /*#__PURE__*/ createContextId("qr-lc");
+var ContentContext = /*#__PURE__*/ createContextId("qr-c");
+var ContentInternalContext = /*#__PURE__*/ createContextId("qr-ic");
+var DocumentHeadContext = /*#__PURE__*/ createContextId("qr-h");
+var RouteLocationContext = /*#__PURE__*/ createContextId("qr-l");
+var RouteNavigateContext = /*#__PURE__*/ createContextId("qr-n");
+var RouteActionContext = /*#__PURE__*/ createContextId("qr-a");
+var RoutePreventNavigateContext = /*#__PURE__*/ createContextId("qr-p");
+var HttpStatusContext = /*#__PURE__*/ createContextId("qr-hs");
+/**
+* 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_LOADER_PATHS_STORE = "@loaderPathsStore";
+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";
+/**
+* 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 isRedirectStatus = (status) => status >= 300 && status < 400;
+/** 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);
+		signal.addEventListener("abort", abort, { once: true });
+		promise.finally(() => signal.removeEventListener("abort", abort)).then(resolve, reject);
+	});
 };
-
-const MODULE_CACHE = /* @__PURE__ */ new WeakMap();
-const httpErrorLoader = () => import('./http-error.qwik.mjs');
-function walkTrieKeys(root, keys) {
-  let node = root;
-  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 void 0;
-    }
-    node = next;
-    if (node._L) {
-      layouts.push(node._L);
-    }
-  }
-  return {
-    node,
-    layouts
-  };
-}
-const boundaryChain = (ref) => ref.v ? Array.isArray(ref.v) ? ref.v : [
-  ...ref.layouts,
-  ref.v
-] : void 0;
-function collectNodeMeta(node, groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, matchedPathname = "/") {
-  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._E) {
-      errorLoaderRef.v = g._E;
-      errorLoaderRef.layouts = [
-        ...layouts
-      ];
-    }
-    if (g._4) {
-      notFoundLoaderRef.v = g._4;
-      notFoundLoaderRef.layouts = [
-        ...layouts
-      ];
-    }
-    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._E) {
-    errorLoaderRef.v = node._E;
-    errorLoaderRef.layouts = [
-      ...layouts
-    ];
-  }
-  if (node._4) {
-    notFoundLoaderRef.v = node._4;
-    notFoundLoaderRef.layouts = [
-      ...layouts
-    ];
-  }
-  if (node._N) {
-    menuLoaderRef.v = node._N;
-  }
-}
-function tryWildcardMatch(node, part, partLower, parts, partIndex) {
-  let next = node._W;
-  if (next) {
-    const prefix = next._0;
-    const suffix = next._9;
-    if (prefix || suffix) {
-      const pre = prefix || "";
-      const suf = suffix || "";
-      if (partLower.length > pre.length + suf.length && (!pre || partLower.startsWith(pre.toLowerCase())) && (!suf || partLower.endsWith(suf.toLowerCase()))) {
-        const paramName = next._P;
-        const value = part.slice(pre.length, suf ? part.length - suf.length : void 0);
-        return {
-          next,
-          routePart: `${pre}[${paramName}]${suf}`,
-          done: false,
-          kind: 1,
-          paramName,
-          paramValue: value
-        };
-      }
-    } else {
-      const paramName = next._P;
-      return {
-        next,
-        routePart: `[${paramName}]`,
-        done: false,
-        kind: 1,
-        paramName,
-        paramValue: part
-      };
-    }
-  }
-  next = node._A;
-  if (next) {
-    const paramName = next._P;
-    const restValue = parts.slice(partIndex).join("/");
-    return {
-      next,
-      routePart: `[...${paramName}]`,
-      done: true,
-      kind: 2,
-      paramName,
-      paramValue: restValue
-    };
-  }
-  return void 0;
-}
-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: []
-    };
-  }
-  return void 0;
-}
-function descendGroups(node, hit) {
-  const value = hit(node);
-  if (value !== void 0) {
-    return {
-      value,
-      node,
-      groups: []
-    };
-  }
-  if (node._M) {
-    for (let j = 0; j < node._M.length; j++) {
-      const group = node._M[j];
-      const result = descendGroups(group, hit);
-      if (result) {
-        result.groups.unshift(group);
-        return result;
-      }
-    }
-  }
-  return void 0;
-}
-function findIndexNode(node) {
-  const r = descendGroups(node, (n) => n._I || n._G != null ? n : void 0);
-  return r ? {
-    target: r.node,
-    groups: r.groups.filter((g) => g !== r.node)
-  } : void 0;
-}
-function resolveLoaders(root, node, gatheredLayouts) {
-  if (node._G != null) {
-    const keys = node._G.split("/").filter((p) => p.length > 0);
-    const target = walkTrieKeys(root, keys);
-    if (!target) {
-      return void 0;
-    }
-    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 void 0;
-  }
-  if (Array.isArray(index)) {
-    return index;
-  }
-  return [
-    ...gatheredLayouts,
-    index
-  ];
-}
-function findRestNode(node) {
-  const r = descendGroups(node, (n) => n._A);
-  return r ? {
-    next: r.value,
-    groups: r.groups
-  } : void 0;
-}
-function findGroupBoundary(node, layouts, kind) {
-  const r = descendGroups(node, (n) => n[kind]);
-  if (!r) {
-    return void 0;
-  }
-  const groupLayouts = [
-    ...layouts
-  ];
-  for (const g of r.groups) {
-    if (g._L) {
-      groupLayouts.push(g._L);
-    }
-  }
-  return {
-    v: r.value,
-    layouts: groupLayouts
-  };
-}
-function matchRouteTree(root = {}, pathname) {
-  let node = root;
-  const params = {};
-  const routeParts = [];
-  const layouts = [];
-  const loaderHashes = [];
-  const loaderPathsByHash = {};
-  const errorLoaderRef = {
-    v: void 0,
-    layouts: []
-  };
-  const notFoundLoaderRef = {
-    v: void 0,
-    layouts: []
-  };
-  const menuLoaderRef = {
-    v: void 0
-  };
-  const groupNodes = [];
-  collectNodeMeta(root, [], layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash);
-  if (root._M) {
-    groupNodes.push({
-      node: root,
-      depth: layouts.length
-    });
-  }
-  let done = false;
-  let matched = true;
-  const parts = pathname.split("/").filter((p) => p.length > 0).map(decodeURIComponent);
-  let restFallback;
-  let i = 0;
-  const len = parts.length;
-  for (; !done && i < len; i++) {
-    const part = parts[i];
-    const partLower = part.toLowerCase();
-    const found = findChild(node, part, partLower, parts, i);
-    if (!found) {
-      matched = false;
-      break;
-    }
-    const restInfo = found.kind === 1 ? findRestNode(node) : void 0;
-    if (restInfo) {
-      restFallback = {
-        aNode: restInfo.next,
-        groups: restInfo.groups,
-        paramName: restInfo.next._P,
-        restValue: parts.slice(i).join("/"),
-        routeParts: [
-          ...routeParts
-        ],
-        params: {
-          ...params
-        },
-        layouts: [
-          ...layouts
-        ],
-        loaderPathsByHash: {
-          ...loaderPathsByHash
-        },
-        errorLoader: errorLoaderRef.v,
-        errorLayouts: errorLoaderRef.layouts,
-        notFoundLoader: notFoundLoaderRef.v,
-        notFoundLayouts: notFoundLoaderRef.layouts,
-        menuLoader: menuLoaderRef.v
-      };
-    }
-    if (found.paramName) {
-      params[found.paramName] = found.paramValue;
-    }
-    routeParts.push(found.routePart);
-    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);
-    if (node._M) {
-      groupNodes.push({
-        node,
-        depth: layouts.length
-      });
-    }
-  }
-  if (matched && !done && i === len) {
-    if (!node._I && node._G == null) {
-      const indexResult = findIndexNode(node);
-      if (indexResult) {
-        collectNodeMeta(indexResult.target, indexResult.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, pathname);
-        node = indexResult.target;
-      }
-    }
-    if (!node._I && node._G == null) {
-      const restInfo = findRestNode(node);
-      if (restInfo) {
-        const next = restInfo.next;
-        const paramName = next._P;
-        params[paramName] = "";
-        routeParts.push(`[...${paramName}]`);
-        collectNodeMeta(next, restInfo.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, pathname);
-        node = next;
-      }
-    }
-  }
-  const loaders = matched && (done || i >= len) ? resolveLoaders(root, node, layouts) : void 0;
-  if (!loaders && restFallback) {
-    const fb = restFallback;
-    const fbParams = {
-      ...fb.params,
-      [fb.paramName]: fb.restValue
-    };
-    const fbRouteParts = [
-      ...fb.routeParts,
-      `[...${fb.paramName}]`
-    ];
-    const fbLayouts = [
-      ...fb.layouts
-    ];
-    const fbLoaderPathsByHash = {
-      ...fb.loaderPathsByHash
-    };
-    const fbErrorRef = {
-      v: fb.errorLoader,
-      layouts: fb.errorLayouts
-    };
-    const fbNotFoundRef = {
-      v: fb.notFoundLoader,
-      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)
-      };
-    }
-    errorLoaderRef.v = fbErrorRef.v;
-    errorLoaderRef.layouts = fbErrorRef.layouts;
-    notFoundLoaderRef.v = fbNotFoundRef.v;
-    notFoundLoaderRef.layouts = fbNotFoundRef.layouts;
-    menuLoaderRef.v = fbMenuRef.v;
-  }
-  if (!loaders) {
-    const recover = (kind) => {
-      for (let k = groupNodes.length - 1; k >= 0; k--) {
-        const found = findGroupBoundary(groupNodes[k].node, layouts.slice(0, groupNodes[k].depth), kind);
-        if (found) {
-          return found;
-        }
-      }
-      return void 0;
-    };
-    if (!notFoundLoaderRef.v) {
-      const g = recover("_4");
-      if (g) {
-        notFoundLoaderRef.v = g.v;
-        notFoundLoaderRef.layouts = g.layouts;
-      }
-    }
-    if (!errorLoaderRef.v) {
-      const g = recover("_E");
-      if (g) {
-        errorLoaderRef.v = g.v;
-        errorLoaderRef.layouts = g.layouts;
-      }
-    }
-    const ref = notFoundLoaderRef.v ? notFoundLoaderRef : errorLoaderRef.v ? errorLoaderRef : null;
-    const boundary = ref?.v ?? httpErrorLoader;
-    const boundaryLayouts = ref ? ref.layouts : layouts;
-    return {
-      loaders: Array.isArray(boundary) ? boundary : [
-        ...boundaryLayouts,
-        boundary
-      ],
-      params,
-      routeParts,
-      notFound: true,
-      routeBundleNames: void 0,
-      loaderHashes: void 0,
-      loaderPathsByHash: void 0,
-      menuLoader: menuLoaderRef.v,
-      errorLoader: boundaryChain(errorLoaderRef)
-    };
-  }
-  if (node._R) {
-    loaderHashes.push(...node._R);
-    const matchedPathname = ensureSlash(pathname);
-    for (let i2 = 0; i2 < node._R.length; i2++) {
-      const hash = node._R[i2];
-      loaderPathsByHash[hash] = matchedPathname;
-    }
-  }
-  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,
-    menuLoader: menuLoaderRef.v,
-    errorLoader: boundaryChain(errorLoaderRef)
-  };
-}
-const loadModule = (moduleLoader, pendingLoads, moduleSetter, cacheModules) => {
-  if (typeof moduleLoader === "function") {
-    const loadedModule = MODULE_CACHE.get(moduleLoader);
-    if (loadedModule) {
-      moduleSetter(loadedModule);
-    } else {
-      const moduleOrPromise = moduleLoader();
-      if (typeof moduleOrPromise.then === "function") {
-        pendingLoads.push(moduleOrPromise.then((loadedModule2) => {
-          if (cacheModules !== false) {
-            MODULE_CACHE.set(moduleLoader, loadedModule2);
-          }
-          moduleSetter(loadedModule2);
-        }));
-      } else if (moduleOrPromise) {
-        moduleSetter(moduleOrPromise);
-      }
-    }
-  }
-};
-const loadRoute = async (routes, cacheModules, pathname) => {
-  const result = matchRouteTree(routes, pathname);
-  const { loaders, params, routeParts, notFound, routeBundleNames, loaderHashes, loaderPathsByHash, menuLoader, errorLoader } = result;
-  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$: loaderHashes,
-    $loaderPaths$: loaderPathsByHash
-  };
+var getRouteLoaderValueStateKey = (loaderId) => `${ROUTE_LOADER_VALUE_PREFIX}${loaderId}`;
+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) => {
+	if (!routePath) return;
+	let resolvedPath = routePath;
+	const basePath = opts?.basePath ?? "/";
+	if (basePath !== "/" && !resolvedPath.startsWith(basePath)) resolvedPath = basePath + resolvedPath.slice(1);
+	const pathBase = ensureSlash(resolvedPath);
+	const pageUrl = opts?.pageUrl;
+	const search = pageUrl?.search ?? "";
+	const url = `${pathBase}${getLoaderName(loaderId, manifestHash)}${search}`;
+	const headers = {};
+	if (pageUrl && pageUrl.pathname !== pathBase) {
+		if (!globalThis.__STRICT_LOADERS__) headers[FULLPATH_HEADER] = pageUrl.pathname;
+		else if (isDev) headers[ROUTE_PATH_HEADER] = pageUrl.pathname;
+	}
+	const cacheKey = `${url}\n${headers["X-Qwik-fullpath"] ?? ""}`;
+	if (!opts?.ignoreCache) {
+		const entry = navFetchCache.get(cacheKey);
+		if (entry) return opts?.signal ? wrapWithAbort(entry, opts.signal) : entry;
+	}
+	const request = async () => {
+		const response = await fetch(url, {
+			signal: opts?.signal,
+			cache: opts?.ignoreCache ? "reload" : "default",
+			headers
+		});
+		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() };
+	};
+	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));
+		return value;
+	});
+	const promise = request().then((value) => {
+		if (value === void 0) navFetchCache.delete(cacheKey);
+		return value;
+	}, (err) => {
+		navFetchCache.delete(cacheKey);
+		throw err;
+	});
+	navFetchCache.set(cacheKey, promise);
+	return promise;
 };
-
-const QACTION_KEY = "qaction";
-const QFN_KEY = "qfunc";
-const QDATA_KEY = "qdata";
-const Q_ROUTE = "q:route";
-const DEFAULT_LOADERS_SERIALIZATION_STRATEGY = globalThis.__DEFAULT_LOADERS_SERIALIZATION_STRATEGY__ || "never";
-
-const RouteStateContext = /* @__PURE__ */ createContextId("qr-s");
-const RouteLoaderCtxContext = /* @__PURE__ */ createContextId("qr-lc");
-const ContentContext = /* @__PURE__ */ createContextId("qr-c");
-const ContentInternalContext = /* @__PURE__ */ createContextId("qr-ic");
-const DocumentHeadContext = /* @__PURE__ */ createContextId("qr-h");
-const RouteLocationContext = /* @__PURE__ */ createContextId("qr-l");
-const RouteNavigateContext = /* @__PURE__ */ createContextId("qr-n");
-const RouteActionContext = /* @__PURE__ */ createContextId("qr-a");
-const RoutePreventNavigateContext = /* @__PURE__ */ createContextId("qr-p");
-const HttpStatusContext = /* @__PURE__ */ createContextId("qr-hs");
-
-const REQUEST_ROUTE_LOADER_STATE = "@routeLoaderState";
-const REQUEST_LOADER_PATHS_STORE = "@loaderPathsStore";
-const REQUEST_ROUTE_LOADERS = "@routeLoaders";
-const REQUEST_ROUTE_LOADER_PROMISES = "@routeLoaderPromises";
-const REQUEST_ROUTE_LOADER_EVENTS = "@routeLoaderEvents";
-const REQUEST_ROUTE_LOADER_ROOT_EVENT = "@routeLoaderRootEvent";
-const ROUTE_LOADER_VALUE_PREFIX = "__qwik_route_loader_value__";
-const FULLPATH_HEADER = "X-Qwik-fullpath";
-const ROUTE_PATH_HEADER = "X-Qwik-route-path";
-const navFetchCache = /* @__PURE__ */ new Map();
-const clearNavFetchCache = () => navFetchCache.clear();
-const isRedirectStatus = (status) => status >= 300 && status < 400;
-const wrapWithAbort = (promise, signal) => {
-  if (signal.aborted) {
-    return Promise.reject(signal.reason);
-  }
-  return new Promise((resolve, reject) => {
-    const abort = () => reject(signal.reason);
-    signal.addEventListener("abort", abort, {
-      once: true
-    });
-    promise.finally(() => signal.removeEventListener("abort", abort)).then(resolve, reject);
-  });
+/** 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];
+		const values = params.getAll(name);
+		for (let j = 0; j < values.length; j++) filtered.append(name, values[j]);
+	}
+	filtered.sort();
+	return filtered.toString() ? `?${filtered.toString()}` : "";
 };
-const getRouteLoaderValueStateKey = (loaderId) => `${ROUTE_LOADER_VALUE_PREFIX}${loaderId}`;
-const isRequestEvent = (value) => !!value && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, "sharedMap") && Object.prototype.hasOwnProperty.call(value, "cookie");
-const isLoaderInternal = (value) => typeof value === "function" && value.__brand === "server_loader";
-const fetchRouteLoaderData = async (loaderId, routePath, manifestHash, opts) => {
-  if (!routePath) {
-    return void 0;
-  }
-  let resolvedPath = routePath;
-  const basePath = opts?.basePath ?? "/";
-  if (basePath !== "/" && !resolvedPath.startsWith(basePath)) {
-    resolvedPath = basePath + resolvedPath.slice(1);
-  }
-  const pathBase = ensureSlash(resolvedPath);
-  const pageUrl = opts?.pageUrl;
-  const search = pageUrl?.search ?? "";
-  const url = `${pathBase}${getLoaderName(loaderId, manifestHash)}${search}`;
-  const headers = {};
-  if (pageUrl && pageUrl.pathname !== pathBase) {
-    if (!globalThis.__STRICT_LOADERS__) {
-      headers[FULLPATH_HEADER] = pageUrl.pathname;
-    } else if (isDev) {
-      headers[ROUTE_PATH_HEADER] = pageUrl.pathname;
-    }
-  }
-  const cacheKey = `${url}
-${headers[FULLPATH_HEADER] ?? ""}`;
-  if (!opts?.ignoreCache) {
-    const entry = navFetchCache.get(cacheKey);
-    if (entry) {
-      return opts?.signal ? wrapWithAbort(entry, opts.signal) : entry;
-    }
-  }
-  const request = async () => {
-    const response = await fetch(url, {
-      signal: opts?.signal,
-      cache: opts?.ignoreCache ? "reload" : "default",
-      headers
-    });
-    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 void 0;
-    }
-    return {
-      raw: await response.text()
-    };
-  };
-  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));
-      }
-      return value;
-    });
-  }
-  const promise = request().then((value) => {
-    if (value === void 0) {
-      navFetchCache.delete(cacheKey);
-    }
-    return value;
-  }, (err) => {
-    navFetchCache.delete(cacheKey);
-    throw err;
-  });
-  navFetchCache.set(cacheKey, promise);
-  return promise;
+var getLoaderOptions = (rest) => {
+	let id;
+	let serializationStrategy = DEFAULT_LOADERS_SERIALIZATION_STRATEGY;
+	let cacheControl;
+	let eTag;
+	let cacheKey;
+	let search;
+	let blockSSR = true;
+	const validators = [];
+	if (rest.length === 1) {
+		const options = rest[0];
+		if (options && typeof options === "object") {
+			if ("validate" in options) validators.push(options);
+			else {
+				if (options.id) id = options.id;
+				if (options.serializationStrategy) serializationStrategy = options.serializationStrategy;
+				if (options.validation) validators.push(...options.validation);
+				if ("cacheControl" in options) cacheControl = options.cacheControl;
+				if ("eTag" in options) eTag = options.eTag;
+				if ("cacheKey" in options) cacheKey = options.cacheKey;
+				if (options.search) search = options.search;
+				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;
+				}
+			}
+		}
+	} else if (rest.length > 1) validators.push(...rest.filter(Boolean));
+	return {
+		id,
+		validators: validators.reverse(),
+		serializationStrategy,
+		cacheControl,
+		eTag,
+		cacheKey,
+		search,
+		blockSSR
+	};
 };
-const filterSearchParams = (params, allowed) => {
-  const filtered = new URLSearchParams();
-  for (let i = 0; i < allowed.length; i++) {
-    const name = allowed[i];
-    const values = params.getAll(name);
-    for (let j = 0; j < values.length; j++) {
-      filtered.append(name, values[j]);
-    }
-  }
-  filtered.sort();
-  return filtered.toString() ? `?${filtered.toString()}` : "";
+/**
+* Returns the current RequestEvent if possible. Only usable on the server, and only during request
+* processing.
+*
+* @public
+*/ var getRequestEvent = (thisArg) => {
+	if (!isServer) throw new Error("getRequestEvent() can only be used on the server.");
+	return _asyncRequestStore?.getStore() || [thisArg, _getContextEvent()].find(isRequestEvent);
 };
-const getLoaderOptions = (rest) => {
-  let id;
-  let serializationStrategy = DEFAULT_LOADERS_SERIALIZATION_STRATEGY;
-  let cacheControl;
-  let eTag;
-  let cacheKey;
-  let search;
-  let blockSSR = true;
-  const validators = [];
-  if (rest.length === 1) {
-    const options = rest[0];
-    if (options && typeof options === "object") {
-      if ("validate" in options) {
-        validators.push(options);
-      } else {
-        if (options.id) {
-          id = options.id;
-        }
-        if (options.serializationStrategy) {
-          serializationStrategy = options.serializationStrategy;
-        }
-        if (options.validation) {
-          validators.push(...options.validation);
-        }
-        if ("cacheControl" in options) {
-          cacheControl = options.cacheControl;
-        }
-        if ("eTag" in options) {
-          eTag = options.eTag;
-        }
-        if ("cacheKey" in options) {
-          cacheKey = options.cacheKey;
-        }
-        if (options.search) {
-          search = options.search;
-        } 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;
-        }
-      }
-    }
-  } else if (rest.length > 1) {
-    validators.push(...rest.filter(Boolean));
-  }
-  return {
-    id,
-    validators: validators.reverse(),
-    serializationStrategy,
-    cacheControl,
-    eTag,
-    cacheKey,
-    search,
-    blockSSR
-  };
-};
-const getRequestEvent = (thisArg) => {
-  if (!isServer$1) {
-    throw new Error("getRequestEvent() can only be used on the server.");
-  }
-  return _asyncRequestStore?.getStore() || [
-    thisArg,
-    _getContextEvent()
-  ].find(isRequestEvent);
-};
-const REQUEST_ROUTE_LOADER_VALUES = "@routeLoaderValues";
-function getRouteLoaderValues(requestEv) {
-  let values = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_VALUES);
-  if (!values) {
-    values = {};
-    requestEv.sharedMap.set(REQUEST_ROUTE_LOADER_VALUES, values);
-  }
-  return values;
+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);
+	if (!values) {
+		values = {};
+		requestEv.sharedMap.set(REQUEST_ROUTE_LOADER_VALUES, values);
+	}
+	return values;
 }
 function getRouteLoaderPromises(requestEv) {
-  let promises = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_PROMISES);
-  if (!promises) {
-    promises = {};
-    requestEv.sharedMap.set(REQUEST_ROUTE_LOADER_PROMISES, promises);
-  }
-  return promises;
+	let promises = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_PROMISES);
+	if (!promises) {
+		promises = {};
+		requestEv.sharedMap.set(REQUEST_ROUTE_LOADER_PROMISES, promises);
+	}
+	return promises;
 }
-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(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);
 }
-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(requestEv, loaders) {
+	requestEv.sharedMap.set(REQUEST_ROUTE_LOADERS, loaders);
 }
-function getRouteLoaders(requestEv) {
-  return requestEv.sharedMap.get(REQUEST_ROUTE_LOADERS) ?? [];
+/** Get the route loader internals stored on the request. */ function getRouteLoaders(requestEv) {
+	return requestEv.sharedMap.get(REQUEST_ROUTE_LOADERS) ?? [];
 }
 function getRouteLoaderCtx(requestEv) {
-  let ctx = requestEv.sharedMap.get(REQUEST_LOADER_PATHS_STORE);
-  if (!ctx) {
-    ctx = {
-      loaderPaths: {}
-    };
-    requestEv.sharedMap.set(REQUEST_LOADER_PATHS_STORE, ctx);
-  }
-  return ctx;
+	let ctx = requestEv.sharedMap.get(REQUEST_LOADER_PATHS_STORE);
+	if (!ctx) {
+		ctx = { loaderPaths: {} };
+		requestEv.sharedMap.set(REQUEST_LOADER_PATHS_STORE, ctx);
+	}
+	return ctx;
 }
-const updateRouteLoaderPaths = (ctx, loaderPaths, pageUrl) => {
-  if (!isServer$1) {
-    ctx.pagePathname = pageUrl.pathname;
-    ctx.pageSearch = pageUrl.search;
-    if (isDev) {
-      ctx.devRouteLoaderPaths = {};
-    }
-  }
-  if (loaderPaths) {
-    for (const key in loaderPaths) {
-      ctx.loaderPaths[key] = loaderPaths[key];
-      if (!isServer$1 && isDev) {
-        ctx.devRouteLoaderPaths[key] = true;
-      }
-    }
-  }
+/**
+* Update the loader paths store on client-side navigation.
+*
+* Only adds/updates entries for loaders present on the new route. Entries for loaders that are NOT
+* on the new route are left untouched — their ComputedSignals keep their prior values, and no
+* track() fires to invalidate them. If the user navigates back to a route where the loader IS
+* present, the path updates and the signal re-fetches. This is the "stale is fine by default"
+* contract: readers see old data until new data arrives.
+*/ var updateRouteLoaderPaths = (ctx, loaderPaths, pageUrl) => {
+	if (!isServer) {
+		ctx.pagePathname = pageUrl.pathname;
+		ctx.pageSearch = pageUrl.search;
+		if (isDev) ctx.devRouteLoaderPaths = {};
+	}
+	if (loaderPaths) for (const key in loaderPaths) {
+		ctx.loaderPaths[key] = loaderPaths[key];
+		if (!isServer && isDev) ctx.devRouteLoaderPaths[key] = true;
+	}
 };
-const getModuleRouteLoaders = (mods) => {
-  const routeLoaders = [];
-  const seen = /* @__PURE__ */ new Map();
-  for (let i = 0; i < mods.length; i++) {
-    const mod = mods[i];
-    if (!mod) {
-      continue;
-    }
-    for (const key in mod) {
-      const value = mod[key];
-      if (isLoaderInternal(value)) {
-        const existing = seen.get(value.__id);
-        if (existing) {
-          if (isDev && existing !== value) {
-            console.warn(`Two route loaders share the same id "${value.__id}". Only the first will run; the others are ignored. If they are created by a shared wrapper around routeLoader$, give each loader a distinct \`id\` option.`);
-          }
-          continue;
-        }
-        seen.set(value.__id, value);
-        routeLoaders.push(value);
-      }
-    }
-  }
-  return routeLoaders;
+var getModuleRouteLoaders = (mods) => {
+	const routeLoaders = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (let i = 0; i < mods.length; i++) {
+		const mod = mods[i];
+		if (!mod) continue;
+		for (const key in mod) {
+			const value = mod[key];
+			if (isLoaderInternal(value)) {
+				const existing = seen.get(value.__id);
+				if (existing) {
+					if (isDev && existing !== value) console.warn(`Two route loaders share the same id "${value.__id}". Only the first will run; the others are ignored. If they are created by a shared wrapper around routeLoader$, give each loader a distinct \`id\` option.`);
+					continue;
+				}
+				seen.set(value.__id, value);
+				routeLoaders.push(value);
+			}
+		}
+	}
+	return routeLoaders;
 };
-const immutableLoaderIds = /* @__PURE__ */ new Set();
-const isImmutableLoader = (loaderId) => immutableLoaderIds.has(loaderId);
-const invalidateNavRouteLoaders = (state) => {
-  for (const id in state) {
-    if (!id.startsWith(ROUTE_LOADER_VALUE_PREFIX) && !immutableLoaderIds.has(id)) {
-      state[id].invalidate();
-    }
-  }
+/**
+* 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();
+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();
 };
-const setLoaderSignalValue = (signal, value) => {
-  _injectAsyncSignalValue(signal, value);
+/**
+* Inject a pre-loaded value into a ComputedSignal while preserving subscriptions. Delegates to the
+* core helper which calls `invalidate({__v})` + `$computeIfNeeded$()` so the compute function runs
+* 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) => {
+	_injectAsyncSignalValue(signal, value);
 };
-const matchesRouteLoaderId = (loader, loaderId) => {
-  return typeof loaderId === "string" && (loader.__id === loaderId || isDev && loader.__qrl.getHash() === loaderId);
+var matchesRouteLoaderId = (loader, loaderId) => {
+	return typeof loaderId === "string" && (loader.__id === loaderId || isDev && loader.__qrl.getHash() === loaderId);
 };
-const resolveRouteLoaderByHash = (routeLoaders, loaderId) => {
-  return routeLoaders.find((loader) => matchesRouteLoaderId(loader, loaderId));
+var resolveRouteLoaderByHash = (routeLoaders, loaderId) => {
+	return routeLoaders.find((loader) => matchesRouteLoaderId(loader, loaderId));
 };
-const getLoaderRequestEvent = (loader, requestEv) => {
-  let rootRequestEv = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_ROOT_EVENT);
-  if (!rootRequestEv) {
-    rootRequestEv = requestEv;
-    requestEv.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;
-  }
-  let events = rootRequestEv.sharedMap.get(REQUEST_ROUTE_LOADER_EVENTS);
-  if (!events) {
-    events = /* @__PURE__ */ new Map();
-    rootRequestEv.sharedMap.set(REQUEST_ROUTE_LOADER_EVENTS, events);
-  }
-  const eventKey = `${pathname}
-${filteredSearch}`;
-  let loaderRequestEv = events.get(eventKey);
-  if (!loaderRequestEv) {
-    url.pathname = pathname;
-    url.search = filteredSearch;
-    const request = new Request(url, rootRequestEv.request);
-    loaderRequestEv = Object.create(rootRequestEv, {
-      originalUrl: {
-        value: new URL(url),
-        enumerable: true
-      },
-      params: {
-        value: {},
-        enumerable: true
-      },
-      pathname: {
-        get: () => url.pathname,
-        enumerable: true
-      },
-      query: {
-        get: () => url.searchParams,
-        enumerable: true
-      },
-      request: {
-        value: request,
-        enumerable: true
-      },
-      url: {
-        value: url,
-        enumerable: true
-      }
-    });
-    events.set(eventKey, loaderRequestEv);
-  }
-  return loaderRequestEv;
+/** @internal */ var getLoaderRequestEvent = (loader, requestEv) => {
+	let rootRequestEv = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_ROOT_EVENT);
+	if (!rootRequestEv) {
+		rootRequestEv = requestEv;
+		requestEv.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;
+	let events = rootRequestEv.sharedMap.get(REQUEST_ROUTE_LOADER_EVENTS);
+	if (!events) {
+		events = /* @__PURE__ */ new Map();
+		rootRequestEv.sharedMap.set(REQUEST_ROUTE_LOADER_EVENTS, events);
+	}
+	const eventKey = `${pathname}\n${filteredSearch}`;
+	let loaderRequestEv = events.get(eventKey);
+	if (!loaderRequestEv) {
+		url.pathname = pathname;
+		url.search = filteredSearch;
+		const request = new Request(url, rootRequestEv.request);
+		loaderRequestEv = Object.create(rootRequestEv, {
+			originalUrl: {
+				value: new URL(url),
+				enumerable: true
+			},
+			params: {
+				value: {},
+				enumerable: true
+			},
+			pathname: {
+				get: () => url.pathname,
+				enumerable: true
+			},
+			query: {
+				get: () => url.searchParams,
+				enumerable: true
+			},
+			request: {
+				value: request,
+				enumerable: true
+			},
+			url: {
+				value: url,
+				enumerable: true
+			}
+		});
+		events.set(eventKey, loaderRequestEv);
+	}
+	return loaderRequestEv;
 };
-const detachResponseFromEvent = (requestEv) => {
-  let status = 200;
-  const headers = new Headers();
-  return Object.create(requestEv, {
-    headers: {
-      value: headers,
-      enumerable: true
-    },
-    status: {
-      value: (statusCode) => {
-        if (typeof statusCode === "number") {
-          status = statusCode;
-        }
-        return status;
-      },
-      enumerable: true
-    },
-    error: {
-      value: (statusCode, message) => {
-        status = statusCode;
-        return new ServerError(statusCode, message);
-      },
-      enumerable: true
-    },
-    redirect: {
-      value: (statusCode, url) => {
-        status = statusCode;
-        if (url) {
-          headers.set("Location", url);
-        }
-        return new RedirectMessage();
-      },
-      enumerable: true
-    },
-    fail: {
-      value: (statusCode, data) => {
-        status = statusCode;
-        return {
-          failed: true,
-          ...data
-        };
-      },
-      enumerable: true
-    },
-    // A background loader cannot set the page's cache headers.
-    cacheControl: {
-      value: () => {
-      },
-      enumerable: true
-    }
-  });
+/**
+* View of a request event whose response controls (status/headers/redirect/error/fail/cacheControl)
+* 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) => {
+	let status = 200;
+	const headers = new Headers();
+	return Object.create(requestEv, {
+		headers: {
+			value: headers,
+			enumerable: true
+		},
+		status: {
+			value: (statusCode) => {
+				if (typeof statusCode === "number") status = statusCode;
+				return status;
+			},
+			enumerable: true
+		},
+		error: {
+			value: (statusCode, message) => {
+				status = statusCode;
+				return new ServerError(statusCode, message);
+			},
+			enumerable: true
+		},
+		redirect: {
+			value: (statusCode, url) => {
+				status = statusCode;
+				if (url) headers.set("Location", url);
+				return new RedirectMessage();
+			},
+			enumerable: true
+		},
+		fail: {
+			value: (statusCode, data) => {
+				status = statusCode;
+				return {
+					failed: true,
+					...data
+				};
+			},
+			enumerable: true
+		},
+		cacheControl: {
+			value: () => {},
+			enumerable: true
+		}
+	});
 };
 async function runValidators(requestEv, validators, data) {
-  let lastResult = {
-    success: true,
-    data
-  };
-  if (validators) {
-    for (let i = 0; i < validators.length; i++) {
-      const validator = validators[i];
-      lastResult = await validator.validate(requestEv, data);
-      if (!lastResult.success) {
-        return lastResult;
-      }
-      data = lastResult.data;
-    }
-  }
-  return lastResult;
+	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;
-  }
+	try {
+		_verifySerializable(data, void 0);
+	} catch (error) {
+		if (error instanceof Error && qrl.dev) error.loc = qrl.dev;
+		throw error;
+	}
 }
-const 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;
+/** 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;
 };
-const 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 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;
 };
-class ServerRouteLoaderCapture {
-  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;
-  }
-}
-const createRouteLoaderSignal = (loader, routeLoaderCtx, state) => {
-  const id = loader.__id;
-  const stateValues = state;
-  const resumeValueKey = getRouteLoaderValueStateKey(id);
-  const capture = isServer$1 ? new ServerRouteLoaderCapture(id, loader.__qrl, loader.__validators, loader.__blockSSR) : id;
-  const searchFilter = loader.__search;
-  const lastFetch = {};
-  const signal = createComputedQrl(/* @__PURE__ */ inlinedQrl(async (ctx) => {
-    const capture2 = _captures[0], id2 = _captures[1], lastFetch2 = _captures[2], resumeValueKey2 = _captures[3], routeLoaderCtx2 = _captures[4], searchFilter2 = _captures[5], stateValues2 = _captures[6];
-    const hasInjectedValue = !!ctx.info && typeof ctx.info === "object" && "__v" in ctx.info;
-    const trackedRoutePath = ctx.track(routeLoaderCtx2.loaderPaths, id2);
-    const trackedPagePathname = ctx.track(routeLoaderCtx2, "pagePathname");
-    const trackedPageSearch = ctx.track(routeLoaderCtx2, "pageSearch");
-    if (hasInjectedValue) {
-      const value = ctx.info.__v;
-      if (!isServer$1 && resumeValueKey2 in stateValues2) {
-        stateValues2[resumeValueKey2] = value;
-      }
-      lastFetch2.raw = void 0;
-      return value;
-    }
-    if (isServer$1) {
-      return capture2.load();
-    }
-    const pagePathname = trackedPagePathname || location.pathname;
-    const pageSearch = trackedPageSearch || location.search;
-    const pageUrl = new URL(pagePathname + pageSearch, location.href);
-    const mHash = routeLoaderCtx2.manifestHash || "dev";
-    const basePath = qwikRouterConfig.basePathname ?? "/";
-    const needsResumeFetch = stateValues2[resumeValueKey2] === _UNINITIALIZED;
-    const fetchRoutePath = trackedRoutePath || (needsResumeFetch ? pageUrl.pathname : void 0);
-    if (!fetchRoutePath) {
-      return ctx.previous;
-    }
-    let fetchUrl = pageUrl;
-    if (searchFilter2) {
-      fetchUrl = new URL(pageUrl.href);
-      fetchUrl.search = filterSearchParams(pageUrl.searchParams, searchFilter2);
-    }
-    const result = await fetchRouteLoaderData(id2, fetchRoutePath, mHash, {
-      pageUrl: fetchUrl,
-      basePath,
-      ignoreCache: ctx.info === true,
-      signal: ctx.abortSignal
-    });
-    if (!result) {
-      throw new Error(`Loader ${id2} returned empty response`);
-    }
-    let response;
-    if (result.raw === void 0) {
-      response = result;
-    } else {
-      if (result.raw === lastFetch2.raw && ctx.previous !== void 0) {
-        return ctx.previous;
-      }
-      response = await _deserialize(result.raw);
-      if (!response) {
-        throw new Error(`Loader ${id2} returned empty response`);
-      }
-    }
-    if (response.r) {
-      const goto = routeLoaderCtx2.goto;
-      if (goto) {
-        goto(response.r, {
-          replaceState: true
-        });
-      } else {
-        location.href = response.r;
-      }
-      return ctx.previous;
-    }
-    if (response.e) {
-      throw response.e;
-    }
-    lastFetch2.raw = result.raw;
-    if (needsResumeFetch) {
-      stateValues2[resumeValueKey2] = response.d;
-    }
-    return response.d;
-  }, "createRouteLoaderSignal_signal_createComputed_4s4ZDCYhDOA", [
-    capture,
-    id,
-    lastFetch,
-    resumeValueKey,
-    routeLoaderCtx,
-    searchFilter,
-    stateValues
-  ]), {
-    serializationStrategy: loader.__serializationStrategy
-  });
-  _markSignalAsExternallyOwned(signal);
-  return signal;
+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;
+	}
 };
-const ensureRouteLoaderSignal = (loader, state, routeLoaderCtx) => {
-  if (loader.__cacheControl === "immutable") {
-    immutableLoaderIds.add(loader.__id);
-  }
-  if (isServer$1 && loader.__serializationStrategy === "never") {
-    state[getRouteLoaderValueStateKey(loader.__id)] = _UNINITIALIZED;
-  }
-  return state[loader.__id] ||= createRouteLoaderSignal(loader, routeLoaderCtx, state);
+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;
 };
-const ensureRouteLoaderSignals = (mods, state, routeLoaderCtx) => {
-  const loaders = getModuleRouteLoaders(mods);
-  for (let i = 0; i < loaders.length; i++) {
-    const loader = loaders[i];
-    if (isDev && !isServer$1) {
-      const devCtx = routeLoaderCtx;
-      if (devCtx.pagePathname && !devCtx.devRouteLoaderPaths?.[loader.__id]) {
-        devCtx.loaderPaths[loader.__id] = devCtx.pagePathname;
-      }
-    }
-    ensureRouteLoaderSignal(loader, state, routeLoaderCtx);
-  }
-  return loaders;
+var ensureRouteLoaderSignal = (loader, state, 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);
 };
-const loadRouteLoader = (loader, requestEv) => {
-  const loaderEv = getLoaderRequestEvent(loader, requestEv);
-  return loadRouteLoaderByQrl(
-    loader.__id,
-    loader.__qrl,
-    loader.__validators,
-    // A background (blockSSR:false) loader must not touch the page response.
-    loader.__blockSSR ? loaderEv : detachResponseFromEvent(loaderEv)
-  );
+var ensureRouteLoaderSignals = (mods, state, routeLoaderCtx) => {
+	const loaders = getModuleRouteLoaders(mods);
+	for (let i = 0; i < loaders.length; i++) {
+		const loader = loaders[i];
+		if (isDev && !isServer) {
+			const devCtx = routeLoaderCtx;
+			if (devCtx.pagePathname && !devCtx.devRouteLoaderPaths?.[loader.__id]) devCtx.loaderPaths[loader.__id] = devCtx.pagePathname;
+		}
+		ensureRouteLoaderSignal(loader, state, routeLoaderCtx);
+	}
+	return loaders;
 };
-const getRouteLoaderResponse = async (loaderQrl, validators, requestEv) => {
-  try {
-    const value = await getRouteLoaderData(loaderQrl, validators, requestEv);
-    return {
-      d: value
-    };
-  } catch (err) {
-    if (err instanceof RedirectMessage) {
-      const location1 = requestEv.headers.get("Location") || "/";
-      requestEv.headers.delete("Location");
-      return {
-        r: location1
-      };
-    }
-    if (err instanceof ServerError) {
-      return {
-        e: err
-      };
-    }
-    throw err;
-  }
+var loadRouteLoader = (loader, requestEv) => {
+	const loaderEv = getLoaderRequestEvent(loader, requestEv);
+	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) => {
+	try {
+		return { d: await getRouteLoaderData(loaderQrl, validators, requestEv) };
+	} catch (err) {
+		if (err instanceof RedirectMessage) {
+			const location1 = requestEv.headers.get("Location") || "/";
+			requestEv.headers.delete("Location");
+			return { r: location1 };
+		}
+		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);
+	function loader() {
+		const state = _resolveContextWithoutSequentialScope(RouteStateContext);
+		let signal = state[loader.__id];
+		if (!signal) signal = ensureRouteLoaderSignal(loader, state, _resolveContextWithoutSequentialScope(RouteLoaderCtxContext));
+		signal.promise();
+		return signal;
+	}
+	loader.__brand = "server_loader";
+	loader.__qrl = loaderQrl;
+	loader.__validators = validators;
+	loader.__id = id ?? loaderQrl.getHash();
+	loader.__serializationStrategy = serializationStrategy;
+	loader.__cacheControl = cacheControl;
+	loader.__eTag = eTag;
+	loader.__cacheKey = cacheKey;
+	loader.__search = search;
+	loader.__blockSSR = blockSSR;
+	Object.freeze(loader);
+	return loader;
+};
+/**
+* Define a route loader that fetches data before the route renders.
+*
+* Route loaders run on the server during SSR and return data as a `ComputedSignal`. On the client,
+* loaders automatically re-fetch when the route changes (SPA navigation). Each loader gets its own
+* JSON endpoint (`q-loader-{id}.{hash}.json`), so only the loaders present on the target route are
+* fetched.
+*
+* **Important:** Route loader data uses Qwik's custom serialization format, not standard JSON. This
+* means the data supports features like circular references, Dates, and other non-JSON types, but
+* it cannot be consumed by external clients expecting plain JSON.
+*
+* ## Options
+*
+* - `search: string[]`: Allowlist of URL search params the loader depends on. Only listed params are
+*   sent in the request and changes to other params are ignored. During SSR and loader JSON
+*   requests, the loader's request event is filtered to those params too. `search: []` means no
+*   search params are sent and only route path changes trigger a re-fetch.
+* - `eTag`: Enable ETag-based caching. Can be `true` (auto-hash), a string, or a function.
+* - `cacheControl`: Cache-Control for loader JSON responses; the browser HTTP cache controls
+*   client-side freshness. `'immutable'` additionally lets SSG write the loader file.
+*
+* The `strictLoaders` Vite plugin option applies `search: []` globally for all loaders that don't
+* specify an explicit `search` option.
+*
+* @public
+*/ var routeLoader$ = /*#__PURE__*/ implicit$FirstArg(routeLoaderQrl);
+var deepFreeze = (obj) => {
+	if (obj == null) return obj;
+	Object.getOwnPropertyNames(obj).forEach((prop) => {
+		const value = obj[prop];
+		if (value && typeof value === "object" && !Object.isFrozen(value)) try {
+			deepFreeze(value);
+		} catch {
+			return 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) {
+	let node = root;
+	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;
+		if (node._L) layouts.push(node._L);
+	}
+	return {
+		node,
+		layouts
+	};
+}
+/**
+* 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;
+/**
+* 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 = "/") {
+	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._E) {
+			errorLoaderRef.v = g._E;
+			errorLoaderRef.layouts = [...layouts];
+		}
+		if (g._4) {
+			notFoundLoaderRef.v = g._4;
+			notFoundLoaderRef.layouts = [...layouts];
+		}
+		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._E) {
+		errorLoaderRef.v = node._E;
+		errorLoaderRef.layouts = [...layouts];
+	}
+	if (node._4) {
+		notFoundLoaderRef.v = node._4;
+		notFoundLoaderRef.layouts = [...layouts];
+	}
+	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) {
+	let next = node._W;
+	if (next) {
+		const prefix = next._0;
+		const suffix = next._9;
+		if (prefix || suffix) {
+			const pre = prefix || "";
+			const suf = suffix || "";
+			if (partLower.length > pre.length + suf.length && (!pre || partLower.startsWith(pre.toLowerCase())) && (!suf || partLower.endsWith(suf.toLowerCase()))) {
+				const paramName = next._P;
+				const value = part.slice(pre.length, suf ? part.length - suf.length : void 0);
+				return {
+					next,
+					routePart: `${pre}[${paramName}]${suf}`,
+					done: false,
+					kind: 1,
+					paramName,
+					paramValue: value
+				};
+			}
+		} else {
+			const paramName = next._P;
+			return {
+				next,
+				routePart: `[${paramName}]`,
+				done: false,
+				kind: 1,
+				paramName,
+				paramValue: part
+			};
+		}
+	}
+	next = node._A;
+	if (next) {
+		const paramName = next._P;
+		const restValue = parts.slice(partIndex).join("/");
+		return {
+			next,
+			routePart: `[...${paramName}]`,
+			done: true,
+			kind: 2,
+			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) {
+	const value = hit(node);
+	if (value !== void 0) return {
+		value,
+		node,
+		groups: []
+	};
+	if (node._M) for (let j = 0; j < node._M.length; j++) {
+		const group = node._M[j];
+		const result = descendGroups(group, hit);
+		if (result) {
+			result.groups.unshift(group);
+			return result;
+		}
+	}
+}
+/**
+* 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) {
+	const r = descendGroups(node, (n) => n._I || n._G != null ? n : void 0);
+	return r ? {
+		target: r.node,
+		groups: r.groups.filter((g) => g !== r.node)
+	} : 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) {
+	const r = descendGroups(node, (n) => n._A);
+	return r ? {
+		next: r.value,
+		groups: r.groups
+	} : void 0;
+}
+/**
+* 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) {
+	const r = descendGroups(node, (n) => n[kind]);
+	if (!r) return;
+	const groupLayouts = [...layouts];
+	for (const g of r.groups) if (g._L) groupLayouts.push(g._L);
+	return {
+		v: r.value,
+		layouts: groupLayouts
+	};
+}
+/**
+* Match a URL pathname against the route trie.
+*
+* Always returns a result. When no route matches, `notFound` is true and `loaders` contains only
+* the error component (from the nearest `_E` or `_4` ancestor, or the built-in fallback).
+*
+* 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) {
+	let node = root;
+	const params = {};
+	const routeParts = [];
+	const layouts = [];
+	const loaderHashes = [];
+	const loaderPathsByHash = {};
+	const errorLoaderRef = {
+		v: void 0,
+		layouts: []
+	};
+	const notFoundLoaderRef = {
+		v: void 0,
+		layouts: []
+	};
+	const menuLoaderRef = { v: void 0 };
+	const groupNodes = [];
+	collectNodeMeta(root, [], layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash);
+	if (root._M) groupNodes.push({
+		node: root,
+		depth: layouts.length
+	});
+	let done = false;
+	let matched = true;
+	const parts = pathname.split("/").filter((p) => p.length > 0).map(decodeURIComponent);
+	let restFallback;
+	let i = 0;
+	const len = parts.length;
+	for (; !done && i < len; i++) {
+		const part = parts[i];
+		const partLower = part.toLowerCase();
+		const found = findChild(node, part, partLower, parts, i);
+		if (!found) {
+			matched = false;
+			break;
+		}
+		const restInfo = found.kind === 1 ? findRestNode(node) : void 0;
+		if (restInfo) restFallback = {
+			aNode: restInfo.next,
+			groups: restInfo.groups,
+			paramName: restInfo.next._P,
+			restValue: parts.slice(i).join("/"),
+			routeParts: [...routeParts],
+			params: { ...params },
+			layouts: [...layouts],
+			loaderPathsByHash: { ...loaderPathsByHash },
+			errorLoader: errorLoaderRef.v,
+			errorLayouts: errorLoaderRef.layouts,
+			notFoundLoader: notFoundLoaderRef.v,
+			notFoundLayouts: notFoundLoaderRef.layouts,
+			menuLoader: menuLoaderRef.v
+		};
+		if (found.paramName) params[found.paramName] = found.paramValue;
+		routeParts.push(found.routePart);
+		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);
+		if (node._M) groupNodes.push({
+			node,
+			depth: layouts.length
+		});
+	}
+	if (matched && !done && i === len) {
+		if (!node._I && node._G == null) {
+			const indexResult = findIndexNode(node);
+			if (indexResult) {
+				collectNodeMeta(indexResult.target, indexResult.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, pathname);
+				node = indexResult.target;
+			}
+		}
+		if (!node._I && node._G == null) {
+			const restInfo = findRestNode(node);
+			if (restInfo) {
+				const next = restInfo.next;
+				const paramName = next._P;
+				params[paramName] = "";
+				routeParts.push(`[...${paramName}]`);
+				collectNodeMeta(next, restInfo.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, pathname);
+				node = next;
+			}
+		}
+	}
+	const loaders = matched && (done || i >= len) ? resolveLoaders(root, node, layouts) : void 0;
+	if (!loaders && restFallback) {
+		const fb = restFallback;
+		const fbParams = {
+			...fb.params,
+			[fb.paramName]: fb.restValue
+		};
+		const fbRouteParts = [...fb.routeParts, `[...${fb.paramName}]`];
+		const fbLayouts = [...fb.layouts];
+		const fbLoaderPathsByHash = { ...fb.loaderPathsByHash };
+		const fbErrorRef = {
+			v: fb.errorLoader,
+			layouts: fb.errorLayouts
+		};
+		const fbNotFoundRef = {
+			v: fb.notFoundLoader,
+			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)
+		};
+		errorLoaderRef.v = fbErrorRef.v;
+		errorLoaderRef.layouts = fbErrorRef.layouts;
+		notFoundLoaderRef.v = fbNotFoundRef.v;
+		notFoundLoaderRef.layouts = fbNotFoundRef.layouts;
+		menuLoaderRef.v = fbMenuRef.v;
+	}
+	if (!loaders) {
+		const recover = (kind) => {
+			for (let k = groupNodes.length - 1; k >= 0; k--) {
+				const found = findGroupBoundary(groupNodes[k].node, layouts.slice(0, groupNodes[k].depth), kind);
+				if (found) return found;
+			}
+		};
+		if (!notFoundLoaderRef.v) {
+			const g = recover("_4");
+			if (g) {
+				notFoundLoaderRef.v = g.v;
+				notFoundLoaderRef.layouts = g.layouts;
+			}
+		}
+		if (!errorLoaderRef.v) {
+			const g = recover("_E");
+			if (g) {
+				errorLoaderRef.v = g.v;
+				errorLoaderRef.layouts = g.layouts;
+			}
+		}
+		const ref = notFoundLoaderRef.v ? notFoundLoaderRef : errorLoaderRef.v ? errorLoaderRef : null;
+		const boundary = ref?.v ?? httpErrorLoader;
+		const boundaryLayouts = ref ? ref.layouts : layouts;
+		return {
+			loaders: Array.isArray(boundary) ? boundary : [...boundaryLayouts, boundary],
+			params,
+			routeParts,
+			notFound: true,
+			routeBundleNames: void 0,
+			loaderHashes: void 0,
+			loaderPathsByHash: 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;
+		}
+	}
+	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,
+		menuLoader: menuLoaderRef.v,
+		errorLoader: boundaryChain(errorLoaderRef)
+	};
+}
+var loadModule = (moduleLoader, pendingLoads, moduleSetter, cacheModules) => {
+	if (typeof moduleLoader === "function") {
+		const loadedModule = MODULE_CACHE.get(moduleLoader);
+		if (loadedModule) moduleSetter(loadedModule);
+		else {
+			const moduleOrPromise = moduleLoader();
+			if (typeof moduleOrPromise.then === "function") pendingLoads.push(moduleOrPromise.then((loadedModule) => {
+				if (cacheModules !== false) MODULE_CACHE.set(moduleLoader, loadedModule);
+				moduleSetter(loadedModule);
+			}));
+			else if (moduleOrPromise) moduleSetter(moduleOrPromise);
+		}
+	}
 };
-const routeLoaderQrl = (loaderQrl, ...rest) => {
-  const { id, validators, serializationStrategy, cacheControl, eTag, cacheKey, search, blockSSR } = getLoaderOptions(rest);
-  function loader() {
-    const state = _resolveContextWithoutSequentialScope(RouteStateContext);
-    let signal = state[loader.__id];
-    if (!signal) {
-      const routeLoaderCtx = _resolveContextWithoutSequentialScope(RouteLoaderCtxContext);
-      signal = ensureRouteLoaderSignal(loader, state, routeLoaderCtx);
-    }
-    void signal.promise();
-    return signal;
-  }
-  loader.__brand = "server_loader";
-  loader.__qrl = loaderQrl;
-  loader.__validators = validators;
-  loader.__id = id ?? loaderQrl.getHash();
-  loader.__serializationStrategy = serializationStrategy;
-  loader.__cacheControl = cacheControl;
-  loader.__eTag = eTag;
-  loader.__cacheKey = cacheKey;
-  loader.__search = search;
-  loader.__blockSSR = blockSSR;
-  Object.freeze(loader);
-  return loader;
+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);
+	}
+	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
+	};
 };
-const routeLoader$ = /* @__PURE__ */ implicit$FirstArg(routeLoaderQrl);
-
-const toPath = (url) => url.pathname + url.search + url.hash;
-const toUrl = (url, baseUrl) => new URL(url, baseUrl.href);
-const isSameOrigin = (a, b) => a.origin === b.origin;
-const isSamePathname = ({ pathname: a }, { pathname: b }) => {
-  const lDiff = Math.abs(a.length - b.length);
-  return lDiff === 0 ? a === b : lDiff === 1 && ensureSlash(a) === ensureSlash(b);
+/** 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);
 };
-const isSameSearchQuery = (a, b) => a.search === b.search;
-const isSamePath = (a, b) => isSameSearchQuery(a, b) && isSamePathname(a, b);
-const getClientNavPath = (props, baseUrl) => {
-  const href = props.href;
-  if (typeof href === "string" && typeof props.target !== "string" && !props.reload) {
-    try {
-      const linkUrl = toUrl(href.trim(), baseUrl.url);
-      const currentUrl = toUrl("", baseUrl.url);
-      if (isSameOrigin(linkUrl, currentUrl)) {
-        return toPath(linkUrl);
-      }
-    } catch (e) {
-      console.error(e);
-    }
-  } else if (props.reload) {
-    return toPath(toUrl("", baseUrl.url));
-  }
-  return null;
+/** 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 {
+		const linkUrl = toUrl(href.trim(), baseUrl.url);
+		if (isSameOrigin(linkUrl, toUrl("", baseUrl.url))) return toPath(linkUrl);
+	} catch (e) {
+		console.error(e);
+	}
+	else if (props.reload) return toPath(toUrl("", baseUrl.url));
+	return null;
 };
-const shouldPreload = (clientNavPath, currentLoc) => {
-  if (clientNavPath) {
-    const prefetchUrl = toUrl(clientNavPath, currentLoc.url);
-    const currentUrl = toUrl("", currentLoc.url);
-    return !isSamePathname(prefetchUrl, currentUrl);
-  }
-  return false;
+var shouldPreload = (clientNavPath, currentLoc) => {
+	if (clientNavPath) return !isSamePathname(toUrl(clientNavPath, currentLoc.url), toUrl("", currentLoc.url));
+	return false;
 };
-const isPromise = (value) => {
-  return value && typeof value.then === "function";
+var isPromise = (value) => {
+	return value && typeof value.then === "function";
 };
-
-const 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 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);
+	}
 };
-const 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 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);
 };
-const createDocumentHead = (defaults, manifestHash) => ({
-  title: defaults?.title || "",
-  meta: [
-    ...defaults?.meta || []
-  ],
-  links: [
-    ...defaults?.links || []
-  ],
-  styles: [
-    ...defaults?.styles || []
-  ],
-  scripts: [
-    ...defaults?.scripts || []
-  ],
-  frontmatter: {
-    ...defaults?.frontmatter
-  },
-  manifestHash: manifestHash || "dev"
+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"
 });
-const resolveRouteConfig = (resolveValue, routeLocation, contentModules, locale, status, defaults) => withLocale(locale, () => {
-  const head = createDocumentHead(defaults);
-  let eTag;
-  let cacheKey;
-  const fns = [];
-  for (let i = 0; i < contentModules.length; i++) {
-    const contentModule = contentModules[i];
-    if (!contentModule) {
-      continue;
-    }
-    const isLast = i === contentModules.length - 1;
-    let config;
-    if (contentModule.routeConfig) {
-      config = contentModule.routeConfig;
-    } else if (contentModule.head) {
-      const synthetic = {
-        head: void 0
-      };
-      const headExport = contentModule.head;
-      if (typeof headExport === "function") {
-        const mod = contentModule;
-        config = (props) => ({
-          head: headExport(props),
-          eTag: mod.eTag,
-          cacheKey: mod.cacheKey
-        });
-      } else {
-        synthetic.head = headExport;
-        const mod = contentModule;
-        if (mod.eTag !== void 0) {
-          synthetic.eTag = mod.eTag;
-        }
-        if (mod.cacheKey !== void 0) {
-          synthetic.cacheKey = mod.cacheKey;
-        }
-        config = synthetic;
-      }
-    } else {
-      const mod = contentModule;
-      if (mod.eTag !== void 0 || mod.cacheKey !== void 0) {
-        config = {
-          eTag: mod.eTag,
-          cacheKey: mod.cacheKey
-        };
-      }
-    }
-    if (!config) {
-      continue;
-    }
-    if (typeof config === "function") {
-      fns.unshift({
-        fn: config,
-        isLast
-      });
-    } else {
-      if (config.head) {
-        resolveDocumentHead(head, config.head);
-      }
-      if (config.eTag !== void 0) {
-        eTag = config.eTag;
-      }
-      if (config.cacheKey !== void 0) {
-        cacheKey = config.cacheKey;
-      }
-    }
-  }
-  if (fns.length) {
-    const headProps = {
-      head,
-      status,
-      withLocale: (fn) => fn(),
-      resolveValue,
-      ...routeLocation
-    };
-    for (const { fn } of fns) {
-      const result = fn(headProps);
-      if (result.head) {
-        resolveDocumentHead(head, result.head);
-      }
-      if (result.eTag !== void 0) {
-        eTag = result.eTag;
-      }
-      if (result.cacheKey !== void 0) {
-        cacheKey = result.cacheKey;
-      }
-    }
-  }
-  return {
-    head,
-    eTag,
-    cacheKey
-  };
+/**
+* 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, () => {
+	const head = createDocumentHead(defaults);
+	let eTag;
+	let cacheKey;
+	const fns = [];
+	for (let i = 0; i < contentModules.length; i++) {
+		const contentModule = contentModules[i];
+		if (!contentModule) continue;
+		const isLast = i === contentModules.length - 1;
+		let config;
+		if (contentModule.routeConfig) config = contentModule.routeConfig;
+		else if (contentModule.head) {
+			const synthetic = { head: void 0 };
+			const headExport = contentModule.head;
+			if (typeof headExport === "function") {
+				const mod = contentModule;
+				config = (props) => ({
+					head: headExport(props),
+					eTag: mod.eTag,
+					cacheKey: mod.cacheKey
+				});
+			} else {
+				synthetic.head = headExport;
+				const mod = contentModule;
+				if (mod.eTag !== void 0) synthetic.eTag = mod.eTag;
+				if (mod.cacheKey !== void 0) synthetic.cacheKey = mod.cacheKey;
+				config = synthetic;
+			}
+		} else {
+			const mod = contentModule;
+			if (mod.eTag !== void 0 || mod.cacheKey !== void 0) config = {
+				eTag: mod.eTag,
+				cacheKey: mod.cacheKey
+			};
+		}
+		if (!config) continue;
+		if (typeof config === "function") fns.unshift({
+			fn: config,
+			isLast
+		});
+		else {
+			if (config.head) resolveDocumentHead(head, config.head);
+			if (config.eTag !== void 0) eTag = config.eTag;
+			if (config.cacheKey !== void 0) cacheKey = config.cacheKey;
+		}
+	}
+	if (fns.length) {
+		const headProps = {
+			head,
+			status,
+			withLocale: (fn) => fn(),
+			resolveValue,
+			...routeLocation
+		};
+		for (const { fn } of fns) {
+			const result = fn(headProps);
+			if (result.head) resolveDocumentHead(head, result.head);
+			if (result.eTag !== void 0) eTag = result.eTag;
+			if (result.cacheKey !== void 0) cacheKey = result.cacheKey;
+		}
+	}
+	return {
+		head,
+		eTag,
+		cacheKey
+	};
 });
-const 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 void 0;
-  };
-  return resolveRouteConfig(getData, routeLocation, contentModules, locale, actionData?.status ?? 200, defaults).head;
+/**
+* Resolve only the document head from all content modules. This is the browser-side entry point
+* that ignores eTag/cacheKey (server-only concerns).
+*
+* 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) => {
+		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 { QFN_KEY as A, QDATA_KEY as B, ContentContext as C, DocumentHeadContext as D, routeLoader$ as E, FULLPATH_HEADER as F, routeLoaderQrl as G, HttpStatusContext as H, getRouteLoaders as I, getRouteLoaderValues as J, loadRouteLoader as K, isPromise as L, getLoaderRequestEvent as M, resolveRouteLoaderByHash as N, getRouteLoaderResponse as O, getRouteLoaderCtx as P, QACTION_KEY as Q, ROUTE_PATH_HEADER as R, setRouteLoaders as S, resolveRouteConfig as T, clearRouteLoaderData as U, matchesRouteLoaderId as V, _asyncRequestStore as _, getClientNavPath as a, isSameOrigin as b, setLoaderSignalValue as c, createDocumentHead as d, ensureRouteLoaderSignals as e, fetchRouteLoaderData as f, getModuleRouteLoaders as g, ContentInternalContext as h, isSamePath as i, RouteLocationContext as j, RouteNavigateContext as k, loadRoute as l, RouteStateContext as m, RouteLoaderCtxContext as n, RouteActionContext as o, RoutePreventNavigateContext as p, invalidateNavRouteLoaders as q, isImmutableLoader as r, shouldPreload as s, toPath as t, updateRouteLoaderPaths as u, clearNavFetchCache as v, resolveHead as w, Q_ROUTE as x, toUrl as y, getRequestEvent as z };
+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 };