one 1.14.4 → 1.15.0

package/dist/cjs/server/workerHandler.cjs

@@ -3,82 +3,89 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-    for (var name in all) __defProp(target, name, {
-      get: all[name],
-      enumerable: !0
-    });
-  },
-  __copyProps = (to, from, except, desc) => {
-    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
       get: () => from[key],
       enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
     });
-    return to;
-  };
+  }
+  return to;
+};
 var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: !0
+  value: true
 }), mod);
 var workerHandler_exports = {};
 __export(workerHandler_exports, {
   createWorkerHandler: () => createWorkerHandler
 });
 module.exports = __toCommonJS(workerHandler_exports);
-var import_constants = require("../constants.cjs"),
-  import_createHandleRequest = require("../createHandleRequest.cjs"),
-  import_cleanUrl = require("../utils/cleanUrl.cjs"),
-  import_isResponse = require("../utils/isResponse.cjs"),
-  import_resolveResponse = require("../vite/resolveResponse.cjs"),
-  import_ssrLoaderData = require("./ssrLoaderData.cjs"),
-  import_staticHtmlFetcher = require("./staticHtmlFetcher.cjs");
+var import_constants = require("../constants.cjs");
+var import_createHandleRequest = require("../createHandleRequest.cjs");
+var import_cleanUrl = require("../utils/cleanUrl.cjs");
+var import_isResponse = require("../utils/isResponse.cjs");
+var import_resolveResponse = require("../vite/resolveResponse.cjs");
+var import_ssrLoaderData = require("./ssrLoaderData.cjs");
+var import_staticHtmlFetcher = require("./staticHtmlFetcher.cjs");
 function createWorkerHandler(options) {
   const {
     oneOptions
   } = options;
-  let currentLazyRoutes = options.lazyRoutes,
-    compiledManifest = (0, import_createHandleRequest.compileManifest)(options.buildInfo.manifest),
-    routeToBuildInfo = options.buildInfo.routeToBuildInfo,
-    routeMap = options.buildInfo.routeMap,
-    currentPreloads = options.buildInfo.preloads,
-    currentCssPreloads = options.buildInfo.cssPreloads;
-  const debugRouter = process.env.ONE_DEBUG_ROUTER,
-    redirects = oneOptions.web?.redirects;
+  let currentLazyRoutes = options.lazyRoutes;
+  let compiledManifest = (0, import_createHandleRequest.compileManifest)(options.buildInfo.manifest);
+  let routeToBuildInfo = options.buildInfo.routeToBuildInfo;
+  let routeMap = options.buildInfo.routeMap;
+  let currentPreloads = options.buildInfo.preloads;
+  let currentCssPreloads = options.buildInfo.cssPreloads;
+  const debugRouter = process.env.ONE_DEBUG_ROUTER;
+  const redirects = oneOptions.web?.redirects;
   let compiledRedirects = null;
-  redirects?.length && (compiledRedirects = redirects.map(r => {
-    const regexSource = r.source.replace(/:(\w+)/g, (_, name) => `(?<${name}>[^/]+)`);
-    return {
-      regex: new RegExp(`^${regexSource}$`),
-      destination: r.destination,
-      permanent: r.permanent || !1
-    };
-  }));
-  const 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();
-  let render = null,
-    renderStream = null,
-    renderLoading = null,
-    renderGeneration = 0;
+  if (redirects?.length) {
+    compiledRedirects = redirects.map(r => {
+      const regexSource = r.source.replace(/:(\w+)/g, (_, name) => `(?<${name}>[^/]+)`);
+      return {
+        regex: new RegExp(`^${regexSource}$`),
+        destination: r.destination,
+        permanent: r.permanent || false
+      };
+    });
+  }
+  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();
+  let render = null;
+  let renderStream = null;
+  let renderLoading = null;
+  let renderGeneration = 0;
   function ensureRenderLoaded() {
     if (render) return;
     if (renderLoading) return renderLoading;
     const gen = ++renderGeneration;
-    return renderLoading = (async () => {
+    renderLoading = (async () => {
       const entry = await currentLazyRoutes.serverEntry();
-      gen === renderGeneration && (render = entry.default.render, renderStream = entry.default.renderStream || null);
-    })(), renderLoading;
+      if (gen !== renderGeneration) return;
+      render = entry.default.render;
+      renderStream = entry.default.renderStream || null;
+    })();
+    return renderLoading;
   }
   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 (!parent) break;
@@ -88,20 +95,37 @@ function createWorkerHandler(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)}}}`;
   }
   async function readStaticHtml(htmlPath) {
     const fetchStaticHtml = (0, import_staticHtmlFetcher.getFetchStaticHtml)();
-    return fetchStaticHtml ? await fetchStaticHtml(htmlPath) : (debugRouter && console.warn(`[one/worker] no fetchStaticHtml set, cannot read ${htmlPath}`), null);
+    if (fetchStaticHtml) return await fetchStaticHtml(htmlPath);
+    if (debugRouter) {
+      console.warn(`[one/worker] no fetchStaticHtml set, cannot read ${htmlPath}`);
+    }
+    return null;
   }
   function resolveLoaderSync(lazyKey) {
-    const cacheKey = lazyKey || "",
-      cached = loaderCache.get(cacheKey);
-    return cached !== void 0 ? cached : (async () => {
+    const cacheKey = lazyKey || "";
+    const cached = loaderCache.get(cacheKey);
+    if (cached !== void 0) return cached;
+    return (async () => {
       let routeExported;
-      if (moduleImportCache.has(cacheKey)) routeExported = moduleImportCache.get(cacheKey);else if (lazyKey && currentLazyRoutes.pages[lazyKey]) routeExported = await currentLazyRoutes.pages[lazyKey](), moduleImportCache.set(cacheKey, routeExported);else return console.warn(`[one/worker] no lazy route for ${cacheKey}`), loaderCache.set(cacheKey, null), null;
+      if (moduleImportCache.has(cacheKey)) {
+        routeExported = moduleImportCache.get(cacheKey);
+      } else if (lazyKey && currentLazyRoutes.pages[lazyKey]) {
+        routeExported = await currentLazyRoutes.pages[lazyKey]();
+        moduleImportCache.set(cacheKey, routeExported);
+      } else {
+        console.warn(`[one/worker] no lazy route for ${cacheKey}`);
+        loaderCache.set(cacheKey, null);
+        return null;
+      }
       const loader = routeExported?.loader || null;
-      return loaderCache.set(cacheKey, loader), loaderCacheFnMap.set(cacheKey, routeExported?.loaderCache ?? null), loader;
+      loaderCache.set(cacheKey, loader);
+      loaderCacheFnMap.set(cacheKey, routeExported?.loaderCache ?? null);
+      return loader;
     })();
   }
   async function importAndRunLoader(routeId, lazyKey, loaderProps) {
@@ -109,56 +133,67 @@ function createWorkerHandler(options) {
       loaderData: void 0,
       routeId
     };
-    const cacheMapKey = lazyKey,
-      loaderCacheFn = loaderCacheFnMap.get(cacheMapKey);
-    let coalFullKey,
-      coalTtl = 0;
+    const cacheMapKey = lazyKey;
+    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(lazyKey),
-        loader = loaderOrPromise instanceof Promise ? await loaderOrPromise : loaderOrPromise;
+      const loaderOrPromise = resolveLoaderSync(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));
-        }, () => pendingLoaderResults.delete(coalFullKey)), {
-          loaderData: await promise,
+        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));
+        const loaderData2 = await promise;
+        return {
+          loaderData: loaderData2,
           routeId
         };
       }
+      const loaderData = await loader(loaderProps);
       return {
-        loaderData: await loader(loaderProps),
+        loaderData,
         routeId
       };
     } catch (err) {
       if ((0, import_isResponse.isResponse)(err)) throw err;
-      return err?.code === "ENOENT" ? {
+      if (err?.code === "ENOENT") return {
         loaderData: void 0,
         routeId,
-        isEnoent: !0
-      } : (console.error(`[one] Error running loader for ${routeId}:`, err), {
+        isEnoent: true
+      };
+      console.error(`[one] Error running loader for ${routeId}:`, err);
+      return {
         loaderData: void 0,
         routeId
-      });
+      };
     }
   }
   const requestHandlers = {
@@ -168,10 +203,18 @@ function createWorkerHandler(options) {
     async handleAPI({
       route
     }) {
-      return currentLazyRoutes.api[route.page] ? await currentLazyRoutes.api[route.page]() : (console.warn(`[one/worker] no lazy API route for ${route.page}`), null);
+      if (currentLazyRoutes.api[route.page]) {
+        return await currentLazyRoutes.api[route.page]();
+      }
+      console.warn(`[one/worker] no lazy API route for ${route.page}`);
+      return null;
     },
     async loadMiddleware(route) {
-      return currentLazyRoutes.middlewares[route.contextKey] ? await currentLazyRoutes.middlewares[route.contextKey]() : (console.warn(`[one/worker] no lazy middleware for ${route.contextKey}`), null);
+      if (currentLazyRoutes.middlewares[route.contextKey]) {
+        return await currentLazyRoutes.middlewares[route.contextKey]();
+      }
+      console.warn(`[one/worker] no lazy middleware for ${route.contextKey}`);
+      return null;
     },
     async handleLoader({
       route,
@@ -191,7 +234,9 @@ function createWorkerHandler(options) {
       try {
         json = await loader(loaderProps);
       } catch (err) {
-        if (err?.code === "ENOENT") return make404LoaderJs(loaderProps?.path || "/", `ENOENT ${err?.path || err}`);
+        if (err?.code === "ENOENT") {
+          return make404LoaderJs(loaderProps?.path || "/", `ENOENT ${err?.path || err}`);
+        }
         throw err;
       }
       if ((0, import_isResponse.isResponse)(json)) throw json;
@@ -204,50 +249,64 @@ function createWorkerHandler(options) {
     }) {
       const routeBuildInfo = routeToBuildInfo[route.file];
       if (route.type === "ssr") {
-        if (!routeBuildInfo) throw console.error("Error in route", route), new Error(`No buildinfo found for ${url}, route: ${route.file}, in keys:
-  ${Object.keys(routeToBuildInfo).join(`
-  `)}`);
+        if (!routeBuildInfo) {
+          console.error(`Error in route`, route);
+          throw new Error(`No buildinfo found for ${url}, route: ${route.file}, in keys:
+  ${Object.keys(routeToBuildInfo).join("\n  ")}`);
+        }
         try {
-          const layoutRoutes = route.layouts || [],
-            layoutLoaderPromises = [],
-            noLoaderResults = [];
+          const layoutRoutes = route.layouts || [];
+          const layoutLoaderPromises = [];
+          const noLoaderResults = [];
           for (const layout of layoutRoutes) {
             const cacheKey = layout.contextKey || "";
-            loaderCache.get(cacheKey) === null ? noLoaderResults.push({
-              loaderData: void 0,
-              routeId: layout.contextKey
-            }) : layoutLoaderPromises.push(importAndRunLoader(layout.contextKey, layout.contextKey, loaderProps));
+            const cachedLoader = loaderCache.get(cacheKey);
+            if (cachedLoader === null) {
+              noLoaderResults.push({
+                loaderData: void 0,
+                routeId: layout.contextKey
+              });
+            } else {
+              layoutLoaderPromises.push(importAndRunLoader(layout.contextKey, layout.contextKey, loaderProps));
+            }
           }
           const pageLoaderPromise = importAndRunLoader(route.file, route.file, loaderProps);
-          let layoutResults, pageResult;
+          let layoutResults;
+          let pageResult;
           try {
-            if (layoutLoaderPromises.length === 0) layoutResults = noLoaderResults, pageResult = await pageLoaderPromise;else {
+            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;
+              layoutResults = [...noLoaderResults, ...asyncLayoutResults];
+              pageResult = pr;
             }
           } catch (err) {
             if ((0, import_isResponse.isResponse)(err)) return err;
             throw err;
           }
           if (pageResult.isEnoent) {
-            const nfPath = findNearestNotFoundPath(loaderProps?.path || "/"),
-              nfHtml = routeMap[nfPath];
+            const nfPath = findNearestNotFoundPath(loaderProps?.path || "/");
+            const nfHtml = routeMap[nfPath];
             if (nfHtml) {
               const html = await readStaticHtml(nfHtml);
-              if (html) return new Response(html, {
-                headers: {
-                  "content-type": "text/html"
-                },
-                status: 404
-              });
+              if (html) {
+                return new Response(html, {
+                  headers: {
+                    "content-type": "text/html"
+                  },
+                  status: 404
+                });
+              }
             }
             return new Response("404 Not Found", {
               status: 404
             });
           }
-          const matchPathname = loaderProps?.path || "/",
-            matchParams = loaderProps?.params || {},
-            matches = new Array(layoutResults.length + 1);
+          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] = {
@@ -265,30 +324,31 @@ function createWorkerHandler(options) {
           };
           const loaderData = pageResult.loaderData;
           for (const layout of layoutRoutes) {
-            const key = layout.contextKey,
-              loaderFn = loaderCache.get(key);
+            const key = layout.contextKey;
+            const loaderFn = loaderCache.get(key);
             if (loaderFn) {
               const result = layoutResults.find(r => r.routeId === key);
-              result && (0, import_ssrLoaderData.setSSRLoaderData)(loaderFn, result.loaderData);
+              if (result) (0, import_ssrLoaderData.setSSRLoaderData)(loaderFn, result.loaderData);
             }
           }
           const pageLoaderFn = loaderCache.get(route.file);
-          pageLoaderFn && (0, import_ssrLoaderData.setSSRLoaderData)(pageLoaderFn, pageResult.loaderData), globalThis.__vxrnresetState?.();
+          if (pageLoaderFn) (0, import_ssrLoaderData.setSSRLoaderData)(pageLoaderFn, pageResult.loaderData);
+          globalThis["__vxrnresetState"]?.();
           const renderProps = {
-              mode: route.type,
-              loaderData,
-              loaderProps,
-              path: loaderProps?.path || "/",
-              preloads: routeBuildInfo.criticalPreloads || routeBuildInfo.preloads,
-              deferredPreloads: routeBuildInfo.deferredPreloads,
-              css: routeBuildInfo.css,
-              cssContents: routeBuildInfo.cssContents,
-              matches
-            },
-            _rl = ensureRenderLoaded();
-          _rl && (await _rl);
-          const status = route.isNotFound ? 404 : 200,
-            responseHeaders = route.isNotFound ? htmlHeaders : ssrHtmlHeaders;
+            mode: route.type,
+            loaderData,
+            loaderProps,
+            path: loaderProps?.path || "/",
+            preloads: routeBuildInfo.criticalPreloads || routeBuildInfo.preloads,
+            deferredPreloads: routeBuildInfo.deferredPreloads,
+            css: routeBuildInfo.css,
+            cssContents: routeBuildInfo.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, {
@@ -302,24 +362,29 @@ function createWorkerHandler(options) {
             status
           });
         } catch (err) {
-          return (0, import_isResponse.isResponse)(err) ? err : (console.error(`[one] Error rendering SSR route ${route.file}
-${err?.stack ?? err}
-url: ${url}`), null);
+          if ((0, import_isResponse.isResponse)(err)) return err;
+          console.error(`[one] Error rendering SSR route ${route.file}
+${err?.["stack"] ?? err}
+url: ${url}`);
+          return null;
         }
       } 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 => importAndRunLoader(layout.contextKey, layout.contextKey, loaderProps)))).map(result => ({
-            routeId: result.routeId,
-            pathname: loaderProps?.path || "/",
-            params: loaderProps?.params || {},
-            loaderData: result.loaderData
-          }));
-          globalThis.__vxrnresetState?.();
-          const _rl = ensureRenderLoaded();
-          _rl && (await _rl);
-          const spaRouteBuildInfo = routeToBuildInfo[route.file],
-            rendered = await render({
+        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 => importAndRunLoader(layout.contextKey, layout.contextKey, loaderProps)));
+            const matches = layoutResults.map(result => ({
+              routeId: result.routeId,
+              pathname: loaderProps?.path || "/",
+              params: loaderProps?.params || {},
+              loaderData: result.loaderData
+            }));
+            globalThis["__vxrnresetState"]?.();
+            const _rl = ensureRenderLoaded();
+            if (_rl) await _rl;
+            const spaRouteBuildInfo = routeToBuildInfo[route.file];
+            const rendered = await render({
               mode: "spa-shell",
               loaderData: void 0,
               loaderProps,
@@ -330,38 +395,41 @@ url: ${url}`), null);
               cssContents: spaRouteBuildInfo?.cssContents,
               matches
             });
-          return new Response(rendered, {
-            headers: htmlHeaders,
-            status: route.isNotFound ? 404 : 200
-          });
-        } catch (err) {
-          if ((0, import_isResponse.isResponse)(err)) return err;
-          console.error(`[one] Error rendering spa-shell for ${route.file}
-${err?.stack ?? err}
+            return new Response(rendered, {
+              headers: htmlHeaders,
+              status: route.isNotFound ? 404 : 200
+            });
+          } catch (err) {
+            if ((0, import_isResponse.isResponse)(err)) return err;
+            console.error(`[one] Error rendering spa-shell for ${route.file}
+${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[routeBuildInfo?.cleanPath];
+        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[routeBuildInfo?.cleanPath];
         if (htmlPath) {
           const html = await readStaticHtml(htmlPath);
-          if (html) return new Response(html, {
-            headers: htmlHeaders,
-            status: route.isNotFound ? 404 : 200
-          });
+          if (html) {
+            return new Response(html, {
+              headers: htmlHeaders,
+              status: route.isNotFound ? 404 : 200
+            });
+          }
         }
         if (isDynamicRoute) {
-          const notFoundRoute = findNearestNotFoundPath(url.pathname),
-            notFoundHtmlPath = routeMap[notFoundRoute];
+          const notFoundRoute = findNearestNotFoundPath(url.pathname);
+          const notFoundHtmlPath = routeMap[notFoundRoute];
           if (notFoundHtmlPath) {
             const notFoundHtml = await readStaticHtml(notFoundHtmlPath);
             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`);
+                originalPath: url.pathname,
+                notFoundPath: notFoundRoute
+              })}</script>`;
+              const injectedHtml = notFoundHtml.includes("</head>") ? notFoundHtml.replace("</head>", `${notFoundMarker}</head>`) : notFoundHtml.replace("<body", `${notFoundMarker}<body`);
               return new Response(injectedHtml, {
                 headers: htmlHeaders,
                 status: 404
@@ -377,106 +445,158 @@ url: ${url}`);
     }
   };
   function setCacheHeaders(response, route, isAPI) {
-    if (!response.headers.has("cache-control") && !response.headers.has("Cache-Control")) try {
-      isAPI ? response.headers.set("cache-control", "no-store") : 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");
-    } catch {}
+    if (!response.headers.has("cache-control") && !response.headers.has("Cache-Control")) {
+      try {
+        if (isAPI) {
+          response.headers.set("cache-control", "no-store");
+        } else 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");
+        }
+      } catch {}
+    }
     return response;
   }
   async function handleRequest(request) {
-    const url = (0, import_createHandleRequest.getURLfromRequestURL)(request),
-      pathname = url.pathname,
-      method = request.method;
-    if (compiledRedirects) for (const redirect of compiledRedirects) {
-      const match = redirect.regex.exec(pathname);
-      if (match) {
-        let destination = redirect.destination;
-        if (match.groups) for (const [name, value] of Object.entries(match.groups)) destination = destination.replace(`:${name}`, value);
-        return debugRouter && console.info(`[one] \u21AA redirect ${pathname} \u2192 ${destination}`), new Response(null, {
-          status: redirect.permanent ? 301 : 302,
+    const url = (0, import_createHandleRequest.getURLfromRequestURL)(request);
+    const pathname = url.pathname;
+    const method = request.method;
+    if (compiledRedirects) {
+      for (const redirect of compiledRedirects) {
+        const match = redirect.regex.exec(pathname);
+        if (match) {
+          let destination = redirect.destination;
+          if (match.groups) {
+            for (const [name, value] of Object.entries(match.groups)) {
+              destination = destination.replace(`:${name}`, value);
+            }
+          }
+          if (debugRouter) console.info(`[one] \u21AA redirect ${pathname} \u2192 ${destination}`);
+          return new Response(null, {
+            status: redirect.permanent ? 301 : 302,
+            headers: {
+              location: new URL(destination, url.origin).toString()
+            }
+          });
+        }
+      }
+    }
+    if (pathname.endsWith(import_constants.PRELOAD_JS_POSTFIX)) {
+      if (!currentPreloads[pathname]) {
+        return new Response("", {
           headers: {
-            location: new URL(destination, url.origin).toString()
+            "Content-Type": "text/javascript"
           }
         });
       }
+      return null;
     }
-    if (pathname.endsWith(import_constants.PRELOAD_JS_POSTFIX)) return currentPreloads[pathname] ? null : new Response("", {
-      headers: {
-        "Content-Type": "text/javascript"
-      }
-    });
-    if (pathname.endsWith(import_constants.CSS_PRELOAD_JS_POSTFIX)) return currentCssPreloads?.[pathname] ? null : new Response("export default Promise.resolve()", {
-      headers: {
-        "Content-Type": "text/javascript"
-      }
-    });
-    if (pathname.endsWith(import_constants.LOADER_JS_POSTFIX_UNCACHED)) {
-      const originalUrl = (0, import_cleanUrl.getPathFromLoaderPath)(pathname);
-      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 new Response(make404LoaderJs(originalUrl, "ssg route not in routeMap"), {
+    if (pathname.endsWith(import_constants.CSS_PRELOAD_JS_POSTFIX)) {
+      if (!currentCssPreloads?.[pathname]) {
+        return new Response("export default Promise.resolve()", {
           headers: {
             "Content-Type": "text/javascript"
           }
         });
+      }
+      return null;
+    }
+    if (pathname.endsWith(import_constants.LOADER_JS_POSTFIX_UNCACHED)) {
+      const originalUrl = (0, import_cleanUrl.getPathFromLoaderPath)(pathname);
+      for (const route of compiledManifest.pageRoutes) {
+        if (route.file === "") continue;
+        if (!route.compiledRegex.test(originalUrl)) continue;
+        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 loaderRoute = {
-            ...route,
-            routeFile: route.file,
-            file: route.loaderServerPath || pathname
-          },
-          finalUrl = new URL(originalUrl, url.origin);
+          ...route,
+          routeFile: route.file,
+          file: route.loaderServerPath || pathname
+        };
+        const finalUrl = new URL(originalUrl, url.origin);
         finalUrl.search = url.search;
         const cleanedRequest = new Request(finalUrl, request);
         try {
           return await (0, import_createHandleRequest.resolveLoaderRoute)(requestHandlers, cleanedRequest, finalUrl, loaderRoute);
         } catch (err) {
-          return err?.code === "ERR_MODULE_NOT_FOUND" ? new Response("export function loader() { return undefined }", {
-            headers: {
-              "Content-Type": "text/javascript"
-            }
-          }) : (console.error(`Error running loader: ${err}`), null);
+          if (err?.code === "ERR_MODULE_NOT_FOUND") {
+            return new Response("export function loader() { return undefined }", {
+              headers: {
+                "Content-Type": "text/javascript"
+              }
+            });
+          }
+          console.error(`Error running loader: ${err}`);
+          return null;
         }
       }
       return null;
     }
-    if (pathname.endsWith(".js") || pathname.endsWith(".css")) return null;
-    for (const route of compiledManifest.apiRoutes) if (route.compiledRegex.test(pathname)) {
-      debugRouter && console.info(`[one] \u26A1 ${pathname} \u2192 matched API route: ${route.page}`);
-      const response = await (0, import_createHandleRequest.resolveAPIRoute)(requestHandlers, request, url, route);
-      return response && (0, import_isResponse.isResponse)(response) ? setCacheHeaders(response, route, !0) : null;
+    if (pathname.endsWith(".js") || pathname.endsWith(".css")) {
+      return null;
+    }
+    for (const route of compiledManifest.apiRoutes) {
+      if (route.compiledRegex.test(pathname)) {
+        if (debugRouter) console.info(`[one] \u26A1 ${pathname} \u2192 matched API route: ${route.page}`);
+        const response = await (0, import_createHandleRequest.resolveAPIRoute)(requestHandlers, request, url, route);
+        if (response && (0, import_isResponse.isResponse)(response)) {
+          return setCacheHeaders(response, route, true);
+        }
+        return null;
+      }
     }
     if (method === "GET") {
-      for (const route of compiledManifest.pageRoutes) if (route.compiledRegex.test(pathname)) {
-        if (debugRouter && console.info(`[one] \u26A1 ${pathname} \u2192 matched page route: ${route.page} (${route.type})`), route.type === "ssr" && !route.middlewares?.length) {
-          const params = {},
-            match = route.compiledRegex.exec(pathname);
-          if (match?.groups) for (const [key, value] of Object.entries(match.groups)) params[route.routeKeys[key]] = value;
+      for (const route of compiledManifest.pageRoutes) {
+        if (!route.compiledRegex.test(pathname)) continue;
+        if (debugRouter) {
+          console.info(`[one] \u26A1 ${pathname} \u2192 matched page route: ${route.page} (${route.type})`);
+        }
+        if (route.type === "ssr" && !route.middlewares?.length) {
+          const params = {};
+          const match = route.compiledRegex.exec(pathname);
+          if (match?.groups) {
+            for (const [key, value] of Object.entries(match.groups)) {
+              params[route.routeKeys[key]] = value;
+            }
+          }
           const loaderProps = {
-              path: pathname,
-              search: url.search,
-              subdomain: (0, import_createHandleRequest.getSubdomain)(url),
-              request,
-              params
-            },
-            response = await (0, import_resolveResponse.resolveResponse)(async () => {
-              try {
-                return await requestHandlers.handlePage({
-                  request,
-                  route,
-                  url,
-                  loaderProps
-                });
-              } catch (err) {
-                if ((0, import_isResponse.isResponse)(err)) return err;
-                throw err;
-              }
-            });
-          return response && (0, import_isResponse.isResponse)(response) ? setCacheHeaders(response, route, !1) : null;
+            path: pathname,
+            search: url.search,
+            subdomain: (0, import_createHandleRequest.getSubdomain)(url),
+            request,
+            params
+          };
+          const response = await (0, import_resolveResponse.resolveResponse)(async () => {
+            try {
+              return await requestHandlers.handlePage({
+                request,
+                route,
+                url,
+                loaderProps
+              });
+            } catch (err) {
+              if ((0, import_isResponse.isResponse)(err)) return err;
+              throw err;
+            }
+          });
+          if (response && (0, import_isResponse.isResponse)(response)) {
+            return setCacheHeaders(response, route, false);
+          }
+          return null;
         }
         try {
           const response = await (0, import_createHandleRequest.resolvePageRoute)(requestHandlers, request, url, route);
-          if (response && (0, import_isResponse.isResponse)(response)) return setCacheHeaders(response, route, !1);
+          if (response && (0, import_isResponse.isResponse)(response)) {
+            return setCacheHeaders(response, route, false);
+          }
         } catch (err) {
-          console.error(` [one] Error handling request: ${err.stack}`);
+          console.error(` [one] Error handling request: ${err["stack"]}`);
         }
         return null;
       }
@@ -484,7 +604,19 @@ url: ${url}`);
     return null;
   }
   function updateRoutes(newBuildInfo, newLazyRoutes) {
-    compiledManifest = (0, import_createHandleRequest.compileManifest)(newBuildInfo.manifest), routeToBuildInfo = newBuildInfo.routeToBuildInfo, routeMap = newBuildInfo.routeMap, currentPreloads = newBuildInfo.preloads, currentCssPreloads = newBuildInfo.cssPreloads, newLazyRoutes && (currentLazyRoutes = newLazyRoutes), loaderCache.clear(), moduleImportCache.clear(), loaderCacheFnMap.clear(), pendingLoaderResults.clear(), render = null, renderStream = null, renderLoading = null;
+    compiledManifest = (0, import_createHandleRequest.compileManifest)(newBuildInfo.manifest);
+    routeToBuildInfo = newBuildInfo.routeToBuildInfo;
+    routeMap = newBuildInfo.routeMap;
+    currentPreloads = newBuildInfo.preloads;
+    currentCssPreloads = newBuildInfo.cssPreloads;
+    if (newLazyRoutes) currentLazyRoutes = newLazyRoutes;
+    loaderCache.clear();
+    moduleImportCache.clear();
+    loaderCacheFnMap.clear();
+    pendingLoaderResults.clear();
+    render = null;
+    renderStream = null;
+    renderLoading = null;
   }
   return {
     handleRequest,