one 1.25.5 → 1.25.7

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

@@ -0,0 +1,984 @@
+"use strict";
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  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;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var oneServe_exports = {};
+__export(oneServe_exports, {
+  oneServe: () => oneServe
+});
+module.exports = __toCommonJS(oneServe_exports);
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_constants = require("../constants.native.js");
+var import_createHandleRequest = require("../createHandleRequest.native.js");
+var import_cleanUrl = require("../utils/cleanUrl.native.js");
+var import_toAbsolute = require("../utils/toAbsolute.native.js");
+var import_toServerOutputPath = require("../utils/toServerOutputPath.native.js");
+var import_ssrLoaderData = require("./ssrLoaderData.native.js");
+var import_staticHtmlFetcher = require("./staticHtmlFetcher.native.js");
+function _instanceof(left, right) {
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return !!right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
+}
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var debugRouter = process.env.ONE_DEBUG_ROUTER;
+var MODULE_CACHE_MAX = 500;
+function setBounded(map, key, value, max) {
+  if (map.has(key)) {
+    map.set(key, value);
+    return;
+  }
+  if (map.size >= max) {
+    var firstKey = map.keys().next().value;
+    if (firstKey !== void 0) map.delete(firstKey);
+  }
+  map.set(key, value);
+}
+function forwardHeaders(response, context) {
+  var _response_headers_getSetCookie, _response_headers;
+  var setCookies = (_response_headers_getSetCookie = (_response_headers = response.headers).getSetCookie) === null || _response_headers_getSetCookie === void 0 ? void 0 : _response_headers_getSetCookie.call(_response_headers);
+  if (setCookies === null || setCookies === void 0 ? void 0 : setCookies.length) {
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = setCookies[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var cookie = _step.value;
+        context.header("set-cookie", cookie, {
+          append: true
+        });
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  }
+  response.headers.forEach(function (value, key) {
+    if (key === "set-cookie") return;
+    context.header(key, value);
+  });
+}
+async function readStaticHtml(htmlPath) {
+  var outDir = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "dist";
+  var 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)(`${outDir}/client`, htmlPath), "utf-8");
+  } catch (unused) {
+    return null;
+  }
+}
+async function oneServe(oneOptions, buildInfo, app, options) {
+  var _oneOptions_web, _oneOptions_build_api, _oneOptions_build;
+  var outDir = buildInfo.outDir || "dist";
+  var {
+    resolveAPIRoute,
+    resolveLoaderRoute,
+    resolvePageRoute
+  } = await import("../createHandleRequest");
+  var {
+    isResponse
+  } = await import("../utils/isResponse");
+  var {
+    isStatusRedirect
+  } = await import("../utils/isStatus");
+  var {
+    resolveResponse
+  } = await import("../vite/resolveResponse");
+  var isAPIRequest = /* @__PURE__ */new WeakMap();
+  var redirects = (_oneOptions_web = oneOptions.web) === null || _oneOptions_web === void 0 ? void 0 : _oneOptions_web.redirects;
+  if (redirects) {
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      var _loop = function () {
+        var redirect = _step.value;
+        app.get(redirect.source, function (context) {
+          var destinationUrl = redirect.destination.replace(/:\w+/g, function (param) {
+            var 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);
+        });
+      };
+      for (var _iterator = redirects[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _loop();
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  }
+  if (!buildInfo) {
+    throw new Error(`No build info found, have you run build?`);
+  }
+  var {
+    routeToBuildInfo,
+    routeMap
+  } = buildInfo;
+  function findNearestNotFoundPath(urlPath) {
+    var cur = urlPath;
+    while (cur) {
+      var parent = cur.lastIndexOf("/") > 0 ? cur.slice(0, cur.lastIndexOf("/")) : "";
+      if (routeMap[`${parent}/+not-found`]) {
+        return `${parent}/+not-found`;
+      }
+      if (!parent) break;
+      cur = parent;
+    }
+    return "/+not-found";
+  }
+  function make404LoaderJs(path, logReason) {
+    var nfPath = findNearestNotFoundPath(path);
+    if (logReason) {
+      console.error(`[one] 404 loader for ${path}: ${logReason}`);
+    }
+    return `export function loader(){return{__oneError:404,__oneErrorMessage:'Not Found',__oneNotFoundPath:${JSON.stringify(nfPath)}}}`;
+  }
+  var serverOptions = {
+    ...oneOptions,
+    root: "."
+  };
+  var apiCJS = ((_oneOptions_build = oneOptions.build) === null || _oneOptions_build === void 0 ? void 0 : (_oneOptions_build_api = _oneOptions_build.api) === null || _oneOptions_build_api === void 0 ? void 0 : _oneOptions_build_api.outputFormat) === "cjs";
+  var useStreaming = !process.env.ONE_BUFFERED_SSR;
+  var htmlHeaders = {
+    "content-type": "text/html"
+  };
+  var ssrHtmlHeaders = {
+    "content-type": "text/html",
+    "cache-control": "no-cache"
+  };
+  var loaderCache = /* @__PURE__ */new Map();
+  var moduleImportCache = /* @__PURE__ */new Map();
+  var loaderCacheFnMap = /* @__PURE__ */new Map();
+  var pendingLoaderResults = /* @__PURE__ */new Map();
+  function resolveLoaderSync(serverPath, lazyKey) {
+    var cacheKey = lazyKey || serverPath || "";
+    var cached = loaderCache.get(cacheKey);
+    if (cached !== void 0) return cached;
+    return async function () {
+      var _ref;
+      var pathToResolve = serverPath || lazyKey || "";
+      var resolvedPath = (0, import_toServerOutputPath.toServerOutputPath)(pathToResolve, outDir);
+      var routeExported;
+      if (moduleImportCache.has(cacheKey)) {
+        routeExported = moduleImportCache.get(cacheKey);
+      } else {
+        var _options_lazyRoutes_pages, _options_lazyRoutes;
+        routeExported = lazyKey ? (options === null || options === void 0 ? void 0 : (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0 ? void 0 : (_options_lazyRoutes_pages = _options_lazyRoutes.pages) === null || _options_lazyRoutes_pages === void 0 ? void 0 : _options_lazyRoutes_pages[lazyKey]) ? await options.lazyRoutes.pages[lazyKey]() : await import((0, import_toAbsolute.toAbsoluteUrl)(resolvedPath)) : await import((0, import_toAbsolute.toAbsoluteUrl)(serverPath));
+        setBounded(moduleImportCache, cacheKey, routeExported, MODULE_CACHE_MAX);
+      }
+      var loader = (routeExported === null || routeExported === void 0 ? void 0 : routeExported.loader) || null;
+      setBounded(loaderCache, cacheKey, loader, MODULE_CACHE_MAX);
+      var loaderCacheFn = (_ref = routeExported === null || routeExported === void 0 ? void 0 : routeExported.loaderCache) !== null && _ref !== void 0 ? _ref : null;
+      setBounded(loaderCacheFnMap, cacheKey, loaderCacheFn, MODULE_CACHE_MAX);
+      return loader;
+    }();
+  }
+  async function importAndRunLoader(routeId, serverPath, lazyKey, loaderProps) {
+    if (!serverPath && !lazyKey) {
+      return {
+        loaderData: void 0,
+        routeId
+      };
+    }
+    var cacheMapKey = lazyKey || serverPath || "";
+    var loaderCacheFn = loaderCacheFnMap.get(cacheMapKey);
+    var coalFullKey;
+    var coalTtl = 0;
+    if (loaderCacheFn) {
+      var _ref;
+      var cacheResult = loaderCacheFn(loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.params, loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.request);
+      var cacheKey = typeof cacheResult === "string" ? cacheResult : cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.key;
+      coalTtl = typeof cacheResult === "string" ? 0 : (_ref = cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.ttl) !== null && _ref !== void 0 ? _ref : 0;
+      if (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 loaderOrPromise = resolveLoaderSync(serverPath, lazyKey);
+      var loader = _instanceof(loaderOrPromise, Promise) ? await loaderOrPromise : loaderOrPromise;
+      if (!loader) {
+        return {
+          loaderData: void 0,
+          routeId
+        };
+      }
+      if (coalFullKey) {
+        var promise = loader(loaderProps);
+        var entry = {
+          promise,
+          expires: 0
+        };
+        pendingLoaderResults.set(coalFullKey, entry);
+        promise.then(function () {
+          entry.expires = coalTtl > 0 ? Date.now() + coalTtl : 0;
+          if (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: loaderData2,
+        routeId
+      };
+    } catch (err) {
+      if (isResponse(err)) {
+        throw err;
+      }
+      if ((err === null || err === void 0 ? void 0 : err.code) === "ENOENT") {
+        return {
+          loaderData: void 0,
+          routeId,
+          isEnoent: true
+        };
+      }
+      console.error(`[one] Error running loader for ${routeId}:`, err);
+      return {
+        loaderData: void 0,
+        routeId
+      };
+    }
+  }
+  var render = null;
+  var renderStream = null;
+  var renderLoading = null;
+  function ensureRenderLoaded() {
+    if (render) return;
+    if (renderLoading) return renderLoading;
+    renderLoading = async function () {
+      var _options_lazyRoutes, _oneOptions_build2;
+      var entry = (options === null || options === void 0 ? void 0 : (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0 ? void 0 : _options_lazyRoutes.serverEntry) ? await options.lazyRoutes.serverEntry() : await import((0, import_toAbsolute.toAbsoluteUrl)(`${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;
+    }();
+    return renderLoading;
+  }
+  var clientDir = (0, import_path.join)(process.cwd(), outDir, "client");
+  var requestHandlers = {
+    async handleStaticFile(filePath) {
+      try {
+        var fullPath = (0, import_path.join)(clientDir, filePath);
+        var content = await (0, import_promises.readFile)(fullPath, "utf-8");
+        return new Response(content, {
+          headers: {
+            "Content-Type": "text/javascript"
+          }
+        });
+      } catch (unused) {
+        return null;
+      }
+    },
+    async handleAPI(param) {
+      var {
+        route: route2
+      } = param;
+      var _options_lazyRoutes_api, _options_lazyRoutes;
+      if (options === null || options === void 0 ? void 0 : (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0 ? void 0 : (_options_lazyRoutes_api = _options_lazyRoutes.api) === null || _options_lazyRoutes_api === void 0 ? void 0 : _options_lazyRoutes_api[route2.page]) {
+        return await options.lazyRoutes.api[route2.page]();
+      }
+      var fileName = route2.page.slice(1).replace(/\[/g, "_").replace(/\]/g, "_");
+      var apiFile = import_path.posix.join(outDir, "api", fileName + (apiCJS ? ".cjs" : ".js"));
+      return await import((0, import_toAbsolute.toAbsoluteUrl)(apiFile));
+    },
+    async loadMiddleware(route2) {
+      var _options_lazyRoutes_middlewares, _options_lazyRoutes;
+      if (options === null || options === void 0 ? void 0 : (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0 ? void 0 : (_options_lazyRoutes_middlewares = _options_lazyRoutes.middlewares) === null || _options_lazyRoutes_middlewares === void 0 ? void 0 : _options_lazyRoutes_middlewares[route2.contextKey]) {
+        return await options.lazyRoutes.middlewares[route2.contextKey]();
+      }
+      return await import((0, import_toAbsolute.toAbsoluteUrl)(route2.contextKey));
+    },
+    async handleLoader(param) {
+      var {
+        route: route2,
+        loaderProps
+      } = param;
+      var routeFile = route2.routeFile || route2.file;
+      var serverPath = (0, import_toServerOutputPath.toServerOutputPath)(route2.file, outDir);
+      var loader;
+      try {
+        var loaderResult = resolveLoaderSync(serverPath, routeFile);
+        loader = _instanceof(loaderResult, Promise) ? await loaderResult : loaderResult;
+      } catch (err) {
+        if ((err === null || err === void 0 ? void 0 : 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 === null || err === void 0 ? void 0 : err.code) === "ENOENT") {
+          return make404LoaderJs((loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/", `ENOENT ${(err === null || err === void 0 ? void 0 : 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;
+      var _$buildInfo = routeToBuildInfo[route2.file];
+      if (route2.type === "ssr") {
+        if (!_$buildInfo) {
+          console.error(`Error in route`, route2);
+          throw new Error(`No buildinfo found for ${url}, route: ${route2.file}, in keys:
+  ${Object.keys(routeToBuildInfo).join("\n  ")}`);
+        }
+        try {
+          var _globalThis___vxrnresetState, _globalThis;
+          var layoutRoutes = route2.layouts || [];
+          var layoutLoaderPromises = [];
+          var noLoaderResults = [];
+          var _iteratorNormalCompletion3 = true,
+            _didIteratorError3 = false,
+            _iteratorError3 = void 0;
+          try {
+            for (var _iterator3 = layoutRoutes[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+              var layout = _step3.value;
+              var serverPath = layout.loaderServerPath || layout.contextKey;
+              var cacheKey = layout.contextKey || serverPath || "";
+              var cachedLoader = loaderCache.get(cacheKey);
+              if (cachedLoader === null) {
+                noLoaderResults.push({
+                  loaderData: void 0,
+                  routeId: layout.contextKey
+                });
+              } else {
+                layoutLoaderPromises.push(importAndRunLoader(layout.contextKey, serverPath, layout.contextKey, loaderProps));
+              }
+            }
+          } catch (err) {
+            _didIteratorError3 = true;
+            _iteratorError3 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                _iterator3.return();
+              }
+            } finally {
+              if (_didIteratorError3) {
+                throw _iteratorError3;
+              }
+            }
+          }
+          var pageLoaderPromise = importAndRunLoader(route2.file, _$buildInfo.serverJsPath, route2.file, loaderProps);
+          var layoutResults;
+          var pageResult;
+          try {
+            if (layoutLoaderPromises.length === 0) {
+              layoutResults = noLoaderResults;
+              pageResult = await pageLoaderPromise;
+            } else {
+              var [asyncLayoutResults, pr] = await Promise.all([Promise.all(layoutLoaderPromises), pageLoaderPromise]);
+              layoutResults = [...noLoaderResults, ...asyncLayoutResults];
+              pageResult = pr;
+            }
+          } catch (err) {
+            if (isResponse(err)) {
+              return err;
+            }
+            throw err;
+          }
+          if (pageResult.isEnoent) {
+            var nfPath = findNearestNotFoundPath((loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/");
+            var 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 (unused) {}
+            }
+            return new Response("404 Not Found", {
+              status: 404
+            });
+          }
+          var matchPathname = (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/";
+          var matchParams = (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.params) || {};
+          var matches = new Array(layoutResults.length + 1);
+          for (var i = 0; i < layoutResults.length; i++) {
+            var result = layoutResults[i];
+            matches[i] = {
+              routeId: result.routeId,
+              pathname: matchPathname,
+              params: matchParams,
+              loaderData: result.loaderData
+            };
+          }
+          matches[layoutResults.length] = {
+            routeId: pageResult.routeId,
+            pathname: matchPathname,
+            params: matchParams,
+            loaderData: pageResult.loaderData
+          };
+          var loaderData = pageResult.loaderData;
+          var _iteratorNormalCompletion12 = true,
+            _didIteratorError12 = false,
+            _iteratorError12 = void 0;
+          try {
+            var _loop2 = function () {
+              var layout2 = _step12.value;
+              var key = layout2.contextKey;
+              var loaderFn = loaderCache.get(key);
+              if (loaderFn) {
+                var result2 = layoutResults.find(function (r) {
+                  return r.routeId === key;
+                });
+                if (result2) {
+                  (0, import_ssrLoaderData.setSSRLoaderData)(loaderFn, result2.loaderData);
+                }
+              }
+            };
+            for (var _iterator12 = layoutRoutes[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) _loop2();
+          } catch (err) {
+            _didIteratorError12 = true;
+            _iteratorError12 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+                _iterator12.return();
+              }
+            } finally {
+              if (_didIteratorError12) {
+                throw _iteratorError12;
+              }
+            }
+          }
+          var pageLoaderFn = loaderCache.get(route2.file);
+          if (pageLoaderFn) {
+            (0, import_ssrLoaderData.setSSRLoaderData)(pageLoaderFn, pageResult.loaderData);
+          }
+          (_globalThis___vxrnresetState = (_globalThis = globalThis)["__vxrnresetState"]) === null || _globalThis___vxrnresetState === void 0 ? void 0 : _globalThis___vxrnresetState.call(_globalThis);
+          var renderProps = {
+            mode: route2.type,
+            loaderData,
+            loaderProps,
+            path: (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/",
+            preloads: _$buildInfo.criticalPreloads || _$buildInfo.preloads,
+            deferredPreloads: _$buildInfo.deferredPreloads,
+            css: _$buildInfo.css,
+            cssContents: _$buildInfo.cssContents,
+            matches
+          };
+          var _rl = ensureRenderLoaded();
+          if (_rl) await _rl;
+          var status = route2.isNotFound ? 404 : 200;
+          var responseHeaders = route2.isNotFound ? htmlHeaders : ssrHtmlHeaders;
+          if (useStreaming) {
+            var stream = await renderStream(renderProps);
+            return new Response(stream, {
+              headers: responseHeaders,
+              status
+            });
+          }
+          var rendered = await render(renderProps);
+          return new Response(rendered, {
+            headers: responseHeaders,
+            status
+          });
+        } catch (err) {
+          var _ref;
+          if (isResponse(err)) {
+            return err;
+          }
+          console.error(`[one] Error rendering SSR route ${route2.file}
+
+${(_ref = err === null || err === void 0 ? void 0 : err["stack"]) !== null && _ref !== void 0 ? _ref : err}
+
+url: ${url}`);
+        }
+      } else {
+        var layoutRoutes1 = route2.layouts || [];
+        var needsSpaShell = route2.type === "spa" && layoutRoutes1.some(function (layout2) {
+          return layout2.layoutRenderMode === "ssg" || layout2.layoutRenderMode === "ssr";
+        });
+        if (needsSpaShell) {
+          try {
+            var _globalThis___vxrnresetState1, _globalThis1;
+            var layoutResults1 = await Promise.all(layoutRoutes1.map(function (layout2) {
+              var serverPath2 = layout2.loaderServerPath || layout2.contextKey;
+              return importAndRunLoader(layout2.contextKey, serverPath2, layout2.contextKey, loaderProps);
+            }));
+            var matches1 = layoutResults1.map(function (result2) {
+              return {
+                routeId: result2.routeId,
+                pathname: (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/",
+                params: (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.params) || {},
+                loaderData: result2.loaderData
+              };
+            });
+            (_globalThis___vxrnresetState1 = (_globalThis1 = globalThis)["__vxrnresetState"]) === null || _globalThis___vxrnresetState1 === void 0 ? void 0 : _globalThis___vxrnresetState1.call(_globalThis1);
+            var _rl3 = ensureRenderLoaded();
+            if (_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 === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/",
+              preloads: (_$buildInfo === null || _$buildInfo === void 0 ? void 0 : _$buildInfo.criticalPreloads) || (_$buildInfo === null || _$buildInfo === void 0 ? void 0 : _$buildInfo.preloads),
+              deferredPreloads: _$buildInfo === null || _$buildInfo === void 0 ? void 0 : _$buildInfo.deferredPreloads,
+              css: _$buildInfo === null || _$buildInfo === void 0 ? void 0 : _$buildInfo.css,
+              cssContents: _$buildInfo === null || _$buildInfo === void 0 ? void 0 : _$buildInfo.cssContents,
+              matches: matches1
+            });
+            return new Response(rendered1, {
+              headers: htmlHeaders,
+              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 === null || err === void 0 ? void 0 : err["stack"]) !== null && _ref1 !== void 0 ? _ref1 : err}
+url: ${url}`);
+          }
+        }
+        var isDynamicRoute = Object.keys(route2.routeKeys).length > 0;
+        var routeCleanPath = route2.urlCleanPath.replace(/\?/g, "");
+        var notFoundKey = route2.isNotFound ? route2.page.replace(/\[([^\]]+)\]/g, ":$1") : null;
+        var htmlPath = notFoundKey ? routeMap[notFoundKey] : isDynamicRoute ? routeMap[routeCleanPath] || routeMap[url.pathname] : routeMap[url.pathname] || routeMap[_$buildInfo === null || _$buildInfo === void 0 ? void 0 : _$buildInfo.cleanPath];
+        if (htmlPath) {
+          var html1 = await readStaticHtml(htmlPath, outDir);
+          if (html1) {
+            var headers = new Headers();
+            headers.set("content-type", "text/html");
+            return new Response(html1, {
+              headers,
+              status: route2.isNotFound ? 404 : 200
+            });
+          }
+        }
+        if (isDynamicRoute) {
+          var notFoundRoute = findNearestNotFoundPath(url.pathname);
+          var notFoundHtmlPath = routeMap[notFoundRoute];
+          if (notFoundHtmlPath) {
+            var notFoundHtml = await readStaticHtml(notFoundHtmlPath, outDir);
+            if (notFoundHtml) {
+              var notFoundMarker = `<script>window.__one404=${JSON.stringify({
+                originalPath: url.pathname,
+                notFoundPath: notFoundRoute
+              })}</script>`;
+              var injectedHtml = notFoundHtml.includes("</head>") ? notFoundHtml.replace("</head>", `${notFoundMarker}</head>`) : notFoundHtml.replace("<body", `${notFoundMarker}<body`);
+              var headers1 = new Headers();
+              headers1.set("content-type", "text/html");
+              return new Response(injectedHtml, {
+                headers: headers1,
+                status: 404
+              });
+            }
+          }
+          return new Response("404 Not Found", {
+            status: 404
+          });
+        }
+      }
+    }
+  };
+  function createHonoHandler(route2) {
+    var isDynamicOrNotFound = route2.page.endsWith("/+not-found") || Object.keys(route2.routeKeys).length > 0;
+    return async function (context, next) {
+      try {
+        var _route_middlewares;
+        var request = context.req.raw;
+        if (isDynamicOrNotFound) {
+          if (options === null || options === void 0 ? void 0 : options.serveStaticAssets) {
+            var staticAssetResponse = await options.serveStaticAssets({
+              context
+            });
+            if (staticAssetResponse) {
+              return await (0, import_createHandleRequest.runMiddlewares)(requestHandlers, request, route2, async function () {
+                return staticAssetResponse;
+              });
+            }
+          }
+        }
+        var reqPath = context.req.path;
+        if (reqPath.endsWith(".js") || reqPath.endsWith(".css")) {
+          return next();
+        }
+        if (route2.type === "ssr" && !((_route_middlewares = route2.middlewares) === null || _route_middlewares === void 0 ? void 0 : _route_middlewares.length) && !reqPath.endsWith(import_constants.LOADER_JS_POSTFIX_UNCACHED)) {
+          if (debugRouter) {
+            console.info(`[one] \u26A1 ${reqPath} \u2192 matched page route: ${route2.page} (ssr)`);
+          }
+          var pathname = reqPath;
+          var rawUrl = request.url;
+          var qIdx = rawUrl.indexOf("?");
+          var search = qIdx >= 0 ? rawUrl.slice(qIdx) : "";
+          var params = {};
+          var match = route2.compiledRegex.exec(pathname);
+          if (match === null || match === void 0 ? void 0 : match.groups) {
+            var _iteratorNormalCompletion3 = true,
+              _didIteratorError3 = false,
+              _iteratorError3 = void 0;
+            try {
+              for (var _iterator3 = Object.entries(match.groups)[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+                var [key, value] = _step3.value;
+                var namedKey = route2.routeKeys[key];
+                params[namedKey] = value;
+              }
+            } catch (err) {
+              _didIteratorError3 = true;
+              _iteratorError3 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                  _iterator3.return();
+                }
+              } finally {
+                if (_didIteratorError3) {
+                  throw _iteratorError3;
+                }
+              }
+            }
+          }
+          var loaderProps = {
+            path: pathname,
+            search,
+            subdomain: (0, import_createHandleRequest.getSubdomain)((0, import_createHandleRequest.getURLfromRequestURL)(request)),
+            request,
+            params
+          };
+          var url = (0, import_createHandleRequest.getURLfromRequestURL)(request);
+          var response = await resolveResponse(async function () {
+            try {
+              return await requestHandlers.handlePage({
+                request,
+                route: route2,
+                url,
+                loaderProps
+              });
+            } catch (err) {
+              if (isResponse(err)) {
+                return err;
+              }
+              throw err;
+            }
+          });
+          if (response) {
+            if (isResponse(response)) {
+              if (isStatusRedirect(response.status)) {
+                var location = `${response.headers.get("location") || ""}`;
+                forwardHeaders(response, context);
+                return context.redirect(location, response.status);
+              }
+              return response;
+            }
+            return next();
+          }
+          return next();
+        }
+        var url1 = (0, import_createHandleRequest.getURLfromRequestURL)(request);
+        var response1 = await function () {
+          if (url1.pathname.endsWith(import_constants.LOADER_JS_POSTFIX_UNCACHED)) {
+            var originalUrl = (0, import_cleanUrl.getPathFromLoaderPath)(url1.pathname);
+            if (route2.type === "ssg" && Object.keys(route2.routeKeys).length > 0) {
+              if (!routeMap[originalUrl]) {
+                return new Response(make404LoaderJs(originalUrl, "ssg route not in routeMap"), {
+                  headers: {
+                    "Content-Type": "text/javascript"
+                  }
+                });
+              }
+            }
+            var finalUrl = new URL(originalUrl, url1.origin);
+            finalUrl.search = url1.search;
+            var cleanedRequest = new Request(finalUrl, request);
+            return resolveLoaderRoute(requestHandlers, cleanedRequest, finalUrl, route2);
+          }
+          switch (route2.type) {
+            case "api":
+              {
+                if (debugRouter) {
+                  console.info(`[one] \u26A1 ${url1.pathname} \u2192 matched API route: ${route2.page}`);
+                }
+                return resolveAPIRoute(requestHandlers, request, url1, route2);
+              }
+            case "ssg":
+            case "spa":
+            case "ssr":
+              {
+                if (debugRouter) {
+                  console.info(`[one] \u26A1 ${url1.pathname} \u2192 matched page route: ${route2.page} (${route2.type})`);
+                }
+                return resolvePageRoute(requestHandlers, request, url1, route2);
+              }
+          }
+        }();
+        if (response1) {
+          if (isResponse(response1)) {
+            if (isStatusRedirect(response1.status)) {
+              var location1 = `${response1.headers.get("location") || ""}`;
+              forwardHeaders(response1, context);
+              return context.redirect(location1, response1.status);
+            }
+            if (isAPIRequest.get(request)) {
+              try {
+                if (!response1.headers.has("cache-control") && !response1.headers.has("Cache-Control")) {
+                  response1.headers.set("cache-control", "no-store");
+                }
+                return response1;
+              } catch (err) {
+                console.info(`Error updating cache header on api route "${context.req.path}" to no-store, it is ${response1.headers.get("cache-control")}, continue`, err);
+              }
+            }
+            if (!response1.headers.has("cache-control") && !response1.headers.has("Cache-Control")) {
+              if (route2.type === "ssg" || route2.type === "spa") {
+                response1.headers.set("cache-control", "public, s-maxage=60, stale-while-revalidate=120");
+              } else {
+                response1.headers.set("cache-control", "no-cache");
+              }
+            }
+            return response1;
+          }
+          return next();
+        }
+      } catch (err) {
+        console.error(` [one] Error handling request: ${err["stack"]}`);
+      }
+      return next();
+    };
+  }
+  var compiledManifest = (0, import_createHandleRequest.compileManifest)(buildInfo.manifest);
+  var _iteratorNormalCompletion1 = true,
+    _didIteratorError1 = false,
+    _iteratorError1 = void 0;
+  try {
+    for (var _iterator1 = compiledManifest.apiRoutes[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+      var route = _step1.value;
+      app.get(route.urlPath, createHonoHandler(route));
+      app.on("HEAD", 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));
+      app.options(route.urlPath, createHonoHandler(route));
+      if (route.urlPath !== route.urlCleanPath) {
+        app.get(route.urlCleanPath, createHonoHandler(route));
+        app.on("HEAD", 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));
+        app.options(route.urlCleanPath, createHonoHandler(route));
+      }
+    }
+  } catch (err) {
+    _didIteratorError1 = true;
+    _iteratorError1 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+        _iterator1.return();
+      }
+    } finally {
+      if (_didIteratorError1) {
+        throw _iteratorError1;
+      }
+    }
+  }
+  var _iteratorNormalCompletion2 = true,
+    _didIteratorError2 = false,
+    _iteratorError2 = void 0;
+  try {
+    for (var _iterator2 = compiledManifest.pageRoutes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+      var route1 = _step2.value;
+      app.get(route1.urlPath, createHonoHandler(route1));
+      if (route1.urlPath !== route1.urlCleanPath) {
+        app.get(route1.urlCleanPath, createHonoHandler(route1));
+      }
+    }
+  } catch (err) {
+    _didIteratorError2 = true;
+    _iteratorError2 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+        _iterator2.return();
+      }
+    } finally {
+      if (_didIteratorError2) {
+        throw _iteratorError2;
+      }
+    }
+  }
+  var {
+    preloads,
+    cssPreloads
+  } = buildInfo;
+  app.get("*", async function (c, next) {
+    if (import_constants.PRELOAD_JS_POSTFIX_REGEX.test(c.req.path)) {
+      if (!preloads[c.req.path]) {
+        c.header("Content-Type", "text/javascript");
+        c.status(200);
+        return c.body(``);
+      }
+    }
+    if (import_constants.CSS_PRELOAD_JS_POSTFIX_REGEX.test(c.req.path)) {
+      if (!(cssPreloads === null || cssPreloads === void 0 ? void 0 : 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(import_constants.LOADER_JS_POSTFIX_UNCACHED)) {
+      var request = c.req.raw;
+      var url = (0, import_createHandleRequest.getURLfromRequestURL)(request);
+      var originalUrl = (0, import_cleanUrl.getPathFromLoaderPath)(c.req.path);
+      var _iteratorNormalCompletion3 = true,
+        _didIteratorError3 = false,
+        _iteratorError3 = void 0;
+      try {
+        for (var _iterator3 = compiledManifest.pageRoutes[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+          var route2 = _step3.value;
+          if (route2.file === "") {
+            continue;
+          }
+          if (!route2.compiledRegex.test(originalUrl)) {
+            continue;
+          }
+          if (route2.type === "ssg" && Object.keys(route2.routeKeys).length > 0 && !routeMap[originalUrl]) {
+            c.header("Content-Type", "text/javascript");
+            c.status(200);
+            return c.body(make404LoaderJs(originalUrl, "ssg route not in routeMap"));
+          }
+          var loaderRoute = {
+            ...route2,
+            routeFile: route2.file,
+            // preserve original for lazy route lookup
+            file: route2.loaderServerPath || c.req.path
+          };
+          var 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;
+          } catch (err) {
+            if ((err === null || err === void 0 ? void 0 : 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();
+          }
+        }
+      } catch (err) {
+        _didIteratorError3 = true;
+        _iteratorError3 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+            _iterator3.return();
+          }
+        } finally {
+          if (_didIteratorError3) {
+            throw _iteratorError3;
+          }
+        }
+      }
+    }
+    return next();
+  });
+}
+//# sourceMappingURL=oneServe.native.js.map