one 1.10.6 → 1.11.0

package/dist/cjs/server/oneServe.native.js

@@ -42,7 +42,11 @@ var import_promises = require("fs/promises"),
   import_createHandleRequest = require("../createHandleRequest.native.js"),
   import_cleanUrl = require("../utils/cleanUrl.native.js"),
   import_toAbsolute = require("../utils/toAbsolute.native.js"),
+  import_ssrLoaderData = require("./ssrLoaderData.native.js"),
   import_staticHtmlFetcher = require("./staticHtmlFetcher.native.js");
+function _instanceof(left, right) {
+  return right != null && typeof Symbol < "u" && right[Symbol.hasInstance] ? !!right[Symbol.hasInstance](left) : left instanceof right;
+}
 function _type_of(obj) {
   "@swc/helpers - typeof";
 
@@ -50,13 +54,14 @@ function _type_of(obj) {
 }
 var debugRouter = process.env.ONE_DEBUG_ROUTER;
 async function readStaticHtml(htmlPath) {
-  var fetchStaticHtml = (0, import_staticHtmlFetcher.getFetchStaticHtml)();
+  var outDir = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "dist",
+    fetchStaticHtml = (0, import_staticHtmlFetcher.getFetchStaticHtml)();
   if (fetchStaticHtml) {
     var html = await fetchStaticHtml(htmlPath);
     if (html) return html;
   }
   try {
-    return await (0, import_promises.readFile)((0, import_path.join)("dist/client", htmlPath), "utf-8");
+    return await (0, import_promises.readFile)((0, import_path.join)(`${outDir}/client`, htmlPath), "utf-8");
   } catch {
     return null;
   }
@@ -65,6 +70,7 @@ async function oneServe(oneOptions, buildInfo, app, options) {
   var _oneOptions_web,
     _oneOptions_build_api,
     _oneOptions_build,
+    outDir = buildInfo.outDir || "dist",
     {
       resolveAPIRoute,
       resolveLoaderRoute,
@@ -125,22 +131,83 @@ async function oneServe(oneOptions, buildInfo, app, options) {
       ...oneOptions,
       root: "."
     },
-    apiCJS = ((_oneOptions_build = oneOptions.build) === null || _oneOptions_build === void 0 || (_oneOptions_build_api = _oneOptions_build.api) === null || _oneOptions_build_api === void 0 ? void 0 : _oneOptions_build_api.outputFormat) === "cjs";
+    apiCJS = ((_oneOptions_build = oneOptions.build) === null || _oneOptions_build === void 0 || (_oneOptions_build_api = _oneOptions_build.api) === null || _oneOptions_build_api === void 0 ? void 0 : _oneOptions_build_api.outputFormat) === "cjs",
+    loaderCache = /* @__PURE__ */new Map(),
+    moduleImportCache = /* @__PURE__ */new Map(),
+    loaderCacheFnMap = /* @__PURE__ */new Map(),
+    pendingLoaderResults = /* @__PURE__ */new Map();
+  function resolveLoaderSync(serverPath, lazyKey) {
+    var cacheKey = lazyKey || serverPath || "",
+      cached = loaderCache.get(cacheKey);
+    return cached !== void 0 ? cached : async function () {
+      var _ref,
+        pathToResolve = serverPath || lazyKey || "",
+        resolvedPath = pathToResolve.includes(`${outDir}/server`) ? pathToResolve : (0, import_path.join)("./", `${outDir}/server`, pathToResolve),
+        routeExported;
+      if (moduleImportCache.has(cacheKey)) routeExported = moduleImportCache.get(cacheKey);else {
+        var _options_lazyRoutes_pages, _options_lazyRoutes;
+        routeExported = lazyKey ? !(options == null || (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0 || (_options_lazyRoutes_pages = _options_lazyRoutes.pages) === null || _options_lazyRoutes_pages === void 0) && _options_lazyRoutes_pages[lazyKey] ? await options.lazyRoutes.pages[lazyKey]() : await import((0, import_toAbsolute.toAbsolute)(resolvedPath)) : await import((0, import_toAbsolute.toAbsolute)(serverPath)), moduleImportCache.set(cacheKey, routeExported);
+      }
+      var loader = routeExported?.loader || null;
+      loaderCache.set(cacheKey, loader);
+      var loaderCacheFn = (_ref = routeExported?.loaderCache) !== null && _ref !== void 0 ? _ref : null;
+      return loaderCacheFnMap.set(cacheKey, loaderCacheFn), loader;
+    }();
+  }
   async function importAndRunLoader(routeId, serverPath, lazyKey, loaderProps) {
     if (!serverPath && !lazyKey) return {
       loaderData: void 0,
       routeId
     };
+    var cacheMapKey = lazyKey || serverPath || "",
+      loaderCacheFn = loaderCacheFnMap.get(cacheMapKey),
+      coalFullKey,
+      coalTtl = 0;
+    if (loaderCacheFn) {
+      var _ref,
+        cacheResult = loaderCacheFn(loaderProps?.params, loaderProps?.request),
+        cacheKey = typeof cacheResult == "string" ? cacheResult : cacheResult?.key;
+      if (coalTtl = typeof cacheResult == "string" ? 0 : (_ref = cacheResult?.ttl) !== null && _ref !== void 0 ? _ref : 0, cacheKey != null) {
+        coalFullKey = routeId + "\0" + cacheKey;
+        var existing = pendingLoaderResults.get(coalFullKey);
+        if (existing && (!existing.expires || Date.now() < existing.expires)) {
+          var loaderData = await existing.promise;
+          return {
+            loaderData,
+            routeId
+          };
+        }
+      }
+    }
     try {
-      var _options_lazyRoutes_pages,
-        _options_lazyRoutes,
-        _routeExported_loader,
-        pathToResolve = serverPath || lazyKey || "",
-        resolvedPath = pathToResolve.includes("dist/server") ? pathToResolve : (0, import_path.join)("./", "dist/server", pathToResolve),
-        routeExported = lazyKey ? !(options == null || (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0 || (_options_lazyRoutes_pages = _options_lazyRoutes.pages) === null || _options_lazyRoutes_pages === void 0) && _options_lazyRoutes_pages[lazyKey] ? await options.lazyRoutes.pages[lazyKey]() : await import((0, import_toAbsolute.toAbsolute)(resolvedPath)) : await import((0, import_toAbsolute.toAbsolute)(serverPath)),
-        loaderData = await (routeExported == null || (_routeExported_loader = routeExported.loader) === null || _routeExported_loader === void 0 ? void 0 : _routeExported_loader.call(routeExported, loaderProps));
+      var loaderOrPromise = resolveLoaderSync(serverPath, lazyKey),
+        loader = _instanceof(loaderOrPromise, Promise) ? await loaderOrPromise : loaderOrPromise;
+      if (!loader) return {
+        loaderData: void 0,
+        routeId
+      };
+      if (coalFullKey) {
+        var promise = loader(loaderProps),
+          entry = {
+            promise,
+            expires: 0
+          };
+        pendingLoaderResults.set(coalFullKey, entry), promise.then(function () {
+          entry.expires = coalTtl > 0 ? Date.now() + coalTtl : 0, coalTtl <= 0 && Promise.resolve().then(function () {
+            return pendingLoaderResults.delete(coalFullKey);
+          });
+        }, function () {
+          pendingLoaderResults.delete(coalFullKey);
+        });
+        var loaderData1 = await promise;
+        return {
+          loaderData: loaderData1,
+          routeId
+        };
+      }
+      var loaderData2 = await loader(loaderProps);
       return {
-        loaderData,
+        loaderData: loaderData2,
         routeId
       };
     } catch (err) {
@@ -155,228 +222,278 @@ async function oneServe(oneOptions, buildInfo, app, options) {
       });
     }
   }
-  var render = null;
-  async function getRender() {
-    if (!render) {
+  var render = null,
+    renderStream = null,
+    renderLoading = null;
+  function ensureRenderLoaded() {
+    if (!render) return renderLoading || (renderLoading = async function () {
       var _options_lazyRoutes,
         _oneOptions_build2,
-        entry = !(options == null || (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0) && _options_lazyRoutes.serverEntry ? await options.lazyRoutes.serverEntry() : await import((0, import_path.resolve)(process.cwd(), `${serverOptions.root}/dist/server/_virtual_one-entry.${_type_of((_oneOptions_build2 = oneOptions.build) === null || _oneOptions_build2 === void 0 ? void 0 : _oneOptions_build2.server) === "object" && oneOptions.build.server.outputFormat === "cjs" ? "c" : ""}js`));
-      render = entry.default.render;
-    }
-    return render;
+        entry = !(options == null || (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0) && _options_lazyRoutes.serverEntry ? await options.lazyRoutes.serverEntry() : await import((0, import_path.resolve)(process.cwd(), `${serverOptions.root}/${outDir}/server/_virtual_one-entry.${_type_of((_oneOptions_build2 = oneOptions.build) === null || _oneOptions_build2 === void 0 ? void 0 : _oneOptions_build2.server) === "object" && oneOptions.build.server.outputFormat === "cjs" ? "c" : ""}js`));
+      render = entry.default.render, renderStream = entry.default.renderStream;
+    }(), renderLoading);
   }
-  var requestHandlers = {
-    async handleAPI(param) {
-      var {
-          route: route2
-        } = param,
-        _options_lazyRoutes_api,
-        _options_lazyRoutes;
-      if (!(options == null || (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0 || (_options_lazyRoutes_api = _options_lazyRoutes.api) === null || _options_lazyRoutes_api === void 0) && _options_lazyRoutes_api[route2.page]) return await options.lazyRoutes.api[route2.page]();
-      var fileName = route2.page.slice(1).replace(/\[/g, "_").replace(/\]/g, "_"),
-        apiFile = (0, import_path.join)(process.cwd(), "dist", "api", fileName + (apiCJS ? ".cjs" : ".js"));
-      return await import(apiFile);
-    },
-    async loadMiddleware(route2) {
-      var _options_lazyRoutes_middlewares, _options_lazyRoutes;
-      return !(options == null || (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0 || (_options_lazyRoutes_middlewares = _options_lazyRoutes.middlewares) === null || _options_lazyRoutes_middlewares === void 0) && _options_lazyRoutes_middlewares[route2.contextKey] ? await options.lazyRoutes.middlewares[route2.contextKey]() : await import((0, import_toAbsolute.toAbsolute)(route2.contextKey));
-    },
-    async handleLoader(param) {
-      var {
-          route: route2,
-          loaderProps
-        } = param,
-        routeFile = route2.routeFile || route2.file,
-        serverPath = route2.file.includes("dist/server") ? route2.file : (0, import_path.join)("./", "dist/server", route2.file),
-        exports;
-      try {
-        var _options_lazyRoutes_pages, _options_lazyRoutes;
-        exports = !(options == null || (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0 || (_options_lazyRoutes_pages = _options_lazyRoutes.pages) === null || _options_lazyRoutes_pages === void 0) && _options_lazyRoutes_pages[routeFile] ? await options.lazyRoutes.pages[routeFile]() : await import((0, import_toAbsolute.toAbsolute)(serverPath));
-      } catch (err) {
-        if (err?.code === "ERR_MODULE_NOT_FOUND") return null;
-        throw err;
-      }
-      var {
-        loader
-      } = exports;
-      if (!loader) return null;
-      var json;
-      try {
-        json = await loader(loaderProps);
-      } catch (err) {
-        if (err?.code === "ENOENT") return make404LoaderJs(loaderProps?.path || "/", `ENOENT ${err?.path || err}`);
-        throw err;
-      }
-      if (isResponse(json)) throw json;
-      return `export function loader() { return ${JSON.stringify(json)} }`;
-    },
-    async handlePage(param) {
-      var {
-          route: route2,
-          url,
-          loaderProps
-        } = param,
-        _$buildInfo = routeToBuildInfo[route2.file];
-      if (route2.type === "ssr") {
-        if (!_$buildInfo) throw console.error("Error in route", route2), new Error(`No buildinfo found for ${url}, route: ${route2.file}, in keys:
+  var clientDir = (0, import_path.join)(process.cwd(), outDir, "client"),
+    requestHandlers = {
+      async handleStaticFile(filePath) {
+        try {
+          var fullPath = (0, import_path.join)(clientDir, filePath),
+            content = await (0, import_promises.readFile)(fullPath, "utf-8");
+          return new Response(content, {
+            headers: {
+              "Content-Type": "text/javascript"
+            }
+          });
+        } catch {
+          return null;
+        }
+      },
+      async handleAPI(param) {
+        var {
+            route: route2
+          } = param,
+          _options_lazyRoutes_api,
+          _options_lazyRoutes;
+        if (!(options == null || (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0 || (_options_lazyRoutes_api = _options_lazyRoutes.api) === null || _options_lazyRoutes_api === void 0) && _options_lazyRoutes_api[route2.page]) return await options.lazyRoutes.api[route2.page]();
+        var fileName = route2.page.slice(1).replace(/\[/g, "_").replace(/\]/g, "_"),
+          apiFile = (0, import_path.join)(process.cwd(), outDir, "api", fileName + (apiCJS ? ".cjs" : ".js"));
+        return await import(apiFile);
+      },
+      async loadMiddleware(route2) {
+        var _options_lazyRoutes_middlewares, _options_lazyRoutes;
+        return !(options == null || (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0 || (_options_lazyRoutes_middlewares = _options_lazyRoutes.middlewares) === null || _options_lazyRoutes_middlewares === void 0) && _options_lazyRoutes_middlewares[route2.contextKey] ? await options.lazyRoutes.middlewares[route2.contextKey]() : await import((0, import_toAbsolute.toAbsolute)(route2.contextKey));
+      },
+      async handleLoader(param) {
+        var {
+            route: route2,
+            loaderProps
+          } = param,
+          routeFile = route2.routeFile || route2.file,
+          serverPath = route2.file.includes(`${outDir}/server`) ? route2.file : (0, import_path.join)("./", `${outDir}/server`, route2.file),
+          loader;
+        try {
+          var loaderResult = resolveLoaderSync(serverPath, routeFile);
+          loader = _instanceof(loaderResult, Promise) ? await loaderResult : loaderResult;
+        } catch (err) {
+          if (err?.code === "ERR_MODULE_NOT_FOUND") return null;
+          throw err;
+        }
+        if (!loader) return null;
+        var json;
+        try {
+          json = await loader(loaderProps);
+        } catch (err) {
+          if (err?.code === "ENOENT") return make404LoaderJs(loaderProps?.path || "/", `ENOENT ${err?.path || err}`);
+          throw err;
+        }
+        if (isResponse(json)) throw json;
+        return `export function loader() { return ${JSON.stringify(json)} }`;
+      },
+      async handlePage(param) {
+        var {
+            route: route2,
+            url,
+            loaderProps
+          } = param,
+          _$buildInfo = routeToBuildInfo[route2.file];
+        if (route2.type === "ssr") {
+          if (!_$buildInfo) throw console.error("Error in route", route2), new Error(`No buildinfo found for ${url}, route: ${route2.file}, in keys:
   ${Object.keys(routeToBuildInfo).join(`
   `)}`);
-        try {
-          var _globalThis___vxrnresetState,
-            _globalThis,
-            layoutRoutes = route2.layouts || [],
-            layoutLoaderPromises = layoutRoutes.map(function (layout) {
-              var serverPath = layout.loaderServerPath || layout.contextKey;
-              return importAndRunLoader(layout.contextKey, serverPath, layout.contextKey, loaderProps);
-            }),
-            pageLoaderPromise = importAndRunLoader(route2.file, _$buildInfo.serverJsPath, route2.file, loaderProps),
-            layoutResults,
-            pageResult;
           try {
-            [layoutResults, pageResult] = await Promise.all([Promise.all(layoutLoaderPromises), pageLoaderPromise]);
-          } catch (err) {
-            if (isResponse(err)) return err;
-            throw err;
-          }
-          if (pageResult.isEnoent) {
-            var nfPath = findNearestNotFoundPath(loaderProps?.path || "/"),
-              nfHtml = routeMap[nfPath];
-            if (nfHtml) try {
-              var html = await (0, import_promises.readFile)((0, import_path.join)(process.cwd(), "dist/client", nfHtml), "utf-8");
-              return new Response(html, {
-                headers: {
-                  "content-type": "text/html"
-                },
+            var _globalThis___vxrnresetState,
+              _globalThis,
+              layoutRoutes = route2.layouts || [],
+              layoutLoaderPromises = layoutRoutes.map(function (layout) {
+                var serverPath = layout.loaderServerPath || layout.contextKey;
+                return importAndRunLoader(layout.contextKey, serverPath, layout.contextKey, loaderProps);
+              }),
+              pageLoaderPromise = importAndRunLoader(route2.file, _$buildInfo.serverJsPath, route2.file, loaderProps),
+              layoutResults,
+              pageResult;
+            try {
+              [layoutResults, pageResult] = await Promise.all([Promise.all(layoutLoaderPromises), pageLoaderPromise]);
+            } catch (err) {
+              if (isResponse(err)) return err;
+              throw err;
+            }
+            if (pageResult.isEnoent) {
+              var nfPath = findNearestNotFoundPath(loaderProps?.path || "/"),
+                nfHtml = routeMap[nfPath];
+              if (nfHtml) try {
+                var html = await (0, import_promises.readFile)((0, import_path.join)(process.cwd(), `${outDir}/client`, nfHtml), "utf-8");
+                return new Response(html, {
+                  headers: {
+                    "content-type": "text/html"
+                  },
+                  status: 404
+                });
+              } catch {}
+              return new Response("404 Not Found", {
                 status: 404
               });
-            } catch {}
-            return new Response("404 Not Found", {
-              status: 404
-            });
-          }
-          var matches = [...layoutResults.map(function (result) {
-              return {
-                routeId: result.routeId,
+            }
+            var matches = [...layoutResults.map(function (result) {
+                return {
+                  routeId: result.routeId,
+                  pathname: loaderProps?.path || "/",
+                  params: loaderProps?.params || {},
+                  loaderData: result.loaderData
+                };
+              }), {
+                routeId: pageResult.routeId,
                 pathname: loaderProps?.path || "/",
                 params: loaderProps?.params || {},
-                loaderData: result.loaderData
-              };
-            }), {
-              routeId: pageResult.routeId,
-              pathname: loaderProps?.path || "/",
-              params: loaderProps?.params || {},
-              loaderData: pageResult.loaderData
-            }],
-            loaderData = pageResult.loaderData,
-            headers = new Headers();
-          headers.set("content-type", "text/html"), (_globalThis___vxrnresetState = (_globalThis = globalThis).__vxrnresetState) === null || _globalThis___vxrnresetState === void 0 || _globalThis___vxrnresetState.call(_globalThis);
-          var rendered = await (await getRender())({
-            mode: route2.type,
-            loaderData,
-            loaderProps,
-            path: loaderProps?.path || "/",
-            // Use separated preloads for optimal loading
-            preloads: _$buildInfo.criticalPreloads || _$buildInfo.preloads,
-            deferredPreloads: _$buildInfo.deferredPreloads,
-            css: _$buildInfo.css,
-            cssContents: _$buildInfo.cssContents,
-            matches
-          });
-          return new Response(rendered, {
-            headers,
-            status: route2.isNotFound ? 404 : 200
-          });
-        } catch (err) {
-          var _ref;
-          if (isResponse(err)) return err;
-          console.error(`[one] Error rendering SSR route ${route2.file}
+                loaderData: pageResult.loaderData
+              }],
+              loaderData = pageResult.loaderData,
+              _iteratorNormalCompletion3 = !0,
+              _didIteratorError3 = !1,
+              _iteratorError3 = void 0;
+            try {
+              for (var _loop2 = function () {
+                  var layout = _step3.value,
+                    key = layout.contextKey,
+                    loaderFn = loaderCache.get(key);
+                  if (loaderFn) {
+                    var result = layoutResults.find(function (r) {
+                      return r.routeId === key;
+                    });
+                    result && (0, import_ssrLoaderData.setSSRLoaderData)(loaderFn, result.loaderData);
+                  }
+                }, _iterator3 = layoutRoutes[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = !0) _loop2();
+            } catch (err) {
+              _didIteratorError3 = !0, _iteratorError3 = err;
+            } finally {
+              try {
+                !_iteratorNormalCompletion3 && _iterator3.return != null && _iterator3.return();
+              } finally {
+                if (_didIteratorError3) throw _iteratorError3;
+              }
+            }
+            var pageLoaderFn = loaderCache.get(route2.file);
+            pageLoaderFn && (0, import_ssrLoaderData.setSSRLoaderData)(pageLoaderFn, pageResult.loaderData);
+            var headers = new Headers();
+            headers.set("content-type", "text/html"), (_globalThis___vxrnresetState = (_globalThis = globalThis).__vxrnresetState) === null || _globalThis___vxrnresetState === void 0 || _globalThis___vxrnresetState.call(_globalThis);
+            var renderProps = {
+                mode: route2.type,
+                loaderData,
+                loaderProps,
+                path: loaderProps?.path || "/",
+                preloads: _$buildInfo.criticalPreloads || _$buildInfo.preloads,
+                deferredPreloads: _$buildInfo.deferredPreloads,
+                css: _$buildInfo.css,
+                cssContents: _$buildInfo.cssContents,
+                matches
+              },
+              _rl = ensureRenderLoaded();
+            _rl && (await _rl);
+            var streamFn = process.env.ONE_BUFFERED_SSR ? null : renderStream;
+            if (streamFn) {
+              var stream = await streamFn(renderProps);
+              return new Response(stream, {
+                headers,
+                status: route2.isNotFound ? 404 : 200
+              });
+            }
+            var rendered = await render(renderProps);
+            return new Response(rendered, {
+              headers,
+              status: route2.isNotFound ? 404 : 200
+            });
+          } catch (err) {
+            var _ref;
+            if (isResponse(err)) return err;
+            console.error(`[one] Error rendering SSR route ${route2.file}
 
 ${(_ref = err?.stack) !== null && _ref !== void 0 ? _ref : err}
 
 url: ${url}`);
-        }
-      } else {
-        var layoutRoutes1 = route2.layouts || [],
-          needsSpaShell = route2.type === "spa" && layoutRoutes1.some(function (layout) {
-            return layout.layoutRenderMode === "ssg" || layout.layoutRenderMode === "ssr";
-          });
-        if (needsSpaShell) try {
-          var _globalThis___vxrnresetState1,
-            _globalThis1,
-            layoutResults1 = await Promise.all(layoutRoutes1.map(function (layout) {
-              var serverPath = layout.loaderServerPath || layout.contextKey;
-              return importAndRunLoader(layout.contextKey, serverPath, layout.contextKey, loaderProps);
-            })),
-            matches1 = layoutResults1.map(function (result) {
-              return {
-                routeId: result.routeId,
-                pathname: loaderProps?.path || "/",
-                params: loaderProps?.params || {},
-                loaderData: result.loaderData
-              };
-            }),
-            headers1 = new Headers();
-          headers1.set("content-type", "text/html"), (_globalThis___vxrnresetState1 = (_globalThis1 = globalThis).__vxrnresetState) === null || _globalThis___vxrnresetState1 === void 0 || _globalThis___vxrnresetState1.call(_globalThis1);
-          var rendered1 = await (await getRender())({
-            mode: "spa-shell",
-            // don't pass loaderData for spa-shell - the page loader runs on client
-            // passing {} here would make useLoaderState think data is preloaded
-            loaderData: void 0,
-            loaderProps,
-            path: loaderProps?.path || "/",
-            preloads: _$buildInfo?.criticalPreloads || _$buildInfo?.preloads,
-            deferredPreloads: _$buildInfo?.deferredPreloads,
-            css: _$buildInfo?.css,
-            cssContents: _$buildInfo?.cssContents,
-            matches: matches1
-          });
-          return new Response(rendered1, {
-            headers: headers1,
-            status: route2.isNotFound ? 404 : 200
-          });
-        } catch (err) {
-          var _ref1;
-          if (isResponse(err)) return err;
-          console.error(`[one] Error rendering spa-shell for ${route2.file}
-${(_ref1 = err?.stack) !== null && _ref1 !== void 0 ? _ref1 : err}
-url: ${url}`);
-        }
-        var isDynamicRoute = Object.keys(route2.routeKeys).length > 0,
-          routeCleanPath = route2.urlCleanPath.replace(/\?/g, ""),
-          notFoundKey = route2.isNotFound ? route2.page.replace(/\[([^\]]+)\]/g, ":$1") : null,
-          htmlPath = notFoundKey ? routeMap[notFoundKey] : isDynamicRoute ? routeMap[routeCleanPath] || routeMap[url.pathname] : routeMap[url.pathname] || routeMap[_$buildInfo?.cleanPath];
-        if (htmlPath) {
-          var html1 = await readStaticHtml(htmlPath);
-          if (html1) {
-            var headers2 = new Headers();
-            return headers2.set("content-type", "text/html"), new Response(html1, {
-              headers: headers2,
+          }
+        } else {
+          var layoutRoutes1 = route2.layouts || [],
+            needsSpaShell = route2.type === "spa" && layoutRoutes1.some(function (layout) {
+              return layout.layoutRenderMode === "ssg" || layout.layoutRenderMode === "ssr";
+            });
+          if (needsSpaShell) try {
+            var _globalThis___vxrnresetState1,
+              _globalThis1,
+              layoutResults1 = await Promise.all(layoutRoutes1.map(function (layout) {
+                var serverPath = layout.loaderServerPath || layout.contextKey;
+                return importAndRunLoader(layout.contextKey, serverPath, layout.contextKey, loaderProps);
+              })),
+              matches1 = layoutResults1.map(function (result) {
+                return {
+                  routeId: result.routeId,
+                  pathname: loaderProps?.path || "/",
+                  params: loaderProps?.params || {},
+                  loaderData: result.loaderData
+                };
+              }),
+              headers1 = new Headers();
+            headers1.set("content-type", "text/html"), (_globalThis___vxrnresetState1 = (_globalThis1 = globalThis).__vxrnresetState) === null || _globalThis___vxrnresetState1 === void 0 || _globalThis___vxrnresetState1.call(_globalThis1);
+            var _rl3 = ensureRenderLoaded();
+            _rl3 && (await _rl3);
+            var rendered1 = await render({
+              mode: "spa-shell",
+              // don't pass loaderData for spa-shell - the page loader runs on client
+              // passing {} here would make useLoaderState think data is preloaded
+              loaderData: void 0,
+              loaderProps,
+              path: loaderProps?.path || "/",
+              preloads: _$buildInfo?.criticalPreloads || _$buildInfo?.preloads,
+              deferredPreloads: _$buildInfo?.deferredPreloads,
+              css: _$buildInfo?.css,
+              cssContents: _$buildInfo?.cssContents,
+              matches: matches1
+            });
+            return new Response(rendered1, {
+              headers: headers1,
               status: route2.isNotFound ? 404 : 200
             });
+          } catch (err) {
+            var _ref1;
+            if (isResponse(err)) return err;
+            console.error(`[one] Error rendering spa-shell for ${route2.file}
+${(_ref1 = err?.stack) !== null && _ref1 !== void 0 ? _ref1 : err}
+url: ${url}`);
           }
-        }
-        if (isDynamicRoute) {
-          var notFoundRoute = findNearestNotFoundPath(url.pathname),
-            notFoundHtmlPath = routeMap[notFoundRoute];
-          if (notFoundHtmlPath) {
-            var notFoundHtml = await readStaticHtml(notFoundHtmlPath);
-            if (notFoundHtml) {
-              var notFoundMarker = `<script>window.__one404={originalPath:"${url.pathname}",notFoundPath:"${notFoundRoute}"}</script>`,
-                injectedHtml = notFoundHtml.includes("</head>") ? notFoundHtml.replace("</head>", `${notFoundMarker}</head>`) : notFoundHtml.replace("<body", `${notFoundMarker}<body`),
-                headers3 = new Headers();
-              return headers3.set("content-type", "text/html"), new Response(injectedHtml, {
-                headers: headers3,
-                status: 404
+          var isDynamicRoute = Object.keys(route2.routeKeys).length > 0,
+            routeCleanPath = route2.urlCleanPath.replace(/\?/g, ""),
+            notFoundKey = route2.isNotFound ? route2.page.replace(/\[([^\]]+)\]/g, ":$1") : null,
+            htmlPath = notFoundKey ? routeMap[notFoundKey] : isDynamicRoute ? routeMap[routeCleanPath] || routeMap[url.pathname] : routeMap[url.pathname] || routeMap[_$buildInfo?.cleanPath];
+          if (htmlPath) {
+            var html1 = await readStaticHtml(htmlPath, outDir);
+            if (html1) {
+              var headers2 = new Headers();
+              return headers2.set("content-type", "text/html"), new Response(html1, {
+                headers: headers2,
+                status: route2.isNotFound ? 404 : 200
               });
             }
           }
-          return new Response("404 Not Found", {
-            status: 404
-          });
+          if (isDynamicRoute) {
+            var notFoundRoute = findNearestNotFoundPath(url.pathname),
+              notFoundHtmlPath = routeMap[notFoundRoute];
+            if (notFoundHtmlPath) {
+              var notFoundHtml = await readStaticHtml(notFoundHtmlPath, outDir);
+              if (notFoundHtml) {
+                var notFoundMarker = `<script>window.__one404={originalPath:"${url.pathname}",notFoundPath:"${notFoundRoute}"}</script>`,
+                  injectedHtml = notFoundHtml.includes("</head>") ? notFoundHtml.replace("</head>", `${notFoundMarker}</head>`) : notFoundHtml.replace("<body", `${notFoundMarker}<body`),
+                  headers3 = new Headers();
+                return headers3.set("content-type", "text/html"), new Response(injectedHtml, {
+                  headers: headers3,
+                  status: 404
+                });
+              }
+            }
+            return new Response("404 Not Found", {
+              status: 404
+            });
+          }
         }
       }
-    }
-  };
+    };
   function createHonoHandler(route2) {
     return async function (context, next) {
       try {
@@ -399,8 +516,9 @@ url: ${url}`);
                   "Content-Type": "text/javascript"
                 }
               });
-              var finalUrl = new URL(originalUrl, url.origin),
-                cleanedRequest = new Request(finalUrl, request);
+              var finalUrl = new URL(originalUrl, url.origin);
+              finalUrl.search = url.search;
+              var cleanedRequest = new Request(finalUrl, request);
               return resolveLoaderRoute(requestHandlers, cleanedRequest, finalUrl, route2);
             }
             switch (route2.type) {
@@ -495,8 +613,9 @@ url: ${url}`);
                 // preserve original for lazy route lookup
                 file: route2.loaderServerPath || c.req.path
               },
-              finalUrl = new URL(originalUrl, url.origin),
-              cleanedRequest = new Request(finalUrl, request);
+              finalUrl = new URL(originalUrl, url.origin);
+            finalUrl.search = url.search;
+            var cleanedRequest = new Request(finalUrl, request);
             try {
               var resolved = await resolveLoaderRoute(requestHandlers, cleanedRequest, finalUrl, loaderRoute);
               return resolved;