one 1.14.4 → 1.15.0

package/dist/esm/server/oneServe.mjs

@@ -20,40 +20,51 @@ async function readStaticHtml(htmlPath, outDir = "dist") {
   }
 }
 async function oneServe(oneOptions, buildInfo, app, options) {
-  const outDir = buildInfo.outDir || "dist",
-    {
-      resolveAPIRoute,
-      resolveLoaderRoute,
-      resolvePageRoute
-    } = await import("../createHandleRequest.mjs"),
-    {
-      isResponse
-    } = await import("../utils/isResponse.mjs"),
-    {
-      isStatusRedirect
-    } = await import("../utils/isStatus.mjs"),
-    {
-      resolveResponse
-    } = await import("../vite/resolveResponse.mjs"),
-    isAPIRequest = /* @__PURE__ */new WeakMap(),
-    redirects = oneOptions.web?.redirects;
-  if (redirects) for (const redirect of redirects) app.get(redirect.source, context => {
-    const destinationUrl = redirect.destination.replace(/:\w+/g, param => {
-      const paramName = param.substring(1);
-      return context.req.param(paramName) || "";
-    });
-    return debugRouter && console.info(`[one] \u21AA redirect ${context.req.path} \u2192 ${destinationUrl}`), context.redirect(destinationUrl, redirect.permanent ? 301 : 302);
-  });
-  if (!buildInfo) throw new Error("No build info found, have you run build?");
+  const outDir = buildInfo.outDir || "dist";
+  const {
+    resolveAPIRoute,
+    resolveLoaderRoute,
+    resolvePageRoute
+  } = await import("../createHandleRequest.mjs");
+  const {
+    isResponse
+  } = await import("../utils/isResponse.mjs");
+  const {
+    isStatusRedirect
+  } = await import("../utils/isStatus.mjs");
+  const {
+    resolveResponse
+  } = await import("../vite/resolveResponse.mjs");
+  const isAPIRequest = /* @__PURE__ */new WeakMap();
+  const redirects = oneOptions.web?.redirects;
+  if (redirects) {
+    for (const redirect of redirects) {
+      app.get(redirect.source, context => {
+        const destinationUrl = redirect.destination.replace(/:\w+/g, param => {
+          const paramName = param.substring(1);
+          return context.req.param(paramName) || "";
+        });
+        if (debugRouter) {
+          console.info(`[one] \u21AA redirect ${context.req.path} \u2192 ${destinationUrl}`);
+        }
+        return context.redirect(destinationUrl, redirect.permanent ? 301 : 302);
+      });
+    }
+  }
+  if (!buildInfo) {
+    throw new Error(`No build info found, have you run build?`);
+  }
   const {
     routeToBuildInfo,
     routeMap
   } = buildInfo;
   function findNearestNotFoundPath(urlPath) {
     let cur = urlPath;
-    for (; cur;) {
+    while (cur) {
       const parent = cur.lastIndexOf("/") > 0 ? cur.slice(0, cur.lastIndexOf("/")) : "";
-      if (routeMap[`${parent}/+not-found`]) return `${parent}/+not-found`;
+      if (routeMap[`${parent}/+not-found`]) {
+        return `${parent}/+not-found`;
+      }
       if (!parent) break;
       cur = parent;
     }
@@ -61,194 +72,258 @@ async function oneServe(oneOptions, buildInfo, app, options) {
   }
   function make404LoaderJs(path, logReason) {
     const nfPath = findNearestNotFoundPath(path);
-    return logReason && console.error(`[one] 404 loader for ${path}: ${logReason}`), `export function loader(){return{__oneError:404,__oneErrorMessage:'Not Found',__oneNotFoundPath:${JSON.stringify(nfPath)}}}`;
+    if (logReason) {
+      console.error(`[one] 404 loader for ${path}: ${logReason}`);
+    }
+    return `export function loader(){return{__oneError:404,__oneErrorMessage:'Not Found',__oneNotFoundPath:${JSON.stringify(nfPath)}}}`;
   }
   const serverOptions = {
-      ...oneOptions,
-      root: "."
-    },
-    apiCJS = oneOptions.build?.api?.outputFormat === "cjs",
-    useStreaming = !process.env.ONE_BUFFERED_SSR,
-    htmlHeaders = {
-      "content-type": "text/html"
-    },
-    ssrHtmlHeaders = {
-      "content-type": "text/html",
-      "cache-control": "no-cache"
-    },
-    loaderCache = /* @__PURE__ */new Map(),
-    moduleImportCache = /* @__PURE__ */new Map(),
-    loaderCacheFnMap = /* @__PURE__ */new Map(),
-    pendingLoaderResults = /* @__PURE__ */new Map();
+    ...oneOptions,
+    root: "."
+  };
+  const apiCJS = oneOptions.build?.api?.outputFormat === "cjs";
+  const useStreaming = !process.env.ONE_BUFFERED_SSR;
+  const htmlHeaders = {
+    "content-type": "text/html"
+  };
+  const ssrHtmlHeaders = {
+    "content-type": "text/html",
+    "cache-control": "no-cache"
+  };
+  const loaderCache = /* @__PURE__ */new Map();
+  const moduleImportCache = /* @__PURE__ */new Map();
+  const loaderCacheFnMap = /* @__PURE__ */new Map();
+  const pendingLoaderResults = /* @__PURE__ */new Map();
   function resolveLoaderSync(serverPath, lazyKey) {
-    const cacheKey = lazyKey || serverPath || "",
-      cached = loaderCache.get(cacheKey);
-    return cached !== void 0 ? cached : (async () => {
-      const pathToResolve = serverPath || lazyKey || "",
-        resolvedPath = pathToResolve.includes(`${outDir}/server`) ? pathToResolve : join("./", `${outDir}/server`, pathToResolve);
+    const cacheKey = lazyKey || serverPath || "";
+    const cached = loaderCache.get(cacheKey);
+    if (cached !== void 0) return cached;
+    return (async () => {
+      const pathToResolve = serverPath || lazyKey || "";
+      const resolvedPath = pathToResolve.includes(`${outDir}/server`) ? pathToResolve : join("./", `${outDir}/server`, pathToResolve);
       let routeExported;
-      moduleImportCache.has(cacheKey) ? routeExported = moduleImportCache.get(cacheKey) : (routeExported = lazyKey ? options?.lazyRoutes?.pages?.[lazyKey] ? await options.lazyRoutes.pages[lazyKey]() : await import(toAbsolute(resolvedPath)) : await import(toAbsolute(serverPath)), moduleImportCache.set(cacheKey, routeExported));
+      if (moduleImportCache.has(cacheKey)) {
+        routeExported = moduleImportCache.get(cacheKey);
+      } else {
+        routeExported = lazyKey ? options?.lazyRoutes?.pages?.[lazyKey] ? await options.lazyRoutes.pages[lazyKey]() : await import(toAbsolute(resolvedPath)) : await import(toAbsolute(serverPath));
+        moduleImportCache.set(cacheKey, routeExported);
+      }
       const loader = routeExported?.loader || null;
       loaderCache.set(cacheKey, loader);
       const loaderCacheFn = routeExported?.loaderCache ?? null;
-      return loaderCacheFnMap.set(cacheKey, loaderCacheFn), loader;
+      loaderCacheFnMap.set(cacheKey, loaderCacheFn);
+      return loader;
     })();
   }
   async function importAndRunLoader(routeId, serverPath, lazyKey, loaderProps) {
-    if (!serverPath && !lazyKey) return {
-      loaderData: void 0,
-      routeId
-    };
-    const cacheMapKey = lazyKey || serverPath || "",
-      loaderCacheFn = loaderCacheFnMap.get(cacheMapKey);
-    let coalFullKey,
-      coalTtl = 0;
+    if (!serverPath && !lazyKey) {
+      return {
+        loaderData: void 0,
+        routeId
+      };
+    }
+    const cacheMapKey = lazyKey || serverPath || "";
+    const loaderCacheFn = loaderCacheFnMap.get(cacheMapKey);
+    let coalFullKey;
+    let coalTtl = 0;
     if (loaderCacheFn) {
-      const cacheResult = loaderCacheFn(loaderProps?.params, loaderProps?.request),
-        cacheKey = typeof cacheResult == "string" ? cacheResult : cacheResult?.key;
-      if (coalTtl = typeof cacheResult == "string" ? 0 : cacheResult?.ttl ?? 0, cacheKey != null) {
+      const cacheResult = loaderCacheFn(loaderProps?.params, loaderProps?.request);
+      const cacheKey = typeof cacheResult === "string" ? cacheResult : cacheResult?.key;
+      coalTtl = typeof cacheResult === "string" ? 0 : cacheResult?.ttl ?? 0;
+      if (cacheKey != null) {
         coalFullKey = routeId + "\0" + cacheKey;
         const existing = pendingLoaderResults.get(coalFullKey);
-        if (existing && (!existing.expires || Date.now() < existing.expires)) return {
-          loaderData: await existing.promise,
-          routeId
-        };
+        if (existing && (!existing.expires || Date.now() < existing.expires)) {
+          const loaderData = await existing.promise;
+          return {
+            loaderData,
+            routeId
+          };
+        }
       }
     }
     try {
-      const loaderOrPromise = resolveLoaderSync(serverPath, lazyKey),
-        loader = loaderOrPromise instanceof Promise ? await loaderOrPromise : loaderOrPromise;
-      if (!loader) return {
-        loaderData: void 0,
-        routeId
-      };
+      const loaderOrPromise = resolveLoaderSync(serverPath, lazyKey);
+      const loader = loaderOrPromise instanceof Promise ? await loaderOrPromise : loaderOrPromise;
+      if (!loader) {
+        return {
+          loaderData: void 0,
+          routeId
+        };
+      }
       if (coalFullKey) {
-        const promise = loader(loaderProps),
-          entry = {
-            promise,
-            expires: 0
-          };
-        return pendingLoaderResults.set(coalFullKey, entry), promise.then(() => {
-          entry.expires = coalTtl > 0 ? Date.now() + coalTtl : 0, coalTtl <= 0 && Promise.resolve().then(() => pendingLoaderResults.delete(coalFullKey));
+        const promise = loader(loaderProps);
+        const entry = {
+          promise,
+          expires: 0
+        };
+        pendingLoaderResults.set(coalFullKey, entry);
+        promise.then(() => {
+          entry.expires = coalTtl > 0 ? Date.now() + coalTtl : 0;
+          if (coalTtl <= 0) {
+            Promise.resolve().then(() => pendingLoaderResults.delete(coalFullKey));
+          }
         }, () => {
           pendingLoaderResults.delete(coalFullKey);
-        }), {
-          loaderData: await promise,
+        });
+        const loaderData2 = await promise;
+        return {
+          loaderData: loaderData2,
           routeId
         };
       }
+      const loaderData = await loader(loaderProps);
       return {
-        loaderData: await loader(loaderProps),
+        loaderData,
         routeId
       };
     } catch (err) {
-      if (isResponse(err)) throw err;
-      return err?.code === "ENOENT" ? {
-        loaderData: void 0,
-        routeId,
-        isEnoent: !0
-      } : (console.error(`[one] Error running loader for ${routeId}:`, err), {
+      if (isResponse(err)) {
+        throw err;
+      }
+      if (err?.code === "ENOENT") {
+        return {
+          loaderData: void 0,
+          routeId,
+          isEnoent: true
+        };
+      }
+      console.error(`[one] Error running loader for ${routeId}:`, err);
+      return {
         loaderData: void 0,
         routeId
-      });
+      };
     }
   }
-  let render = null,
-    renderStream = null,
-    renderLoading = null;
+  let render = null;
+  let renderStream = null;
+  let renderLoading = null;
   function ensureRenderLoaded() {
-    if (!render) return renderLoading || (renderLoading = (async () => {
-      const entry = options?.lazyRoutes?.serverEntry ? await options.lazyRoutes.serverEntry() : await import(resolve(process.cwd(), `${serverOptions.root}/${outDir}/server/_virtual_one-entry.${typeof oneOptions.build?.server == "object" && oneOptions.build.server.outputFormat === "cjs" ? "c" : ""}js`));
-      render = entry.default.render, renderStream = entry.default.renderStream;
-    })(), renderLoading);
+    if (render) return;
+    if (renderLoading) return renderLoading;
+    renderLoading = (async () => {
+      const entry = options?.lazyRoutes?.serverEntry ? await options.lazyRoutes.serverEntry() : await import(resolve(process.cwd(), `${serverOptions.root}/${outDir}/server/_virtual_one-entry.${typeof oneOptions.build?.server === "object" && oneOptions.build.server.outputFormat === "cjs" ? "c" : ""}js`));
+      render = entry.default.render;
+      renderStream = entry.default.renderStream;
+    })();
+    return renderLoading;
   }
-  const clientDir = join(process.cwd(), outDir, "client"),
-    requestHandlers = {
-      async handleStaticFile(filePath) {
-        try {
-          const fullPath = join(clientDir, filePath),
-            content = await readFile(fullPath, "utf-8");
-          return new Response(content, {
-            headers: {
-              "Content-Type": "text/javascript"
-            }
-          });
-        } catch {
+  const clientDir = join(process.cwd(), outDir, "client");
+  const requestHandlers = {
+    async handleStaticFile(filePath) {
+      try {
+        const fullPath = join(clientDir, filePath);
+        const content = await readFile(fullPath, "utf-8");
+        return new Response(content, {
+          headers: {
+            "Content-Type": "text/javascript"
+          }
+        });
+      } catch {
+        return null;
+      }
+    },
+    async handleAPI({
+      route
+    }) {
+      if (options?.lazyRoutes?.api?.[route.page]) {
+        return await options.lazyRoutes.api[route.page]();
+      }
+      const fileName = route.page.slice(1).replace(/\[/g, "_").replace(/\]/g, "_");
+      const apiFile = join(process.cwd(), outDir, "api", fileName + (apiCJS ? ".cjs" : ".js"));
+      return await import(apiFile);
+    },
+    async loadMiddleware(route) {
+      if (options?.lazyRoutes?.middlewares?.[route.contextKey]) {
+        return await options.lazyRoutes.middlewares[route.contextKey]();
+      }
+      return await import(toAbsolute(route.contextKey));
+    },
+    async handleLoader({
+      route,
+      loaderProps
+    }) {
+      const routeFile = route.routeFile || route.file;
+      const serverPath = route.file.includes(`${outDir}/server`) ? route.file : join("./", `${outDir}/server`, route.file);
+      let loader;
+      try {
+        const loaderResult = resolveLoaderSync(serverPath, routeFile);
+        loader = loaderResult instanceof Promise ? await loaderResult : loaderResult;
+      } catch (err) {
+        if (err?.code === "ERR_MODULE_NOT_FOUND") {
           return null;
         }
-      },
-      async handleAPI({
-        route
-      }) {
-        if (options?.lazyRoutes?.api?.[route.page]) return await options.lazyRoutes.api[route.page]();
-        const fileName = route.page.slice(1).replace(/\[/g, "_").replace(/\]/g, "_");
-        return await import(join(process.cwd(), outDir, "api", fileName + (apiCJS ? ".cjs" : ".js")));
-      },
-      async loadMiddleware(route) {
-        return options?.lazyRoutes?.middlewares?.[route.contextKey] ? await options.lazyRoutes.middlewares[route.contextKey]() : await import(toAbsolute(route.contextKey));
-      },
-      async handleLoader({
-        route,
-        loaderProps
-      }) {
-        const routeFile = route.routeFile || route.file,
-          serverPath = route.file.includes(`${outDir}/server`) ? route.file : join("./", `${outDir}/server`, route.file);
-        let loader;
-        try {
-          const loaderResult = resolveLoaderSync(serverPath, routeFile);
-          loader = loaderResult instanceof Promise ? await loaderResult : loaderResult;
-        } catch (err) {
-          if (err?.code === "ERR_MODULE_NOT_FOUND") return null;
-          throw err;
+        throw err;
+      }
+      if (!loader) {
+        return null;
+      }
+      let json;
+      try {
+        json = await loader(loaderProps);
+      } catch (err) {
+        if (err?.code === "ENOENT") {
+          return make404LoaderJs(loaderProps?.path || "/", `ENOENT ${err?.path || err}`);
         }
-        if (!loader) return null;
-        let json;
-        try {
-          json = await loader(loaderProps);
-        } catch (err) {
-          if (err?.code === "ENOENT") return make404LoaderJs(loaderProps?.path || "/", `ENOENT ${err?.path || err}`);
-          throw err;
+        throw err;
+      }
+      if (isResponse(json)) {
+        throw json;
+      }
+      return `export function loader() { return ${JSON.stringify(json)} }`;
+    },
+    async handlePage({
+      route,
+      url,
+      loaderProps
+    }) {
+      const buildInfo2 = routeToBuildInfo[route.file];
+      if (route.type === "ssr") {
+        if (!buildInfo2) {
+          console.error(`Error in route`, route);
+          throw new Error(`No buildinfo found for ${url}, route: ${route.file}, in keys:
+  ${Object.keys(routeToBuildInfo).join("\n  ")}`);
         }
-        if (isResponse(json)) throw json;
-        return `export function loader() { return ${JSON.stringify(json)} }`;
-      },
-      async handlePage({
-        route,
-        url,
-        loaderProps
-      }) {
-        const buildInfo2 = routeToBuildInfo[route.file];
-        if (route.type === "ssr") {
-          if (!buildInfo2) throw console.error("Error in route", route), new Error(`No buildinfo found for ${url}, route: ${route.file}, in keys:
-  ${Object.keys(routeToBuildInfo).join(`
-  `)}`);
-          try {
-            const layoutRoutes = route.layouts || [],
-              layoutLoaderPromises = [],
-              noLoaderResults = [];
-            for (const layout of layoutRoutes) {
-              const serverPath = layout.loaderServerPath || layout.contextKey,
-                cacheKey = layout.contextKey || serverPath || "";
-              loaderCache.get(cacheKey) === null ? noLoaderResults.push({
+        try {
+          const layoutRoutes = route.layouts || [];
+          const layoutLoaderPromises = [];
+          const noLoaderResults = [];
+          for (const layout of layoutRoutes) {
+            const serverPath = layout.loaderServerPath || layout.contextKey;
+            const cacheKey = layout.contextKey || serverPath || "";
+            const cachedLoader = loaderCache.get(cacheKey);
+            if (cachedLoader === null) {
+              noLoaderResults.push({
                 loaderData: void 0,
                 routeId: layout.contextKey
-              }) : layoutLoaderPromises.push(importAndRunLoader(layout.contextKey, serverPath, layout.contextKey, loaderProps));
+              });
+            } else {
+              layoutLoaderPromises.push(importAndRunLoader(layout.contextKey, serverPath, layout.contextKey, loaderProps));
             }
-            const pageLoaderPromise = importAndRunLoader(route.file, buildInfo2.serverJsPath, route.file, loaderProps);
-            let layoutResults, pageResult;
-            try {
-              if (layoutLoaderPromises.length === 0) layoutResults = noLoaderResults, pageResult = await pageLoaderPromise;else {
-                const [asyncLayoutResults, pr] = await Promise.all([Promise.all(layoutLoaderPromises), pageLoaderPromise]);
-                layoutResults = [...noLoaderResults, ...asyncLayoutResults], pageResult = pr;
-              }
-            } catch (err) {
-              if (isResponse(err)) return err;
-              throw err;
+          }
+          const pageLoaderPromise = importAndRunLoader(route.file, buildInfo2.serverJsPath, route.file, loaderProps);
+          let layoutResults;
+          let pageResult;
+          try {
+            if (layoutLoaderPromises.length === 0) {
+              layoutResults = noLoaderResults;
+              pageResult = await pageLoaderPromise;
+            } else {
+              const [asyncLayoutResults, pr] = await Promise.all([Promise.all(layoutLoaderPromises), pageLoaderPromise]);
+              layoutResults = [...noLoaderResults, ...asyncLayoutResults];
+              pageResult = pr;
+            }
+          } catch (err) {
+            if (isResponse(err)) {
+              return err;
             }
-            if (pageResult.isEnoent) {
-              const nfPath = findNearestNotFoundPath(loaderProps?.path || "/"),
-                nfHtml = routeMap[nfPath];
-              if (nfHtml) try {
+            throw err;
+          }
+          if (pageResult.isEnoent) {
+            const nfPath = findNearestNotFoundPath(loaderProps?.path || "/");
+            const nfHtml = routeMap[nfPath];
+            if (nfHtml) {
+              try {
                 const html = await readFile(join(process.cwd(), `${outDir}/client`, nfHtml), "utf-8");
                 return new Response(html, {
                   headers: {
@@ -257,89 +332,100 @@ async function oneServe(oneOptions, buildInfo, app, options) {
                   status: 404
                 });
               } catch {}
-              return new Response("404 Not Found", {
-                status: 404
-              });
-            }
-            const matchPathname = loaderProps?.path || "/",
-              matchParams = loaderProps?.params || {},
-              matches = new Array(layoutResults.length + 1);
-            for (let i = 0; i < layoutResults.length; i++) {
-              const result = layoutResults[i];
-              matches[i] = {
-                routeId: result.routeId,
-                pathname: matchPathname,
-                params: matchParams,
-                loaderData: result.loaderData
-              };
             }
-            matches[layoutResults.length] = {
-              routeId: pageResult.routeId,
+            return new Response("404 Not Found", {
+              status: 404
+            });
+          }
+          const matchPathname = loaderProps?.path || "/";
+          const matchParams = loaderProps?.params || {};
+          const matches = new Array(layoutResults.length + 1);
+          for (let i = 0; i < layoutResults.length; i++) {
+            const result = layoutResults[i];
+            matches[i] = {
+              routeId: result.routeId,
               pathname: matchPathname,
               params: matchParams,
-              loaderData: pageResult.loaderData
+              loaderData: result.loaderData
             };
-            const loaderData = pageResult.loaderData;
-            for (const layout of layoutRoutes) {
-              const key = layout.contextKey,
-                loaderFn = loaderCache.get(key);
-              if (loaderFn) {
-                const result = layoutResults.find(r => r.routeId === key);
-                result && setSSRLoaderData(loaderFn, result.loaderData);
+          }
+          matches[layoutResults.length] = {
+            routeId: pageResult.routeId,
+            pathname: matchPathname,
+            params: matchParams,
+            loaderData: pageResult.loaderData
+          };
+          const loaderData = pageResult.loaderData;
+          for (const layout of layoutRoutes) {
+            const key = layout.contextKey;
+            const loaderFn = loaderCache.get(key);
+            if (loaderFn) {
+              const result = layoutResults.find(r => r.routeId === key);
+              if (result) {
+                setSSRLoaderData(loaderFn, result.loaderData);
               }
             }
-            const pageLoaderFn = loaderCache.get(route.file);
-            pageLoaderFn && setSSRLoaderData(pageLoaderFn, pageResult.loaderData), globalThis.__vxrnresetState?.();
-            const renderProps = {
-                mode: route.type,
-                loaderData,
-                loaderProps,
-                path: loaderProps?.path || "/",
-                preloads: buildInfo2.criticalPreloads || buildInfo2.preloads,
-                deferredPreloads: buildInfo2.deferredPreloads,
-                css: buildInfo2.css,
-                cssContents: buildInfo2.cssContents,
-                matches
-              },
-              _rl = ensureRenderLoaded();
-            _rl && (await _rl);
-            const status = route.isNotFound ? 404 : 200,
-              responseHeaders = route.isNotFound ? htmlHeaders : ssrHtmlHeaders;
-            if (useStreaming) {
-              const stream = await renderStream(renderProps);
-              return new Response(stream, {
-                headers: responseHeaders,
-                status
-              });
-            }
-            const rendered = await render(renderProps);
-            return new Response(rendered, {
+          }
+          const pageLoaderFn = loaderCache.get(route.file);
+          if (pageLoaderFn) {
+            setSSRLoaderData(pageLoaderFn, pageResult.loaderData);
+          }
+          globalThis["__vxrnresetState"]?.();
+          const renderProps = {
+            mode: route.type,
+            loaderData,
+            loaderProps,
+            path: loaderProps?.path || "/",
+            preloads: buildInfo2.criticalPreloads || buildInfo2.preloads,
+            deferredPreloads: buildInfo2.deferredPreloads,
+            css: buildInfo2.css,
+            cssContents: buildInfo2.cssContents,
+            matches
+          };
+          const _rl = ensureRenderLoaded();
+          if (_rl) await _rl;
+          const status = route.isNotFound ? 404 : 200;
+          const responseHeaders = route.isNotFound ? htmlHeaders : ssrHtmlHeaders;
+          if (useStreaming) {
+            const stream = await renderStream(renderProps);
+            return new Response(stream, {
               headers: responseHeaders,
               status
             });
-          } catch (err) {
-            if (isResponse(err)) return err;
-            console.error(`[one] Error rendering SSR route ${route.file}
+          }
+          const rendered = await render(renderProps);
+          return new Response(rendered, {
+            headers: responseHeaders,
+            status
+          });
+        } catch (err) {
+          if (isResponse(err)) {
+            return err;
+          }
+          console.error(`[one] Error rendering SSR route ${route.file}
 
-${err?.stack ?? err}
+${err?.["stack"] ?? err}
 
 url: ${url}`);
-          }
-        } else {
-          const layoutRoutes = route.layouts || [];
-          if (route.type === "spa" && layoutRoutes.some(layout => layout.layoutRenderMode === "ssg" || layout.layoutRenderMode === "ssr")) try {
-            const matches = (await Promise.all(layoutRoutes.map(layout => {
+        }
+      } else {
+        const layoutRoutes = route.layouts || [];
+        const needsSpaShell = route.type === "spa" && layoutRoutes.some(layout => layout.layoutRenderMode === "ssg" || layout.layoutRenderMode === "ssr");
+        if (needsSpaShell) {
+          try {
+            const layoutResults = await Promise.all(layoutRoutes.map(layout => {
               const serverPath = layout.loaderServerPath || layout.contextKey;
               return importAndRunLoader(layout.contextKey, serverPath, layout.contextKey, loaderProps);
-            }))).map(result => ({
+            }));
+            const matches = layoutResults.map(result => ({
               routeId: result.routeId,
               pathname: loaderProps?.path || "/",
               params: loaderProps?.params || {},
               loaderData: result.loaderData
             }));
-            globalThis.__vxrnresetState?.();
+            globalThis["__vxrnresetState"]?.();
             const _rl3 = ensureRenderLoaded();
-            _rl3 && (await _rl3);
+            if (_rl3) await _rl3;
             const rendered = await render({
               mode: "spa-shell",
               // don't pass loaderData for spa-shell - the page loader runs on client
@@ -358,103 +444,121 @@ url: ${url}`);
               status: route.isNotFound ? 404 : 200
             });
           } catch (err) {
-            if (isResponse(err)) return err;
+            if (isResponse(err)) {
+              return err;
+            }
             console.error(`[one] Error rendering spa-shell for ${route.file}
-${err?.stack ?? err}
+${err?.["stack"] ?? err}
 url: ${url}`);
           }
-          const isDynamicRoute = Object.keys(route.routeKeys).length > 0,
-            routeCleanPath = route.urlCleanPath.replace(/\?/g, ""),
-            notFoundKey = route.isNotFound ? route.page.replace(/\[([^\]]+)\]/g, ":$1") : null,
-            htmlPath = notFoundKey ? routeMap[notFoundKey] : isDynamicRoute ? routeMap[routeCleanPath] || routeMap[url.pathname] : routeMap[url.pathname] || routeMap[buildInfo2?.cleanPath];
-          if (htmlPath) {
-            const html = await readStaticHtml(htmlPath, outDir);
-            if (html) {
+        }
+        const isDynamicRoute = Object.keys(route.routeKeys).length > 0;
+        const routeCleanPath = route.urlCleanPath.replace(/\?/g, "");
+        const notFoundKey = route.isNotFound ? route.page.replace(/\[([^\]]+)\]/g, ":$1") : null;
+        const htmlPath = notFoundKey ? routeMap[notFoundKey] : isDynamicRoute ? routeMap[routeCleanPath] || routeMap[url.pathname] : routeMap[url.pathname] || routeMap[buildInfo2?.cleanPath];
+        if (htmlPath) {
+          const html = await readStaticHtml(htmlPath, outDir);
+          if (html) {
+            const headers = new Headers();
+            headers.set("content-type", "text/html");
+            return new Response(html, {
+              headers,
+              status: route.isNotFound ? 404 : 200
+            });
+          }
+        }
+        if (isDynamicRoute) {
+          const notFoundRoute = findNearestNotFoundPath(url.pathname);
+          const notFoundHtmlPath = routeMap[notFoundRoute];
+          if (notFoundHtmlPath) {
+            const notFoundHtml = await readStaticHtml(notFoundHtmlPath, outDir);
+            if (notFoundHtml) {
+              const notFoundMarker = `<script>window.__one404=${JSON.stringify({
+                originalPath: url.pathname,
+                notFoundPath: notFoundRoute
+              })}</script>`;
+              const injectedHtml = notFoundHtml.includes("</head>") ? notFoundHtml.replace("</head>", `${notFoundMarker}</head>`) : notFoundHtml.replace("<body", `${notFoundMarker}<body`);
               const headers = new Headers();
-              return headers.set("content-type", "text/html"), new Response(html, {
+              headers.set("content-type", "text/html");
+              return new Response(injectedHtml, {
                 headers,
-                status: route.isNotFound ? 404 : 200
+                status: 404
               });
             }
           }
-          if (isDynamicRoute) {
-            const notFoundRoute = findNearestNotFoundPath(url.pathname),
-              notFoundHtmlPath = routeMap[notFoundRoute];
-            if (notFoundHtmlPath) {
-              const notFoundHtml = await readStaticHtml(notFoundHtmlPath, outDir);
-              if (notFoundHtml) {
-                const notFoundMarker = `<script>window.__one404=${JSON.stringify({
-                    originalPath: url.pathname,
-                    notFoundPath: notFoundRoute
-                  })}</script>`,
-                  injectedHtml = notFoundHtml.includes("</head>") ? notFoundHtml.replace("</head>", `${notFoundMarker}</head>`) : notFoundHtml.replace("<body", `${notFoundMarker}<body`),
-                  headers = new Headers();
-                return headers.set("content-type", "text/html"), new Response(injectedHtml, {
-                  headers,
-                  status: 404
-                });
-              }
-            }
-            return new Response("404 Not Found", {
-              status: 404
-            });
-          }
+          return new Response("404 Not Found", {
+            status: 404
+          });
         }
       }
-    };
+    }
+  };
   function createHonoHandler(route) {
     const isDynamicOrNotFound = route.page.endsWith("/+not-found") || Object.keys(route.routeKeys).length > 0;
     return async (context, next) => {
       try {
         const request = context.req.raw;
-        if (isDynamicOrNotFound && options?.serveStaticAssets) {
-          const staticAssetResponse = await options.serveStaticAssets({
-            context
-          });
-          if (staticAssetResponse) return await runMiddlewares(requestHandlers, request, route, async () => staticAssetResponse);
+        if (isDynamicOrNotFound) {
+          if (options?.serveStaticAssets) {
+            const staticAssetResponse = await options.serveStaticAssets({
+              context
+            });
+            if (staticAssetResponse) {
+              return await runMiddlewares(requestHandlers, request, route, async () => staticAssetResponse);
+            }
+          }
         }
         const reqPath = context.req.path;
-        if (reqPath.endsWith(".js") || reqPath.endsWith(".css")) return next();
+        if (reqPath.endsWith(".js") || reqPath.endsWith(".css")) {
+          return next();
+        }
         if (route.type === "ssr" && !route.middlewares?.length && !reqPath.endsWith(LOADER_JS_POSTFIX_UNCACHED)) {
-          debugRouter && console.info(`[one] \u26A1 ${reqPath} \u2192 matched page route: ${route.page} (ssr)`);
-          const pathname = reqPath,
-            rawUrl = request.url,
-            qIdx = rawUrl.indexOf("?"),
-            search = qIdx >= 0 ? rawUrl.slice(qIdx) : "",
-            params = {},
-            match = route.compiledRegex.exec(pathname);
-          if (match?.groups) for (const [key, value] of Object.entries(match.groups)) {
-            const namedKey = route.routeKeys[key];
-            params[namedKey] = value;
+          if (debugRouter) {
+            console.info(`[one] \u26A1 ${reqPath} \u2192 matched page route: ${route.page} (ssr)`);
+          }
+          const pathname = reqPath;
+          const rawUrl = request.url;
+          const qIdx = rawUrl.indexOf("?");
+          const search = qIdx >= 0 ? rawUrl.slice(qIdx) : "";
+          const params = {};
+          const match = route.compiledRegex.exec(pathname);
+          if (match?.groups) {
+            for (const [key, value] of Object.entries(match.groups)) {
+              const namedKey = route.routeKeys[key];
+              params[namedKey] = value;
+            }
           }
           const loaderProps = {
-              path: pathname,
-              search,
-              subdomain: getSubdomain(getURLfromRequestURL(request)),
-              request,
-              params
-            },
-            url2 = getURLfromRequestURL(request),
-            response2 = await resolveResponse(async () => {
-              try {
-                return await requestHandlers.handlePage({
-                  request,
-                  route,
-                  url: url2,
-                  loaderProps
-                });
-              } catch (err) {
-                if (isResponse(err)) return err;
-                throw err;
+            path: pathname,
+            search,
+            subdomain: getSubdomain(getURLfromRequestURL(request)),
+            request,
+            params
+          };
+          const url2 = getURLfromRequestURL(request);
+          const response2 = await resolveResponse(async () => {
+            try {
+              return await requestHandlers.handlePage({
+                request,
+                route,
+                url: url2,
+                loaderProps
+              });
+            } catch (err) {
+              if (isResponse(err)) {
+                return err;
               }
-            });
+              throw err;
+            }
+          });
           if (response2) {
             if (isResponse(response2)) {
               if (isStatusRedirect(response2.status)) {
                 const location = `${response2.headers.get("location") || ""}`;
-                return response2.headers.forEach((value, key) => {
+                response2.headers.forEach((value, key) => {
                   context.header(key, value);
-                }), context.redirect(location, response2.status);
+                });
+                return context.redirect(location, response2.status);
               }
               return response2;
             }
@@ -462,82 +566,155 @@ url: ${url}`);
           }
           return next();
         }
-        const url = getURLfromRequestURL(request),
-          response = await (() => {
-            if (url.pathname.endsWith(LOADER_JS_POSTFIX_UNCACHED)) {
-              const originalUrl = getPathFromLoaderPath(url.pathname);
-              if (route.type === "ssg" && Object.keys(route.routeKeys).length > 0 && !routeMap[originalUrl]) return new Response(make404LoaderJs(originalUrl, "ssg route not in routeMap"), {
-                headers: {
-                  "Content-Type": "text/javascript"
-                }
-              });
-              const finalUrl = new URL(originalUrl, url.origin);
-              finalUrl.search = url.search;
-              const cleanedRequest = new Request(finalUrl, request);
-              return resolveLoaderRoute(requestHandlers, cleanedRequest, finalUrl, route);
-            }
-            switch (route.type) {
-              case "api":
-                return debugRouter && console.info(`[one] \u26A1 ${url.pathname} \u2192 matched API route: ${route.page}`), resolveAPIRoute(requestHandlers, request, url, route);
-              case "ssg":
-              case "spa":
-              case "ssr":
-                return debugRouter && console.info(`[one] \u26A1 ${url.pathname} \u2192 matched page route: ${route.page} (${route.type})`), resolvePageRoute(requestHandlers, request, url, route);
+        const url = getURLfromRequestURL(request);
+        const response = await (() => {
+          if (url.pathname.endsWith(LOADER_JS_POSTFIX_UNCACHED)) {
+            const originalUrl = getPathFromLoaderPath(url.pathname);
+            if (route.type === "ssg" && Object.keys(route.routeKeys).length > 0) {
+              if (!routeMap[originalUrl]) {
+                return new Response(make404LoaderJs(originalUrl, "ssg route not in routeMap"), {
+                  headers: {
+                    "Content-Type": "text/javascript"
+                  }
+                });
+              }
             }
-          })();
+            const finalUrl = new URL(originalUrl, url.origin);
+            finalUrl.search = url.search;
+            const cleanedRequest = new Request(finalUrl, request);
+            return resolveLoaderRoute(requestHandlers, cleanedRequest, finalUrl, route);
+          }
+          switch (route.type) {
+            case "api":
+              {
+                if (debugRouter) {
+                  console.info(`[one] \u26A1 ${url.pathname} \u2192 matched API route: ${route.page}`);
+                }
+                return resolveAPIRoute(requestHandlers, request, url, route);
+              }
+            case "ssg":
+            case "spa":
+            case "ssr":
+              {
+                if (debugRouter) {
+                  console.info(`[one] \u26A1 ${url.pathname} \u2192 matched page route: ${route.page} (${route.type})`);
+                }
+                return resolvePageRoute(requestHandlers, request, url, route);
+              }
+          }
+        })();
         if (response) {
           if (isResponse(response)) {
             if (isStatusRedirect(response.status)) {
               const location = `${response.headers.get("location") || ""}`;
-              return response.headers.forEach((value, key) => {
+              response.headers.forEach((value, key) => {
                 context.header(key, value);
-              }), context.redirect(location, response.status);
+              });
+              return context.redirect(location, response.status);
             }
-            if (isAPIRequest.get(request)) try {
-              return !response.headers.has("cache-control") && !response.headers.has("Cache-Control") && response.headers.set("cache-control", "no-store"), response;
-            } catch (err) {
-              console.info(`Error updating cache header on api route "${context.req.path}" to no-store, it is ${response.headers.get("cache-control")}, continue`, err);
+            if (isAPIRequest.get(request)) {
+              try {
+                if (!response.headers.has("cache-control") && !response.headers.has("Cache-Control")) {
+                  response.headers.set("cache-control", "no-store");
+                }
+                return response;
+              } catch (err) {
+                console.info(`Error updating cache header on api route "${context.req.path}" to no-store, it is ${response.headers.get("cache-control")}, continue`, err);
+              }
             }
-            return !response.headers.has("cache-control") && !response.headers.has("Cache-Control") && (route.type === "ssg" || route.type === "spa" ? response.headers.set("cache-control", "public, s-maxage=60, stale-while-revalidate=120") : response.headers.set("cache-control", "no-cache")), response;
+            if (!response.headers.has("cache-control") && !response.headers.has("Cache-Control")) {
+              if (route.type === "ssg" || route.type === "spa") {
+                response.headers.set("cache-control", "public, s-maxage=60, stale-while-revalidate=120");
+              } else {
+                response.headers.set("cache-control", "no-cache");
+              }
+            }
+            return response;
           }
           return next();
         }
       } catch (err) {
-        console.error(` [one] Error handling request: ${err.stack}`);
+        console.error(` [one] Error handling request: ${err["stack"]}`);
       }
       return next();
     };
   }
   const compiledManifest = compileManifest(buildInfo.manifest);
-  for (const route of compiledManifest.apiRoutes) app.get(route.urlPath, createHonoHandler(route)), app.put(route.urlPath, createHonoHandler(route)), app.post(route.urlPath, createHonoHandler(route)), app.delete(route.urlPath, createHonoHandler(route)), app.patch(route.urlPath, createHonoHandler(route)), route.urlPath !== route.urlCleanPath && (app.get(route.urlCleanPath, createHonoHandler(route)), app.put(route.urlCleanPath, createHonoHandler(route)), app.post(route.urlCleanPath, createHonoHandler(route)), app.delete(route.urlCleanPath, createHonoHandler(route)), app.patch(route.urlCleanPath, createHonoHandler(route)));
-  for (const route of compiledManifest.pageRoutes) app.get(route.urlPath, createHonoHandler(route)), route.urlPath !== route.urlCleanPath && app.get(route.urlCleanPath, createHonoHandler(route));
+  for (const route of compiledManifest.apiRoutes) {
+    app.get(route.urlPath, createHonoHandler(route));
+    app.put(route.urlPath, createHonoHandler(route));
+    app.post(route.urlPath, createHonoHandler(route));
+    app.delete(route.urlPath, createHonoHandler(route));
+    app.patch(route.urlPath, createHonoHandler(route));
+    if (route.urlPath !== route.urlCleanPath) {
+      app.get(route.urlCleanPath, createHonoHandler(route));
+      app.put(route.urlCleanPath, createHonoHandler(route));
+      app.post(route.urlCleanPath, createHonoHandler(route));
+      app.delete(route.urlCleanPath, createHonoHandler(route));
+      app.patch(route.urlCleanPath, createHonoHandler(route));
+    }
+  }
+  for (const route of compiledManifest.pageRoutes) {
+    app.get(route.urlPath, createHonoHandler(route));
+    if (route.urlPath !== route.urlCleanPath) {
+      app.get(route.urlCleanPath, createHonoHandler(route));
+    }
+  }
   const {
     preloads,
     cssPreloads
   } = buildInfo;
   app.get("*", async (c, next) => {
-    if (c.req.path.endsWith(PRELOAD_JS_POSTFIX) && !preloads[c.req.path]) return c.header("Content-Type", "text/javascript"), c.status(200), c.body("");
-    if (c.req.path.endsWith(CSS_PRELOAD_JS_POSTFIX) && !cssPreloads?.[c.req.path]) return c.header("Content-Type", "text/javascript"), c.status(200), c.body("export default Promise.resolve()");
+    if (c.req.path.endsWith(PRELOAD_JS_POSTFIX)) {
+      if (!preloads[c.req.path]) {
+        c.header("Content-Type", "text/javascript");
+        c.status(200);
+        return c.body(``);
+      }
+    }
+    if (c.req.path.endsWith(CSS_PRELOAD_JS_POSTFIX)) {
+      if (!cssPreloads?.[c.req.path]) {
+        c.header("Content-Type", "text/javascript");
+        c.status(200);
+        return c.body(`export default Promise.resolve()`);
+      }
+    }
     if (c.req.path.endsWith(LOADER_JS_POSTFIX_UNCACHED)) {
-      const request = c.req.raw,
-        url = getURLfromRequestURL(request),
-        originalUrl = getPathFromLoaderPath(c.req.path);
+      const request = c.req.raw;
+      const url = getURLfromRequestURL(request);
+      const originalUrl = getPathFromLoaderPath(c.req.path);
       for (const route of compiledManifest.pageRoutes) {
-        if (route.file === "" || !route.compiledRegex.test(originalUrl)) continue;
-        if (route.type === "ssg" && Object.keys(route.routeKeys).length > 0 && !routeMap[originalUrl]) return c.header("Content-Type", "text/javascript"), c.status(200), c.body(make404LoaderJs(originalUrl, "ssg route not in routeMap"));
+        if (route.file === "") {
+          continue;
+        }
+        if (!route.compiledRegex.test(originalUrl)) {
+          continue;
+        }
+        if (route.type === "ssg" && Object.keys(route.routeKeys).length > 0 && !routeMap[originalUrl]) {
+          c.header("Content-Type", "text/javascript");
+          c.status(200);
+          return c.body(make404LoaderJs(originalUrl, "ssg route not in routeMap"));
+        }
         const loaderRoute = {
-            ...route,
-            routeFile: route.file,
-            // preserve original for lazy route lookup
-            file: route.loaderServerPath || c.req.path
-          },
-          finalUrl = new URL(originalUrl, url.origin);
+          ...route,
+          routeFile: route.file,
+          // preserve original for lazy route lookup
+          file: route.loaderServerPath || c.req.path
+        };
+        const finalUrl = new URL(originalUrl, url.origin);
         finalUrl.search = url.search;
         const cleanedRequest = new Request(finalUrl, request);
         try {
-          return await resolveLoaderRoute(requestHandlers, cleanedRequest, finalUrl, loaderRoute);
+          const resolved = await resolveLoaderRoute(requestHandlers, cleanedRequest, finalUrl, loaderRoute);
+          return resolved;
         } catch (err) {
-          return err?.code === "ERR_MODULE_NOT_FOUND" ? (c.header("Content-Type", "text/javascript"), c.status(200), c.body("export function loader() { return undefined }")) : (console.error(`Error running loader: ${err}`), next());
+          if (err?.code === "ERR_MODULE_NOT_FOUND") {
+            c.header("Content-Type", "text/javascript");
+            c.status(200);
+            return c.body(`export function loader() { return undefined }`);
+          }
+          console.error(`Error running loader: ${err}`);
+          return next();
         }
       }
     }