@qwik.dev/router 2.0.0-beta.35 → 2.0.0-beta.37

package/lib/chunks/worker-thread.qwik.mjs

@@ -1,12 +1,50 @@
+import { e as ensureSlash } from './pathname.mjs';
+import { isDev, _deserialize, _verifySerializable, _serialize, _getAsyncLocalStorage } from '@qwik.dev/core/internal';
 import { parentPort } from 'node:worker_threads';
-import { isDev, _UNINITIALIZED, _deserialize, _verifySerializable, _serialize, _getAsyncLocalStorage } from '@qwik.dev/core/internal';
-import { withLocale, inlinedQrl } from '@qwik.dev/core';
-import { A as AbortMessage$1 } from './redirect-handler.mjs';
+import { v as deepFreeze, o as getRouteLoaderValues, p as loadRouteLoader, n as getRouteLoaderCtx, q as setRouteLoaders, A as AbortMessage$1, w as getRouteLoaders } from './deepFreeze.qwik.mjs';
+import { Q as QLoaderId$1, I as IsQLoader$1 } from './request-path.mjs';
+import { withLocale, isDev as isDev$1, inlinedQrl } from '@qwik.dev/core';
+import { j as jsonRequestWrapper, l as loaderHandler, f as actionHandler, h as hash, n as normalizeETag, p as performETagMatch, s as setETagHeader } from './action-handler.mjs';
 import { isServer } from '@qwik.dev/core/build';
-import { d as deepFreeze } from './deepFreeze.qwik.mjs';
+
+const IsQLoader = "@isQLoader";
+const IsQAction = "@isQAction";
+const QLoaderId = "@loaderId";
+const QActionId = "@actionId";
+const LOADER_REGEX = /\/(q-loader-([^.]+)\.([^.]+)\.json)$/;
+function recognizeRequest(pathname) {
+  if (pathname.length < 10) {
+    return null;
+  }
+  const loaderMatch = pathname.match(LOADER_REGEX);
+  if (loaderMatch) {
+    return {
+      type: IsQLoader,
+      trimLength: loaderMatch[1].length + 1,
+      data: {
+        loaderId: loaderMatch[2],
+        manifestHash: loaderMatch[3]
+      }
+    };
+  }
+  return null;
+}
+function trimRecognizedInternalPathname(pathname, recognized) {
+  let trimmed = pathname.slice(0, pathname.length - recognized.trimLength) || "/";
+  if (!globalThis.__NO_TRAILING_SLASH__ && !trimmed.endsWith("/")) {
+    trimmed = ensureSlash(trimmed);
+  }
+  return trimmed;
+}
+function trimInternalPathname(pathname) {
+  const recognized = recognizeRequest(pathname);
+  if (recognized) {
+    return trimRecognizedInternalPathname(pathname, recognized);
+  }
+  return pathname;
+}
 
 const QACTION_KEY = "qaction";
-const QLOADER_KEY = "qloaders";
 const QFN_KEY = "qfunc";
 const QDATA_KEY = "qdata";
 const Q_ROUTE = "q:route";
@@ -156,10 +194,12 @@ function walkTrieKeys(root, keys) {
   if (node._L) {
     layouts.push(node._L);
   }
-  for (const key of keys) {
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
     let next = node[key];
     if (!next && node._M) {
-      for (const group of node._M) {
+      for (let j = 0; j < node._M.length; j++) {
+        const group = node._M[j];
         next = group[key];
         if (next) {
           if (group._L) {
@@ -182,11 +222,21 @@ function walkTrieKeys(root, keys) {
     layouts
   };
 }
-function collectNodeMeta(node, groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef) {
-  for (const g of groups) {
+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;
     }
@@ -200,6 +250,15 @@ function collectNodeMeta(node, groups, layouts, errorLoaderRef, notFoundLoaderRe
   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;
   }
@@ -210,7 +269,7 @@ function collectNodeMeta(node, groups, layouts, errorLoaderRef, notFoundLoaderRe
     menuLoaderRef.v = node._N;
   }
 }
-function tryWildcardMatch(node, part, partLower, parts, partIndex, params) {
+function tryWildcardMatch(node, part, partLower, parts, partIndex) {
   let next = node._W;
   if (next) {
     const prefix = next._0;
@@ -221,20 +280,24 @@ function tryWildcardMatch(node, part, partLower, parts, partIndex, params) {
       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);
-        params[paramName] = value;
         return {
           next,
           routePart: `${pre}[${paramName}]${suf}`,
-          done: false
+          done: false,
+          kind: 1,
+          paramName,
+          paramValue: value
         };
       }
     } else {
       const paramName = next._P;
-      params[paramName] = part;
       return {
         next,
         routePart: `[${paramName}]`,
-        done: false
+        done: false,
+        kind: 1,
+        paramName,
+        paramValue: part
       };
     }
   }
@@ -242,35 +305,39 @@ function tryWildcardMatch(node, part, partLower, parts, partIndex, params) {
   if (next) {
     const paramName = next._P;
     const restValue = parts.slice(partIndex).join("/");
-    params[paramName] = restValue;
     return {
       next,
       routePart: `[...${paramName}]`,
-      done: true
+      done: true,
+      kind: 2,
+      paramName,
+      paramValue: restValue
     };
   }
   return void 0;
 }
-function findChild(node, part, partLower, parts, partIndex, params) {
+function findChild(node, part, partLower, parts, partIndex) {
   const exact = node[partLower];
   if (exact) {
     return {
       next: exact,
       groups: [],
       routePart: part,
-      done: false
+      done: false,
+      kind: 0
     };
   }
   if (node._M) {
-    for (const group of node._M) {
-      const groupResult = findChild(group, part, partLower, parts, partIndex, params);
+    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, params);
+  const wildcard = tryWildcardMatch(node, part, partLower, parts, partIndex);
   if (wildcard) {
     return {
       ...wildcard,
@@ -287,7 +354,8 @@ function findIndexNode(node) {
     };
   }
   if (node._M) {
-    for (const group of node._M) {
+    for (let j = 0; j < node._M.length; j++) {
+      const group = node._M[j];
       const result = findIndexNode(group);
       if (result) {
         if (result.target !== group) {
@@ -311,7 +379,8 @@ function resolveLoaders(root, node, gatheredLayouts) {
     if (!targetNode._I && targetNode._G == null) {
       const indexResult = findIndexNode(targetNode);
       if (indexResult) {
-        for (const g of indexResult.groups) {
+        for (let j = 0; j < indexResult.groups.length; j++) {
+          const g = indexResult.groups[j];
           if (g._L) {
             targetLayouts.push(g._L);
           }
@@ -344,7 +413,8 @@ function findRestNode(node) {
     };
   }
   if (node._M) {
-    for (const group of node._M) {
+    for (let j = 0; j < node._M.length; j++) {
+      const group = node._M[j];
       const result = findRestNode(group);
       if (result) {
         result.groups.unshift(group);
@@ -359,6 +429,8 @@ function matchRouteTree(root = {}, pathname) {
   const params = {};
   const routeParts = [];
   const layouts = [];
+  const loaderHashes = [];
+  const loaderPathsByHash = {};
   const errorLoaderRef = {
     v: void 0
   };
@@ -371,6 +443,13 @@ function matchRouteTree(root = {}, pathname) {
   if (root._L) {
     layouts.push(root._L);
   }
+  if (root._R) {
+    loaderHashes.push(...root._R);
+    for (let i2 = 0; i2 < root._R.length; i2++) {
+      const hash = root._R[i2];
+      loaderPathsByHash[hash] = "/";
+    }
+  }
   if (root._E) {
     errorLoaderRef.v = root._E;
   }
@@ -389,7 +468,12 @@ function matchRouteTree(root = {}, pathname) {
   for (; !done && i < len; i++) {
     const part = parts[i];
     const partLower = part.toLowerCase();
-    const restInfo = findRestNode(node);
+    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,
@@ -405,26 +489,28 @@ function matchRouteTree(root = {}, pathname) {
         layouts: [
           ...layouts
         ],
+        loaderPathsByHash: {
+          ...loaderPathsByHash
+        },
         errorLoader: errorLoaderRef.v,
         notFoundLoader: notFoundLoaderRef.v,
         menuLoader: menuLoaderRef.v
       };
     }
-    const found = findChild(node, part, partLower, parts, i, params);
-    if (!found) {
-      matched = false;
-      break;
+    if (found.paramName) {
+      params[found.paramName] = found.paramValue;
     }
     routeParts.push(found.routePart);
     done = found.done;
     node = found.next;
-    collectNodeMeta(node, found.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef);
+    const matchedPathname = `/${parts.slice(0, found.done ? len : i + 1).join("/")}/`;
+    collectNodeMeta(node, found.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, matchedPathname);
   }
   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);
+        collectNodeMeta(indexResult.target, indexResult.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, pathname);
         node = indexResult.target;
       }
     }
@@ -448,7 +534,7 @@ function matchRouteTree(root = {}, pathname) {
         const paramName = next._P;
         params[paramName] = "";
         routeParts.push(`[...${paramName}]`);
-        collectNodeMeta(next, restInfo.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef);
+        collectNodeMeta(next, restInfo.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, pathname);
         node = next;
       }
     }
@@ -467,6 +553,9 @@ function matchRouteTree(root = {}, pathname) {
     const fbLayouts = [
       ...fb.layouts
     ];
+    const fbLoaderPathsByHash = {
+      ...fb.loaderPathsByHash
+    };
     const fbErrorRef = {
       v: fb.errorLoader
     };
@@ -476,7 +565,8 @@ function matchRouteTree(root = {}, pathname) {
     const fbMenuRef = {
       v: fb.menuLoader
     };
-    collectNodeMeta(fb.aNode, fb.groups, fbLayouts, fbErrorRef, fbNotFoundRef, fbMenuRef);
+    const fbLoaderHashes = [];
+    collectNodeMeta(fb.aNode, fb.groups, fbLayouts, fbErrorRef, fbNotFoundRef, fbMenuRef, fbLoaderHashes, fbLoaderPathsByHash, pathname);
     const fbLoaders = resolveLoaders(root, fb.aNode, fbLayouts);
     if (fbLoaders) {
       return {
@@ -485,6 +575,8 @@ function matchRouteTree(root = {}, pathname) {
         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: fbErrorRef.v,
         notFoundLoader: fbNotFoundRef.v
@@ -504,17 +596,29 @@ function matchRouteTree(root = {}, pathname) {
       routeParts,
       notFound: true,
       routeBundleNames: void 0,
+      loaderHashes: void 0,
+      loaderPathsByHash: void 0,
       menuLoader: menuLoaderRef.v,
       errorLoader: errorLoaderRef.v,
       notFoundLoader: notFoundLoaderRef.v
     };
   }
+  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: errorLoaderRef.v,
     notFoundLoader: notFoundLoaderRef.v
@@ -540,19 +644,18 @@ const loadModule = (moduleLoader, pendingLoads, moduleSetter, cacheModules) => {
     }
   }
 };
-const loadRoute = async (routes, cacheModules, pathname, isInternal) => {
+const loadRoute = async (routes, cacheModules, pathname) => {
   const result = matchRouteTree(routes, pathname);
-  const { loaders, params, routeParts, notFound, routeBundleNames, menuLoader, errorLoader, notFoundLoader } = result;
+  const { loaders, params, routeParts, notFound, routeBundleNames, loaderHashes, loaderPathsByHash, menuLoader, errorLoader, notFoundLoader } = result;
   const routeName = "/" + routeParts.join("/");
   const modules = new Array(loaders.length);
   const pendingLoads = [];
-  loaders.forEach((moduleLoader, i) => {
+  for (let i = 0; i < loaders.length; i++) {
+    const moduleLoader = loaders[i];
     loadModule(moduleLoader, pendingLoads, (routeModule) => modules[i] = routeModule, cacheModules);
-  });
-  let menu = void 0;
-  if (!isInternal) {
-    loadModule(menuLoader, pendingLoads, (menuModule) => menu = menuModule?.default, cacheModules);
   }
+  let menu = void 0;
+  loadModule(menuLoader, pendingLoads, (menuModule) => menu = menuModule?.default, cacheModules);
   if (notFound && notFoundLoader) {
     let notFoundMod;
     let errorMod;
@@ -572,7 +675,9 @@ const loadRoute = async (routes, cacheModules, pathname, isInternal) => {
       $menu$: deepFreeze(menu),
       $routeBundleNames$: routeBundleNames,
       $notFound$: notFound,
-      $errorLoader$: errorLoader
+      $errorLoader$: errorLoader,
+      $loaders$: loaderHashes,
+      $loaderPaths$: loaderPathsByHash
     };
   }
   if (pendingLoads.length > 0) {
@@ -585,7 +690,9 @@ const loadRoute = async (routes, cacheModules, pathname, isInternal) => {
     $menu$: deepFreeze(menu),
     $routeBundleNames$: routeBundleNames,
     $notFound$: notFound,
-    $errorLoader$: errorLoader
+    $errorLoader$: errorLoader,
+    $loaders$: loaderHashes,
+    $loaderPaths$: loaderPathsByHash
   };
 };
 
@@ -594,7 +701,38 @@ const isPromise = (value) => {
 };
 
 const MAX_CACHE_SIZE = typeof globalThis.__SSR_CACHE_SIZE__ === "number" ? globalThis.__SSR_CACHE_SIZE__ : 50;
-const ssrCache = /* @__PURE__ */ new Map();
+function createLruCache() {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      const entry = cache.get(key);
+      if (entry !== void 0) {
+        cache.delete(key);
+        cache.set(key, entry);
+      }
+      return entry;
+    },
+    set(key, entry) {
+      if (MAX_CACHE_SIZE <= 0) {
+        return;
+      }
+      if (cache.size >= MAX_CACHE_SIZE) {
+        const firstKey = cache.keys().next().value;
+        cache.delete(firstKey);
+      }
+      cache.set(key, entry);
+    },
+    clear(key) {
+      if (key != null) {
+        cache.delete(key);
+      } else {
+        cache.clear();
+      }
+    }
+  };
+}
+const ssrCache = createLruCache();
+const loaderCache = createLruCache();
 function resolveETag(eTagExport, headProps) {
   if (eTagExport === void 0) {
     return null;
@@ -604,32 +742,36 @@ function resolveETag(eTagExport, headProps) {
   }
   return eTagExport;
 }
-function resolveCacheKey(cacheKeyExport, status, eTag, pathname) {
+function resolveCacheKey(cacheKeyExport, defaultKey, requestEv, eTag) {
   if (cacheKeyExport === true) {
-    return `${status}|${eTag}|${pathname}`;
+    return defaultKey(requestEv, eTag);
   }
   if (typeof cacheKeyExport !== "function") {
-    return null;
+    return "";
   }
-  return cacheKeyExport(status, eTag, pathname);
+  return cacheKeyExport(requestEv, eTag) || "";
 }
-function getCachedHtml(key) {
-  const html = ssrCache.get(key);
-  if (html !== void 0) {
-    ssrCache.delete(key);
-    ssrCache.set(key, html);
-  }
-  return html;
+function defaultSsrCacheKey(requestEv, eTag) {
+  const status = requestEv.status();
+  const pathname = requestEv.url.pathname;
+  return eTag ? `${status}|${eTag}|${pathname}` : `${status}|${pathname}`;
 }
-function setCachedHtml(key, html) {
-  if (MAX_CACHE_SIZE <= 0) {
-    return;
-  }
-  if (ssrCache.size >= MAX_CACHE_SIZE) {
-    const firstKey = ssrCache.keys().next().value;
-    ssrCache.delete(firstKey);
-  }
-  ssrCache.set(key, html);
+function defaultLoaderCacheKey(requestEv, eTag) {
+  const loaderId = requestEv.sharedMap.get(QLoaderId$1);
+  const base = `${requestEv.url.pathname}|${requestEv.url.search}|${loaderId}`;
+  return eTag ? `${base}|${eTag}` : base;
+}
+function getCachedSsr(key) {
+  return ssrCache.get(key);
+}
+function setCachedSsr(key, entry) {
+  ssrCache.set(key, entry);
+}
+function getCachedLoader(key) {
+  return loaderCache.get(key);
+}
+function setCachedLoader(key, entry) {
+  loaderCache.set(key, entry);
 }
 
 var HttpStatus = /* @__PURE__ */ (function(HttpStatus2) {
@@ -697,10 +839,8 @@ var HttpStatus = /* @__PURE__ */ (function(HttpStatus2) {
   return HttpStatus2;
 })({});
 
-const RequestEvLoaders = /* @__PURE__ */ Symbol("RequestEvLoaders");
 const RequestEvMode = /* @__PURE__ */ Symbol("RequestEvMode");
 const RequestEvRoute = /* @__PURE__ */ Symbol("RequestEvRoute");
-const RequestEvLoaderSerializationStrategyMap = /* @__PURE__ */ Symbol("RequestEvLoaderSerializationStrategyMap");
 const RequestRouteName = "@routeName";
 const RequestEvSharedActionId = "@actionId";
 const RequestEvSharedActionFormData = "@actionFormData";
@@ -709,13 +849,6 @@ const RequestEvIsRewrite = "@rewrite";
 const RequestEvShareServerTiming = "@serverTiming";
 const RequestEvETagCacheKey = "@eTagCacheKey";
 const RequestEvHttpStatusMessage = "@httpStatusMessage";
-const RequestEvShareQData = "qData";
-function getRequestLoaders(requestEv) {
-  return requestEv[RequestEvLoaders];
-}
-function getRequestLoaderSerializationStrategyMap(requestEv) {
-  return requestEv[RequestEvLoaderSerializationStrategyMap];
-}
 function getRequestRoute(requestEv) {
   return requestEv[RequestEvRoute];
 }
@@ -835,10 +968,23 @@ function createRequestEventWithDeps(deps, serverRequestEv, loadedRoute, requestH
   const cookie = new deps.Cookie(request.headers.get("cookie"));
   const headers = new Headers();
   const url = new URL(request.url);
-  const { pathname, isInternal } = deps.getRouteMatchPathname(url.pathname);
-  if (isInternal) {
-    url.pathname = pathname;
-    sharedMap.set(deps.IsQData, true);
+  let internalRequest = false;
+  const recognized = deps.recognizeRequest(url.pathname);
+  if (recognized) {
+    url.pathname = deps.trimRecognizedInternalPathname(url.pathname, recognized);
+    sharedMap.set(recognized.type, true);
+    internalRequest = "loader";
+    if (recognized.data?.loaderId) {
+      sharedMap.set(deps.QLoaderId, recognized.data.loaderId);
+    }
+  }
+  const actionId = url.searchParams.get(deps.QACTION_KEY);
+  if (actionId) {
+    sharedMap.set(deps.IsQAction, true);
+    sharedMap.set(deps.QActionId, actionId);
+    if (request.method === "POST" && request.headers.get("accept")?.includes("application/json")) {
+      internalRequest = "action";
+    }
   }
   let routeModuleIndex = -1;
   let writableStream = null;
@@ -907,10 +1053,7 @@ function createRequestEventWithDeps(deps, serverRequestEv, loadedRoute, requestH
     routeModuleIndex = ABORT_INDEX;
     return message;
   };
-  const loaders = {};
   const requestEv = {
-    [RequestEvLoaders]: loaders,
-    [RequestEvLoaderSerializationStrategyMap]: /* @__PURE__ */ new Map(),
     [RequestEvMode]: serverRequestEv.mode,
     get [RequestEvRoute]() {
       return loadedRoute;
@@ -933,6 +1076,7 @@ function createRequestEventWithDeps(deps, serverRequestEv, loadedRoute, requestH
     },
     request,
     url,
+    internalRequest,
     basePathname,
     sharedMap,
     get headersSent() {
@@ -952,16 +1096,14 @@ function createRequestEventWithDeps(deps, serverRequestEv, loadedRoute, requestH
       headers.set(target, deps.createCacheControl(cacheControl));
     },
     resolveValue: async (loaderOrAction) => {
-      const id = loaderOrAction.__id;
       if (loaderOrAction.__brand === "server_loader") {
-        if (!(id in loaders)) {
-          throw new Error("You can not get the returned data of a loader that has not been executed for this request.");
-        }
-        if (loaders[id] === _UNINITIALIZED) {
-          await deps.getRouteLoaderPromise(loaderOrAction, loaders, requestEv[RequestEvLoaderSerializationStrategyMap], requestEv);
+        const loaderValues = getRouteLoaderValues(requestEv);
+        if (loaderOrAction.__id in loaderValues) {
+          return loaderValues[loaderOrAction.__id];
         }
+        return loadRouteLoader(loaderOrAction, requestEv);
       }
-      return loaders[id];
+      return void 0;
     },
     status: (statusCode) => {
       if (typeof statusCode === "number") {
@@ -1001,15 +1143,18 @@ function createRequestEventWithDeps(deps, serverRequestEv, loadedRoute, requestH
       if (statusCode > 301) {
         headers.set("Cache-Control", "no-store");
       }
+      if (internalRequest === "loader") {
+        return new deps.RedirectMessage();
+      }
       return exit(new deps.RedirectMessage());
     },
-    rewrite: (pathname2) => {
+    rewrite: (pathname) => {
       check();
-      if (pathname2.startsWith("http")) {
+      if (pathname.startsWith("http")) {
         throw new deps.ServerError(400, isDev ? "Rewrite does not support absolute urls" : "Bad Request");
       }
       sharedMap.set(RequestEvIsRewrite, true);
-      return exit(new deps.RewriteMessage(pathname2.replace(/\/+/g, "/")));
+      return exit(new deps.RewriteMessage(pathname.replace(/\/+/g, "/")));
     },
     defer: (returnData) => {
       return typeof returnData === "function" ? returnData : () => returnData;
@@ -1061,105 +1206,6 @@ function createRequestEventWithDeps(deps, serverRequestEv, loadedRoute, requestH
   return requestEv;
 }
 
-function verifySerializable(data, qrl) {
-  try {
-    _verifySerializable(data, void 0);
-  } catch (e) {
-    if (e instanceof Error && qrl.dev) {
-      e.loc = qrl.dev;
-    }
-    throw e;
-  }
-}
-function now() {
-  return typeof performance !== "undefined" ? performance.now() : 0;
-}
-async function measure(requestEv, name, fn) {
-  const start = now();
-  try {
-    return await fn();
-  } finally {
-    const duration = now() - start;
-    let measurements = requestEv.sharedMap.get("@serverTiming");
-    if (!measurements) {
-      requestEv.sharedMap.set("@serverTiming", measurements = []);
-    }
-    measurements.push([
-      name,
-      duration
-    ]);
-  }
-}
-async function runValidators(requestEv, validators, data) {
-  let lastResult = {
-    success: true,
-    data
-  };
-  if (validators) {
-    for (const validator of validators) {
-      if (isDev) {
-        lastResult = await measure(requestEv, `validator$`, () => validator.validate(requestEv, data));
-      } else {
-        lastResult = await validator.validate(requestEv, data);
-      }
-      if (!lastResult.success) {
-        return lastResult;
-      } else {
-        data = lastResult.data;
-      }
-    }
-  }
-  return lastResult;
-}
-async function getRouteLoaderPromise(loader, loaders, loadersSerializationStrategy, requestEv) {
-  const loaderId = loader.__id;
-  loaders[loaderId] = runValidators(
-    requestEv,
-    loader.__validators,
-    void 0
-    // data
-  ).then((res) => {
-    if (res.success) {
-      if (isDev) {
-        return measure(requestEv, loader.__qrl.getHash(), () => loader.__qrl.call(requestEv, requestEv));
-      } else {
-        return loader.__qrl.call(requestEv, requestEv);
-      }
-    } else {
-      return requestEv.fail(res.status ?? 500, res.error);
-    }
-  }).then((resolvedLoader) => {
-    if (typeof resolvedLoader === "function") {
-      loaders[loaderId] = resolvedLoader();
-    } else {
-      if (isDev) {
-        verifySerializable(resolvedLoader, loader.__qrl);
-      }
-      loaders[loaderId] = resolvedLoader;
-    }
-    return resolvedLoader;
-  });
-  loadersSerializationStrategy.set(loaderId, loader.__serializationStrategy);
-  return loaders[loaderId];
-}
-
-const IsQData = "@isQData";
-const QDATA_JSON = "/q-data.json";
-function getRouteMatchPathname(pathname) {
-  const isInternal = pathname.endsWith(QDATA_JSON);
-  if (isInternal) {
-    const trimEnd = pathname.length - QDATA_JSON.length + (globalThis.__NO_TRAILING_SLASH__ ? 0 : 1);
-    pathname = pathname.slice(0, trimEnd);
-    if (pathname === "") {
-      pathname = "/";
-    }
-  }
-  return {
-    pathname,
-    isInternal
-  };
-}
-
 const encoder = /* @__PURE__ */ new TextEncoder();
 function getContentType(headers) {
   return (headers.get("content-type")?.split(/[;,]/, 1)[0].trim() ?? "").toLowerCase();
@@ -1180,22 +1226,20 @@ class RedirectMessage extends AbortMessage {
 }
 
 function createResolveRequestHandlers(deps) {
-  const resolveRequestHandlers = (serverPlugins, route, method, checkOrigin, renderHandler, isInternal) => {
+  const resolveRequestHandlers = (serverPlugins, route, method, checkOrigin, renderHandler) => {
     const routeLoaders = [];
     const routeActions = [];
     const requestHandlers = [];
     const isPageRoute = !!isLastModulePageRoute(route.$mods$);
-    if (isInternal) {
-      requestHandlers.push(handleQDataRedirect);
-    }
     if (isPageRoute) {
+      requestHandlers.push(jsonRequestWrapper());
       requestHandlers.push(serverErrorMiddleware(route, renderHandler));
     }
     if (serverPlugins) {
       _resolveRequestHandlers(routeLoaders, routeActions, requestHandlers, serverPlugins, isPageRoute, method);
     }
     const routeModules = route.$mods$;
-    _resolveRequestHandlers(routeLoaders, routeActions, requestHandlers, routeModules, isPageRoute, method);
+    _resolveRequestHandlers(routeLoaders, routeActions, requestHandlers, routeModules, isPageRoute, method, isPageRoute);
     const routeName = route.$routeName$;
     if (checkOrigin && (method === "POST" || method === "PUT" || method === "PATCH" || method === "DELETE")) {
       if (checkOrigin === "lax-proto") {
@@ -1205,70 +1249,32 @@ function createResolveRequestHandlers(deps) {
       }
     }
     if (isPageRoute) {
+      requestHandlers.push(loaderHandler(routeLoaders, route.$loaderPaths$));
+      requestHandlers.push(actionHandler(routeActions));
       if (method === "POST" || method === "GET") {
         requestHandlers.push(runServerFunction);
       }
       if (!route.$notFound$) {
         requestHandlers.push(fixTrailingSlash);
       }
-      if (isInternal) {
-        requestHandlers.push(renderQData);
-      }
     }
     if (isPageRoute) {
       requestHandlers.push((ev) => {
         ev.sharedMap.set(deps.RequestRouteName, routeName);
       });
       requestHandlers.push(actionsMiddleware(routeActions));
-      requestHandlers.push(loadersMiddleware(routeLoaders));
+      requestHandlers.push(loadersMiddleware(routeLoaders, route));
       requestHandlers.push(eTagMiddleware(route));
       requestHandlers.push(renderHandler);
     }
     return requestHandlers;
   };
-  const _resolveRequestHandlers = (routeLoaders, routeActions, requestHandlers, routeModules, collectActions, method) => {
-    for (const routeModule of routeModules) {
-      if (typeof routeModule.onRequest === "function") {
-        requestHandlers.push(routeModule.onRequest);
-      } else if (Array.isArray(routeModule.onRequest)) {
-        requestHandlers.push(...routeModule.onRequest);
-      }
-      let methodReqHandler;
-      switch (method) {
-        case "GET": {
-          methodReqHandler = routeModule.onGet;
-          break;
-        }
-        case "POST": {
-          methodReqHandler = routeModule.onPost;
-          break;
-        }
-        case "PUT": {
-          methodReqHandler = routeModule.onPut;
-          break;
-        }
-        case "PATCH": {
-          methodReqHandler = routeModule.onPatch;
-          break;
-        }
-        case "DELETE": {
-          methodReqHandler = routeModule.onDelete;
-          break;
-        }
-        case "OPTIONS": {
-          methodReqHandler = routeModule.onOptions;
-          break;
-        }
-        case "HEAD": {
-          methodReqHandler = routeModule.onHead;
-          break;
-        }
-      }
-      if (typeof methodReqHandler === "function") {
-        requestHandlers.push(methodReqHandler);
-      } else if (Array.isArray(methodReqHandler)) {
-        requestHandlers.push(...methodReqHandler);
-      }
+  function _resolveRequestHandlers(routeLoaders, routeActions, requestHandlers, routeModules, collectActions, method, guardPageHandlersForLoader = false) {
+    for (let i = 0; i < routeModules.length; i++) {
+      const routeModule = routeModules[i];
+      const moduleHandlers = getModuleRequestHandlers(routeModule, method);
+      const shouldGuardPageHandlers = guardPageHandlersForLoader && i === routeModules.length - 1;
+      requestHandlers.push(...shouldGuardPageHandlers ? moduleHandlers.map((handler) => guardPageHandlerForLoader(routeModule, handler)) : moduleHandlers);
       if (collectActions) {
         for (const module of Object.values(routeModule)) {
           if (typeof module === "function") {
@@ -1281,7 +1287,73 @@ function createResolveRequestHandlers(deps) {
         }
       }
     }
-  };
+  }
+  function getModuleRequestHandlers(routeModule, method) {
+    const handlers = [];
+    addRequestHandlers(handlers, routeModule.onRequest);
+    let methodReqHandler;
+    switch (method) {
+      case "GET": {
+        methodReqHandler = routeModule.onGet;
+        break;
+      }
+      case "POST": {
+        methodReqHandler = routeModule.onPost;
+        break;
+      }
+      case "PUT": {
+        methodReqHandler = routeModule.onPut;
+        break;
+      }
+      case "PATCH": {
+        methodReqHandler = routeModule.onPatch;
+        break;
+      }
+      case "DELETE": {
+        methodReqHandler = routeModule.onDelete;
+        break;
+      }
+      case "OPTIONS": {
+        methodReqHandler = routeModule.onOptions;
+        break;
+      }
+      case "HEAD": {
+        methodReqHandler = routeModule.onHead;
+        break;
+      }
+    }
+    addRequestHandlers(handlers, methodReqHandler);
+    return handlers;
+  }
+  function addRequestHandlers(handlers, handler) {
+    if (typeof handler === "function") {
+      handlers.push(handler);
+    } else if (Array.isArray(handler)) {
+      handlers.push(...handler);
+    }
+  }
+  function guardPageHandlerForLoader(routeModule, handler) {
+    return (requestEv) => {
+      if (requestEv.sharedMap.has(IsQLoader$1)) {
+        const loaderId = requestEv.sharedMap.get(QLoaderId$1);
+        if (!moduleHasLoader(routeModule, loaderId)) {
+          return;
+        }
+      }
+      return handler(requestEv);
+    };
+  }
+  function moduleHasLoader(routeModule, loaderId) {
+    if (typeof loaderId !== "string") {
+      return false;
+    }
+    for (const value of Object.values(routeModule)) {
+      if (checkBrand(value, "server_loader") && value.__id === loaderId) {
+        return true;
+      }
+    }
+    return false;
+  }
   const checkBrand = (obj, brand) => {
     return obj && typeof obj === "function" && obj.__brand === brand;
   };
@@ -1293,8 +1365,7 @@ function createResolveRequestHandlers(deps) {
         return;
       }
       const { method } = requestEv;
-      const loaders = deps.getRequestLoaders(requestEv);
-      if (isDev && method === "GET") {
+      if (isDev$1 && method === "GET") {
         if (requestEv.query.has(deps.QACTION_KEY)) {
           console.warn('Seems like you are submitting a Qwik Action via GET request. Qwik Actions should be submitted via POST request.\nMake sure your <form> has method="POST" attribute, like this: <form method="POST">');
         }
@@ -1311,66 +1382,79 @@ function createResolveRequestHandlers(deps) {
               throw new Error(`Expected request data for the action id ${selectedActionId} to be an object`);
             }
             const result = await runValidators(requestEv, action.__validators, data);
+            let actionResult;
             if (!result.success) {
-              loaders[selectedActionId] = requestEv.fail(result.status ?? 500, result.error);
+              actionResult = requestEv.fail(result.status ?? 500, result.error);
             } else {
-              const actionResolved = isDev ? await measure(requestEv, action.__qrl.getHash(), () => action.__qrl.call(requestEv, result.data, requestEv)) : await action.__qrl.call(requestEv, result.data, requestEv);
-              if (isDev) {
+              const actionResolved = isDev$1 ? await measure(requestEv, action.__qrl.getHash(), () => action.__qrl.call(requestEv, result.data, requestEv)) : await action.__qrl.call(requestEv, result.data, requestEv);
+              if (isDev$1) {
                 verifySerializable(actionResolved, action.__qrl);
               }
-              loaders[selectedActionId] = actionResolved;
+              actionResult = actionResolved;
             }
+            requestEv.sharedMap.set("@actionResult", actionResult);
           }
         }
       }
     };
   }
-  function loadersMiddleware(routeLoaders) {
+  function loadersMiddleware(routeLoaders, route) {
     return async (requestEvent) => {
       const requestEv = requestEvent;
       if (requestEv.headersSent) {
         requestEv.exit();
         return;
       }
-      const loaders = deps.getRequestLoaders(requestEv);
-      const loadersSerializationStrategy = deps.getRequestLoaderSerializationStrategyMap(requestEv);
       if (routeLoaders.length > 0) {
-        const resolvedLoadersPromises = routeLoaders.map((loader) => deps.getRouteLoaderPromise(loader, loaders, loadersSerializationStrategy, requestEv));
-        await Promise.all(resolvedLoadersPromises);
+        setLoaderData(requestEv, routeLoaders, route);
+        const loaderValues = getRouteLoaderValues(requestEv);
+        await Promise.all(routeLoaders.map(async (loader) => {
+          loaderValues[loader.__id] = await loadRouteLoader(loader, requestEv);
+        }));
       }
     };
   }
+  function setLoaderData(requestEv, routeLoaders, route) {
+    if (routeLoaders.length === 0) {
+      return;
+    }
+    const routeLoaderCtx = getRouteLoaderCtx(requestEv);
+    if (route.$loaderPaths$) {
+      Object.assign(routeLoaderCtx.loaderPaths, route.$loaderPaths$);
+    }
+    setRouteLoaders(requestEv, routeLoaders);
+  }
   function eTagMiddleware(route) {
     return (requestEv) => {
       if (requestEv.headersSent) {
         return;
       }
-      if (requestEv.method !== "GET" || requestEv.sharedMap.has(deps.IsQData)) {
+      if (requestEv.method !== "GET") {
         return;
       }
       const mods = route.$mods$;
-      const hasETag = mods.some((m) => {
+      const hasCachingConfig = mods.some((m) => {
         if (!m) {
           return false;
         }
         if (m.routeConfig) {
-          return typeof m.routeConfig === "function" || m.routeConfig.eTag !== void 0;
+          return typeof m.routeConfig === "function" || m.routeConfig.eTag !== void 0 || m.routeConfig.cacheKey !== void 0;
         }
-        return m.eTag !== void 0;
+        return m.eTag !== void 0 || m.cacheKey !== void 0;
       });
-      if (!hasETag) {
+      if (!hasCachingConfig) {
         return;
       }
-      const loaders = deps.getRequestLoaders(requestEv);
+      const loaderValues = getRouteLoaderValues(requestEv);
       const getData = (loaderOrAction) => {
         const id = loaderOrAction.__id;
-        if (loaderOrAction.__brand === "server_loader" && !(id in loaders)) {
-          throw new Error("Loader not executed for this request.");
-        }
-        if (loaders[id] instanceof Promise) {
-          throw new Error("Loaders returning a promise cannot be resolved for the eTag function.");
+        if (loaderOrAction.__brand === "server_loader") {
+          if (!(id in loaderValues)) {
+            throw new Error("Loader not executed for this request.");
+          }
+          return loaderValues[id];
         }
-        return loaders[id];
+        return requestEv.sharedMap.get(deps.RequestEvSharedActionId) === id ? requestEv.sharedMap.get("@actionResult") : void 0;
       };
       const routeLocation = {
         params: requestEv.params,
@@ -1387,32 +1471,36 @@ function createResolveRequestHandlers(deps) {
         resolveValue: getData,
         ...routeLocation
       };
-      const eTag = deps.resolveETag(config.eTag, headProps);
-      if (!eTag) {
-        return;
-      }
-      requestEv.headers.set("ETag", eTag);
-      const ifNoneMatch = requestEv.request.headers.get("If-None-Match");
-      if (ifNoneMatch && (ifNoneMatch === eTag || ifNoneMatch === `W/${eTag}` || `W/${ifNoneMatch}` === eTag)) {
-        requestEv.status(304);
-        requestEv.send(304, "");
+      const resolvedETag = deps.resolveETag(config.eTag, headProps);
+      const normalizedETag = resolvedETag !== null ? normalizeETag(resolvedETag) : "";
+      if (normalizedETag && performETagMatch(requestEv, normalizedETag)) {
         return;
       }
       if (deps.MAX_CACHE_SIZE <= 0) {
         return;
       }
-      const cacheKey = deps.resolveCacheKey(config.cacheKey, status, eTag, requestEv.url.pathname);
+      const cacheKey = deps.resolveCacheKey(config.cacheKey, deps.defaultSsrCacheKey, requestEv, normalizedETag);
       if (!cacheKey) {
         return;
       }
-      const cachedHtml = deps.getCachedHtml(cacheKey);
-      if (cachedHtml) {
+      const cached = deps.getCachedSsr(cacheKey);
+      if (cached) {
         requestEv.headers.set("Content-Type", "text/html; charset=utf-8");
         requestEv.headers.set("X-SSR-Cache", "HIT");
-        requestEv.send(status, cachedHtml);
+        if (!normalizedETag) {
+          if (performETagMatch(requestEv, cached.eTag)) {
+            return;
+          }
+        } else {
+          setETagHeader(requestEv, cached.eTag);
+        }
+        requestEv.send(status, cached.body);
         return;
       }
-      requestEv.sharedMap.set(deps.RequestEvETagCacheKey, cacheKey);
+      requestEv.sharedMap.set(deps.RequestEvETagCacheKey, {
+        key: cacheKey,
+        eTag: normalizedETag
+      });
     };
   }
   function serverErrorMiddleware(route, renderHandler) {
@@ -1423,9 +1511,6 @@ function createResolveRequestHandlers(deps) {
         if (!(e instanceof deps.ServerError) || requestEv.headersSent) {
           throw e;
         }
-        if (requestEv.sharedMap.has(deps.IsQData)) {
-          throw e;
-        }
         const accept = requestEv.request.headers.get("Accept");
         if (accept && !accept.includes("text/html")) {
           throw e;
@@ -1449,7 +1534,7 @@ function createResolveRequestHandlers(deps) {
     };
     if (validators) {
       for (const validator of validators) {
-        if (isDev) {
+        if (isDev$1) {
           lastResult = await measure(requestEv, `validator$`, () => validator.validate(requestEv, data));
         } else {
           lastResult = await validator.validate(requestEv, data);
@@ -1477,7 +1562,7 @@ function createResolveRequestHandlers(deps) {
       const qrl = inlinedQrl(null, serverFnHash, data.slice(1));
       let result;
       try {
-        if (isDev) {
+        if (isDev$1) {
           result = await measure(ev, `server_${serverFnHash}`, () => qrl.apply(ev, data[0]));
         } else {
           result = await qrl.apply(ev, data[0]);
@@ -1494,7 +1579,7 @@ function createResolveRequestHandlers(deps) {
         const writable = ev.getWritableStream();
         const stream = writable.getWriter();
         for await (const item of result) {
-          if (isDev) {
+          if (isDev$1) {
             verifySerializable(item, qrl);
           }
           const message = await _serialize(item);
@@ -1515,16 +1600,15 @@ function createResolveRequestHandlers(deps) {
     }
   }
   function fixTrailingSlash(ev) {
-    const { basePathname, originalUrl, sharedMap } = ev;
+    const { basePathname, originalUrl } = ev;
     const { pathname, search } = originalUrl;
-    const isQData = sharedMap.has(deps.IsQData);
     if (!pathname.startsWith("/") || pathname.startsWith("//")) {
       return;
     }
-    if (!isQData && pathname !== basePathname && !pathname.endsWith(".html")) {
+    if (pathname !== basePathname && !pathname.endsWith(".html")) {
       if (!globalThis.__NO_TRAILING_SLASH__) {
         if (!pathname.endsWith("/")) {
-          throw ev.redirect(deps.HttpStatus.MovedPermanently, pathname + "/" + search);
+          throw ev.redirect(deps.HttpStatus.MovedPermanently, ensureSlash(pathname) + search);
         }
       } else {
         if (pathname.endsWith("/")) {
@@ -1552,12 +1636,9 @@ function createResolveRequestHandlers(deps) {
   }
   function getPathname(url) {
     url = new URL(url);
-    if (url.pathname.endsWith(deps.QDATA_JSON)) {
-      url.pathname = url.pathname.slice(0, -deps.QDATA_JSON.length);
-    }
     if (!globalThis.__NO_TRAILING_SLASH__) {
       if (!url.pathname.endsWith("/")) {
-        url.pathname += "/";
+        url.pathname = ensureSlash(url.pathname);
       }
     } else {
       if (url.pathname.endsWith("/")) {
@@ -1594,19 +1675,16 @@ The request origin "${inputOrigin}" does not match the server origin "${origin}"
       if (requestEv.headersSent) {
         return;
       }
-      if (requestEv.sharedMap.has(deps.IsQData)) {
-        return;
-      }
       const responseHeaders = requestEv.headers;
       if (!responseHeaders.has("Content-Type")) {
         responseHeaders.set("Content-Type", "text/html; charset=utf-8");
       }
-      const eTagCacheKey = requestEv.sharedMap.get(deps.RequestEvETagCacheKey);
+      const cachePlan = requestEv.sharedMap.get(deps.RequestEvETagCacheKey);
       const { readable, writable } = new TextEncoderStream();
       const writableStream = requestEv.getWritableStream();
       let cacheChunks;
       let pipeSource = readable;
-      if (eTagCacheKey) {
+      if (cachePlan) {
         cacheChunks = [];
         const capture = new TransformStream({
           transform(chunk, controller) {
@@ -1623,29 +1701,24 @@ The request origin "${inputOrigin}" does not match the server origin "${origin}"
         pipeError = error;
       });
       const stream = writable.getWriter();
-      const status = requestEv.status();
       try {
         const isStatic = deps.getRequestMode(requestEv) === "static";
         const serverData = deps.getQwikRouterServerData(requestEv);
         const result = await render({
           base: requestEv.basePathname + "build/",
           stream,
+          streaming: isStatic ? {
+            outOfOrder: false
+          } : void 0,
           serverData,
           containerAttributes: {
             ["q:render"]: isStatic ? "static" : "",
             ...serverData.containerAttributes
           }
         });
-        const qData = {
-          loaders: deps.getRequestLoaders(requestEv),
-          action: requestEv.sharedMap.get(deps.RequestEvSharedActionId),
-          status: status !== 200 ? status : 200,
-          href: getPathname(requestEv.url)
-        };
         if (typeof result.html === "string") {
           await stream.write(result.html);
         }
-        requestEv.sharedMap.set(deps.RequestEvShareQData, qData);
       } finally {
         await stream.ready;
         await stream.close();
@@ -1654,7 +1727,7 @@ The request origin "${inputOrigin}" does not match the server origin "${origin}"
       if (pipeError) {
         throw pipeError;
       }
-      if (eTagCacheKey && cacheChunks && cacheChunks.length > 0) {
+      if (cachePlan && cacheChunks && cacheChunks.length > 0) {
         const totalLength = cacheChunks.reduce((sum, chunk) => sum + chunk.length, 0);
         const combined = new Uint8Array(totalLength);
         let offset = 0;
@@ -1662,86 +1735,16 @@ The request origin "${inputOrigin}" does not match the server origin "${origin}"
           combined.set(chunk, offset);
           offset += chunk.length;
         }
-        deps.setCachedHtml(eTagCacheKey, new TextDecoder().decode(combined));
+        const html = new TextDecoder().decode(combined);
+        const cachedETag = cachePlan.eTag || hash(html);
+        deps.setCachedSsr(cachePlan.key, {
+          eTag: cachedETag,
+          body: html
+        });
       }
       await writableStream.close();
     };
   }
-  async function handleQDataRedirect(requestEv) {
-    try {
-      await requestEv.next();
-    } catch (err) {
-      if (!(err instanceof deps.RedirectMessage)) {
-        throw err;
-      }
-    }
-    if (requestEv.headersSent) {
-      return;
-    }
-    const status = requestEv.status();
-    const location = requestEv.headers.get("Location");
-    const isRedirect = status >= 301 && status <= 308 && location;
-    if (isRedirect) {
-      const adaptedLocation = makeQDataPath(location);
-      if (adaptedLocation) {
-        requestEv.headers.set("Location", adaptedLocation);
-        requestEv.getWritableStream().close();
-        return;
-      } else {
-        requestEv.status(200);
-        requestEv.headers.delete("Location");
-      }
-    }
-  }
-  async function renderQData(requestEv) {
-    await requestEv.next();
-    if (requestEv.headersSent || requestEv.exited) {
-      return;
-    }
-    const status = requestEv.status();
-    const redirectLocation = requestEv.headers.get("Location");
-    requestEv.headers.set("Content-Type", "application/json; charset=utf-8");
-    let loaders = deps.getRequestLoaders(requestEv);
-    const selectedLoaderIds = requestEv.query.getAll(deps.QLOADER_KEY);
-    const hasCustomLoaders = selectedLoaderIds.length > 0;
-    if (hasCustomLoaders) {
-      const selectedLoaders = {};
-      for (const loaderId of selectedLoaderIds) {
-        const loader = loaders[loaderId];
-        selectedLoaders[loaderId] = loader;
-      }
-      loaders = selectedLoaders;
-    }
-    const qData = hasCustomLoaders ? {
-      loaders,
-      status: status !== 200 ? status : 200,
-      href: getPathname(requestEv.url)
-    } : {
-      loaders,
-      action: requestEv.sharedMap.get(deps.RequestEvSharedActionId),
-      status: status !== 200 ? status : 200,
-      href: getPathname(requestEv.url),
-      redirect: redirectLocation ?? void 0,
-      isRewrite: requestEv.sharedMap.get(deps.RequestEvIsRewrite)
-    };
-    const writer = requestEv.getWritableStream().getWriter();
-    const data = await _serialize(qData);
-    writer.write(deps.encoder.encode(data));
-    requestEv.sharedMap.set(deps.RequestEvShareQData, qData);
-    writer.close();
-  }
-  function makeQDataPath(href) {
-    if (href.startsWith("/")) {
-      if (!href.includes(deps.QDATA_JSON)) {
-        const url = new URL(href, "http://localhost");
-        const pathname = url.pathname.endsWith("/") ? url.pathname.slice(0, -1) : url.pathname;
-        return pathname + deps.QDATA_JSON + url.search;
-      }
-      return href;
-    } else {
-      return void 0;
-    }
-  }
   function now() {
     return typeof performance !== "undefined" ? performance.now() : 0;
   }
@@ -1790,6 +1793,7 @@ function getQwikRouterServerDataWithDeps(deps, requestEv) {
   const requestHeaders = {};
   request.headers.forEach((value, key) => requestHeaders[key] = value);
   const action = requestEv.sharedMap.get(deps.RequestEvSharedActionId);
+  const actionResult = requestEv.sharedMap.get("@actionResult");
   const formData = requestEv.sharedMap.get(deps.RequestEvSharedActionFormData);
   const routeName = requestEv.sharedMap.get(deps.RequestRouteName);
   const nonce = requestEv.sharedMap.get(deps.RequestEvSharedNonce);
@@ -1804,11 +1808,12 @@ function getQwikRouterServerDataWithDeps(deps, requestEv) {
   if (protocol) {
     reconstructedUrl.protocol = protocol;
   }
-  const loaders = deps.getRequestLoaders(requestEv);
-  const loadersSerializationStrategy = deps.getRequestLoaderSerializationStrategyMap(requestEv);
+  const routeLoaderCtx = getRouteLoaderCtx(requestEv);
+  const loaderValues = getRouteLoaderValues(requestEv);
   return {
     url: reconstructedUrl.href,
     requestHeaders,
+    renderMode: deps.getRequestMode(requestEv),
     locale: locale(),
     nonce,
     containerAttributes: {
@@ -1821,12 +1826,13 @@ function getQwikRouterServerDataWithDeps(deps, requestEv) {
         ...params
       },
       loadedRoute: deps.getRequestRoute(requestEv),
+      routeLoaderCtx,
+      loaderValues,
       response: {
         status: status(),
         statusMessage: requestEv.sharedMap.get(deps.RequestEvHttpStatusMessage),
-        loaders,
-        loadersSerializationStrategy,
         action,
+        actionResult,
         formData
       }
     }
@@ -1840,8 +1846,7 @@ const responsePageDeps = {
   RequestEvSharedActionId,
   RequestEvSharedNonce,
   RequestRouteName,
-  getRequestLoaders,
-  getRequestLoaderSerializationStrategyMap,
+  getRequestMode,
   getRequestRoute
 };
 function getQwikRouterServerData(...args) {
@@ -1851,13 +1856,8 @@ function getQwikRouterServerData(...args) {
 const requestHandlers = createResolveRequestHandlers({
   QACTION_KEY,
   QFN_KEY,
-  QLOADER_KEY,
-  QDATA_JSON,
-  IsQData,
   RequestEvETagCacheKey,
   RequestEvHttpStatusMessage,
-  RequestEvIsRewrite,
-  RequestEvShareQData,
   RequestEvShareServerTiming,
   RequestEvSharedActionId,
   RequestRouteName,
@@ -1866,18 +1866,19 @@ const requestHandlers = createResolveRequestHandlers({
   HttpStatus,
   encoder,
   isContentType,
-  getCachedHtml,
+  defaultSsrCacheKey,
+  defaultLoaderCacheKey,
+  getCachedSsr,
+  getCachedLoader,
   getQwikRouterServerData,
-  getRequestLoaderSerializationStrategyMap,
-  getRequestLoaders,
   getRequestMode,
-  getRouteLoaderPromise,
   loadHttpError: () => import('./http-error.qwik.mjs'),
   MAX_CACHE_SIZE,
   resolveCacheKey,
   resolveETag,
   resolveRouteConfig,
-  setCachedHtml
+  setCachedSsr,
+  setCachedLoader
 });
 const { renderQwikMiddleware, resolveRequestHandlers} = requestHandlers;
 
@@ -2090,6 +2091,7 @@ class RewriteMessage extends AbortMessage$1 {
 
 const requestEventDeps = {
   QDATA_KEY,
+  QACTION_KEY,
   isPromise,
   createCacheControl,
   Cookie,
@@ -2097,9 +2099,12 @@ const requestEventDeps = {
   RedirectMessage,
   RewriteMessage,
   ServerError,
-  getRouteLoaderPromise,
-  getRouteMatchPathname,
-  IsQData,
+  recognizeRequest,
+  trimRecognizedInternalPathname,
+  IsQLoader,
+  IsQAction,
+  QLoaderId,
+  QActionId,
   encoder,
   getContentType
 };
@@ -2271,18 +2276,13 @@ function runQwikRouter(serverRequestEv, loadedRoute, requestHandlers, rebuildRou
 }
 
 const staticWorkerThreadDeps = {
-  RequestEvShareQData,
   loadRoute,
   renderQwikMiddleware,
   resolveRequestHandlers,
-  getRouteMatchPathname,
+  trimInternalPathname,
   runQwikRouter
 };
 const createNoopWritableStream = () => new WritableStream();
-async function loadSerialize() {
-  const { _serialize: serialize } = await import('@qwik.dev/core/internal');
-  return serialize;
-}
 function isRedirectMessage(value) {
   return typeof value === "object" && value !== null && value.constructor?.name === "RedirectMessage";
 }
@@ -2291,20 +2291,20 @@ async function requestHandlerForSsg(serverRequestEv, opts, deps) {
   if (!qwikRouterConfig) {
     throw new Error("qwikRouterConfig is required.");
   }
-  const { pathname, isInternal } = deps.getRouteMatchPathname(serverRequestEv.url.pathname);
+  const pathname = deps.trimInternalPathname(serverRequestEv.url.pathname);
   if (pathname === "/.well-known" || pathname.startsWith("/.well-known/")) {
     return null;
   }
   const { routes, serverPlugins, cacheModules } = qwikRouterConfig;
-  const loadedRoute = await deps.loadRoute(routes, cacheModules, pathname, isInternal);
-  const requestHandlers = deps.resolveRequestHandlers(serverPlugins, loadedRoute, serverRequestEv.request.method, checkOrigin ?? true, deps.renderQwikMiddleware(render), isInternal);
+  const loadedRoute = await deps.loadRoute(routes, cacheModules, pathname);
+  const requestHandlers = deps.resolveRequestHandlers(serverPlugins, loadedRoute, serverRequestEv.request.method, checkOrigin ?? true, deps.renderQwikMiddleware(render));
   if (qwikRouterConfig.fallthrough && loadedRoute.$notFound$) {
     return null;
   }
   const rebuildRouteInfo = async (url) => {
-    const { pathname: pathname2 } = deps.getRouteMatchPathname(url.pathname);
-    const loadedRoute2 = await deps.loadRoute(routes, cacheModules, pathname2, isInternal);
-    const requestHandlers2 = deps.resolveRequestHandlers(serverPlugins, loadedRoute2, serverRequestEv.request.method, checkOrigin ?? true, deps.renderQwikMiddleware(render), isInternal);
+    const cleanPathname = deps.trimInternalPathname(url.pathname);
+    const loadedRoute2 = await deps.loadRoute(routes, cacheModules, cleanPathname);
+    const requestHandlers2 = deps.resolveRequestHandlers(serverPlugins, loadedRoute2, serverRequestEv.request.method, checkOrigin ?? true, deps.renderQwikMiddleware(render));
     return {
       loadedRoute: loadedRoute2,
       requestHandlers: requestHandlers2
@@ -2360,11 +2360,11 @@ async function workerRender(sys, opts, staticRoute, pendingPromises, callback, d
           result.resourceType = "page";
         }
         const hasRouteWriter = isHtml ? opts.emitHtml !== false : true;
-        const writeQDataEnabled = isHtml && opts.emitData !== false;
+        const writeLoaderDataEnabled = isHtml && opts.emitData !== false;
         const stream = new WritableStream({
           async start() {
             try {
-              if (hasRouteWriter || writeQDataEnabled) {
+              if (hasRouteWriter || writeLoaderDataEnabled) {
                 await sys.ensureDir(routeFilePath);
               }
               if (hasRouteWriter) {
@@ -2404,23 +2404,34 @@ async function workerRender(sys, opts, staticRoute, pendingPromises, callback, d
           async close() {
             const writePromises = [];
             try {
-              if (writeQDataEnabled) {
-                const qData = requestEv.sharedMap.get(deps.RequestEvShareQData);
-                if (qData && !is404ErrorPage) {
-                  const qDataFilePath = sys.getDataFilePath(url.pathname);
-                  const dataWriter = sys.createWriteStream(qDataFilePath);
-                  dataWriter.on("error", (e) => {
+              if (writeLoaderDataEnabled && !is404ErrorPage) {
+                const routeLoaders = getRouteLoaders(requestEv);
+                const loaderValues = getRouteLoaderValues(requestEv);
+                const manifestHash = opts.manifest?.manifestHash || "dev";
+                for (const loader of routeLoaders) {
+                  if (loader.__expires !== 0) {
+                    continue;
+                  }
+                  const data = loaderValues[loader.__id];
+                  if (data === void 0) {
+                    continue;
+                  }
+                  const loaderFilePath = sys.getLoaderFilePath(url.pathname, loader.__id, manifestHash);
+                  const loaderWriter = sys.createWriteStream(loaderFilePath);
+                  loaderWriter.on("error", (e) => {
                     console.error(e);
                     result.error = {
                       message: e.message,
                       stack: e.stack
                     };
                   });
-                  const serialized = await deps.serialize(qData);
-                  dataWriter.write(serialized);
+                  const serialized = await deps.serialize({
+                    d: data
+                  });
+                  loaderWriter.write(serialized);
                   writePromises.push(new Promise((resolve) => {
                     result.filePath = routeFilePath;
-                    dataWriter.end(resolve);
+                    loaderWriter.end(resolve);
                   }));
                 }
               }
@@ -2506,7 +2517,7 @@ async function workerThread(sys) {
   const pendingPromises = /* @__PURE__ */ new Set();
   const deps = {
     ...staticWorkerThreadDeps,
-    serialize: await loadSerialize()
+    serialize: _serialize
   };
   process.on("uncaughtException", (e) => {
     console.error("Worker uncaught exception (suppressed):", e.message);