convex-cms 0.0.6 → 0.0.7

package/admin-dist/server/_chunks/_libs/@tanstack/router-core.mjs

@@ -1,39 +1,9 @@
-import { s as splitSetCookieString } from "../../../_libs/cookie-es.mjs";
 import { b as batch, S as Store } from "./store.mjs";
-import { c as createBrowserHistory, p as parseHref } from "./history.mjs";
+import { p as parseHref } from "./history.mjs";
 import { i as invariant } from "../../../_libs/tiny-invariant.mjs";
-import { n as ni, t as te, c as cn, m as mn } from "../../../_libs/seroval.mjs";
-import { p } from "../../../_libs/seroval-plugins.mjs";
 import { ReadableStream as ReadableStream$1 } from "node:stream/web";
 import { Readable } from "node:stream";
-function toHeadersInstance(init) {
-  if (init instanceof Headers) {
-    return new Headers(init);
-  } else if (Array.isArray(init)) {
-    return new Headers(init);
-  } else if (typeof init === "object") {
-    return new Headers(init);
-  } else {
-    return new Headers();
-  }
-}
-function mergeHeaders(...headers) {
-  return headers.reduce((acc, header) => {
-    const headersInstance = toHeadersInstance(header);
-    for (const [key, value] of headersInstance.entries()) {
-      if (key === "set-cookie") {
-        const splitCookies = splitSetCookieString(value);
-        splitCookies.forEach((cookie) => acc.append("set-cookie", cookie));
-      } else {
-        acc.set(key, value);
-      }
-    }
-    return acc;
-  }, new Headers());
-}
-function isNotFound(obj) {
-  return !!obj?.isNotFound;
-}
+const isServer = true;
 function last(arr) {
   return arr[arr.length - 1];
 }
@@ -66,20 +36,20 @@ function replaceEqualDeep(prev, _next, _depth = 0) {
   let equalItems = 0;
   for (let i = 0; i < nextSize; i++) {
     const key = array ? i : nextItems[i];
-    const p2 = prev[key];
+    const p = prev[key];
     const n = next[key];
-    if (p2 === n) {
-      copy[key] = p2;
+    if (p === n) {
+      copy[key] = p;
       if (array ? i < prevSize : hasOwn.call(prev, key)) equalItems++;
       continue;
     }
-    if (p2 === null || n === null || typeof p2 !== "object" || typeof n !== "object") {
+    if (p === null || n === null || typeof p !== "object" || typeof n !== "object") {
       copy[key] = n;
       continue;
     }
-    const v = replaceEqualDeep(p2, n, _depth + 1);
+    const v = replaceEqualDeep(p, n, _depth + 1);
     copy[key] = v;
-    if (v === p2) equalItems++;
+    if (v === p) equalItems++;
   }
   return prevSize === nextSize && equalItems === prevSize ? prev : copy;
 }
@@ -247,6 +217,10 @@ function decodePath(path, decodeIgnore) {
   }
   return result;
 }
+function encodeNonAscii(path) {
+  if (!/[^\u0000-\u007F]/.test(path)) return path;
+  return path.replace(/[^\u0000-\u007F]/gu, encodeURIComponent);
+}
 function createLRUCache(max) {
   const cache = /* @__PURE__ */ new Map();
   let oldest;
@@ -316,9 +290,15 @@ const SEGMENT_TYPE_WILDCARD = 2;
 const SEGMENT_TYPE_OPTIONAL_PARAM = 3;
 const SEGMENT_TYPE_INDEX = 4;
 const SEGMENT_TYPE_PATHLESS = 5;
-const PARAM_W_CURLY_BRACES_RE = /^([^{]*)\{\$([a-zA-Z_$][a-zA-Z0-9_$]*)\}([^}]*)$/;
-const OPTIONAL_PARAM_W_CURLY_BRACES_RE = /^([^{]*)\{-\$([a-zA-Z_$][a-zA-Z0-9_$]*)\}([^}]*)$/;
-const WILDCARD_W_CURLY_BRACES_RE = /^([^{]*)\{\$\}([^}]*)$/;
+function getOpenAndCloseBraces(part) {
+  const openBrace = part.indexOf("{");
+  if (openBrace === -1) return null;
+  const closeBrace = part.indexOf("}", openBrace);
+  if (closeBrace === -1) return null;
+  const afterOpen = openBrace + 1;
+  if (afterOpen >= part.length) return null;
+  return [openBrace, closeBrace];
+}
 function parseSegment(path, start, output = new Uint16Array(6)) {
   const next = path.indexOf("/", start);
   const end = next === -1 ? path.length : next;
@@ -351,45 +331,44 @@ function parseSegment(path, start, output = new Uint16Array(6)) {
     output[5] = end;
     return output;
   }
-  const wildcardBracesMatch = part.match(WILDCARD_W_CURLY_BRACES_RE);
-  if (wildcardBracesMatch) {
-    const prefix = wildcardBracesMatch[1];
-    const pLength = prefix.length;
-    output[0] = SEGMENT_TYPE_WILDCARD;
-    output[1] = start + pLength;
-    output[2] = start + pLength + 1;
-    output[3] = start + pLength + 2;
-    output[4] = start + pLength + 3;
-    output[5] = path.length;
-    return output;
-  }
-  const optionalParamBracesMatch = part.match(OPTIONAL_PARAM_W_CURLY_BRACES_RE);
-  if (optionalParamBracesMatch) {
-    const prefix = optionalParamBracesMatch[1];
-    const paramName = optionalParamBracesMatch[2];
-    const suffix = optionalParamBracesMatch[3];
-    const pLength = prefix.length;
-    output[0] = SEGMENT_TYPE_OPTIONAL_PARAM;
-    output[1] = start + pLength;
-    output[2] = start + pLength + 3;
-    output[3] = start + pLength + 3 + paramName.length;
-    output[4] = end - suffix.length;
-    output[5] = end;
-    return output;
-  }
-  const paramBracesMatch = part.match(PARAM_W_CURLY_BRACES_RE);
-  if (paramBracesMatch) {
-    const prefix = paramBracesMatch[1];
-    const paramName = paramBracesMatch[2];
-    const suffix = paramBracesMatch[3];
-    const pLength = prefix.length;
-    output[0] = SEGMENT_TYPE_PARAM;
-    output[1] = start + pLength;
-    output[2] = start + pLength + 2;
-    output[3] = start + pLength + 2 + paramName.length;
-    output[4] = end - suffix.length;
-    output[5] = end;
-    return output;
+  const braces = getOpenAndCloseBraces(part);
+  if (braces) {
+    const [openBrace, closeBrace] = braces;
+    const firstChar = part.charCodeAt(openBrace + 1);
+    if (firstChar === 45) {
+      if (openBrace + 2 < part.length && part.charCodeAt(openBrace + 2) === 36) {
+        const paramStart = openBrace + 3;
+        const paramEnd = closeBrace;
+        if (paramStart < paramEnd) {
+          output[0] = SEGMENT_TYPE_OPTIONAL_PARAM;
+          output[1] = start + openBrace;
+          output[2] = start + paramStart;
+          output[3] = start + paramEnd;
+          output[4] = start + closeBrace + 1;
+          output[5] = end;
+          return output;
+        }
+      }
+    } else if (firstChar === 36) {
+      const dollarPos = openBrace + 1;
+      const afterDollar = openBrace + 2;
+      if (afterDollar === closeBrace) {
+        output[0] = SEGMENT_TYPE_WILDCARD;
+        output[1] = start + openBrace;
+        output[2] = start + dollarPos;
+        output[3] = start + afterDollar;
+        output[4] = start + closeBrace + 1;
+        output[5] = path.length;
+        return output;
+      }
+      output[0] = SEGMENT_TYPE_PARAM;
+      output[1] = start + openBrace;
+      output[2] = start + afterDollar;
+      output[3] = start + closeBrace;
+      output[4] = start + closeBrace + 1;
+      output[5] = end;
+      return output;
+    }
   }
   output[0] = SEGMENT_TYPE_PATHNAME;
   output[1] = start;
@@ -1230,19 +1209,27 @@ function resolvePath({
   if (key && cache) cache.set(key, result);
   return result;
 }
-function encodeParam(key, params, decodeCharMap) {
+function compileDecodeCharMap(pathParamsAllowedCharacters) {
+  const charMap = new Map(
+    pathParamsAllowedCharacters.map((char) => [encodeURIComponent(char), char])
+  );
+  const pattern = Array.from(charMap.keys()).map((key) => key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  const regex = new RegExp(pattern, "g");
+  return (encoded) => encoded.replace(regex, (match) => charMap.get(match) ?? match);
+}
+function encodeParam(key, params, decoder) {
   const value = params[key];
   if (typeof value !== "string") return value;
   if (key === "_splat") {
     return encodeURI(value);
   } else {
-    return encodePathParam(value, decodeCharMap);
+    return encodePathParam(value, decoder);
   }
 }
 function interpolatePath({
   path,
   params,
-  decodeCharMap
+  decoder
 }) {
   let isMissingParams = false;
   const usedParams = {};
@@ -1278,7 +1265,7 @@ function interpolatePath({
         }
         continue;
       }
-      const value = encodeParam("_splat", params, decodeCharMap);
+      const value = encodeParam("_splat", params, decoder);
       joined += "/" + prefix + value + suffix;
       continue;
     }
@@ -1290,7 +1277,7 @@ function interpolatePath({
       usedParams[key] = params[key];
       const prefix = path.substring(start, segment[1]);
       const suffix = path.substring(segment[4], end);
-      const value = encodeParam(key, params, decodeCharMap) ?? "undefined";
+      const value = encodeParam(key, params, decoder) ?? "undefined";
       joined += "/" + prefix + value + suffix;
       continue;
     }
@@ -1301,7 +1288,7 @@ function interpolatePath({
       usedParams[key] = valueRaw;
       const prefix = path.substring(start, segment[1]);
       const suffix = path.substring(segment[4], end);
-      const value = encodeParam(key, params, decodeCharMap) ?? "";
+      const value = encodeParam(key, params, decoder) ?? "";
       joined += "/" + prefix + value + suffix;
       continue;
     }
@@ -1310,14 +1297,12 @@ function interpolatePath({
   const interpolatedPath = joined || "/";
   return { usedParams, interpolatedPath, isMissingParams };
 }
-function encodePathParam(value, decodeCharMap) {
-  let encoded = encodeURIComponent(value);
-  if (decodeCharMap) {
-    for (const [encodedChar, char] of decodeCharMap) {
-      encoded = encoded.replaceAll(encodedChar, char);
-    }
-  }
-  return encoded;
+function encodePathParam(value, decoder) {
+  const encoded = encodeURIComponent(value);
+  return decoder?.(encoded) ?? encoded;
+}
+function isNotFound(obj) {
+  return !!obj?.isNotFound;
 }
 function getSafeSessionStorage() {
   try {
@@ -1329,17 +1314,6 @@ function getSafeSessionStorage() {
   return void 0;
 }
 const storageKey = "tsr-scroll-restoration-v1_3";
-const throttle = (fn, wait) => {
-  let timeout;
-  return (...args) => {
-    if (!timeout) {
-      timeout = setTimeout(() => {
-        fn(...args);
-        timeout = null;
-      }, wait);
-    }
-  };
-};
 function createScrollRestorationCache() {
   const safeSessionStorage = getSafeSessionStorage();
   if (!safeSessionStorage) {
@@ -1364,22 +1338,10 @@ function createScrollRestorationCache() {
     }
   };
 }
-const scrollRestorationCache = createScrollRestorationCache();
+createScrollRestorationCache();
 const defaultGetScrollRestorationKey = (location) => {
   return location.state.__TSR_key || location.href;
 };
-function getCssSelector(el) {
-  const path = [];
-  let parent;
-  while (parent = el.parentNode) {
-    path.push(
-      `${el.tagName}:nth-child(${Array.prototype.indexOf.call(parent.children, el) + 1})`
-    );
-    el = parent;
-  }
-  return `${path.reverse().join(" > ")}`.toLowerCase();
-}
-let ignoreScroll = false;
 function restoreScroll({
   storageKey: storageKey2,
   key,
@@ -1397,7 +1359,6 @@ function restoreScroll({
   }
   const resolvedKey = key || window.history.state?.__TSR_key;
   const elementEntries = byKey[resolvedKey];
-  ignoreScroll = true;
   scroll: {
     if (shouldScrollRestoration && elementEntries && Object.keys(elementEntries).length > 0) {
       for (const elementSelector in elementEntries) {
@@ -1439,100 +1400,15 @@ function restoreScroll({
       }
     }
   }
-  ignoreScroll = false;
 }
 function setupScrollRestoration(router, force) {
-  if (!scrollRestorationCache && !router.isServer) {
-    return;
-  }
   const shouldScrollRestoration = router.options.scrollRestoration ?? false;
   if (shouldScrollRestoration) {
     router.isScrollRestoring = true;
   }
-  if (router.isServer || router.isScrollRestorationSetup || !scrollRestorationCache) {
+  {
     return;
   }
-  router.isScrollRestorationSetup = true;
-  ignoreScroll = false;
-  const getKey = router.options.getScrollRestorationKey || defaultGetScrollRestorationKey;
-  window.history.scrollRestoration = "manual";
-  const onScroll = (event) => {
-    if (ignoreScroll || !router.isScrollRestoring) {
-      return;
-    }
-    let elementSelector = "";
-    if (event.target === document || event.target === window) {
-      elementSelector = "window";
-    } else {
-      const attrId = event.target.getAttribute(
-        "data-scroll-restoration-id"
-      );
-      if (attrId) {
-        elementSelector = `[data-scroll-restoration-id="${attrId}"]`;
-      } else {
-        elementSelector = getCssSelector(event.target);
-      }
-    }
-    const restoreKey = getKey(router.state.location);
-    scrollRestorationCache.set((state) => {
-      const keyEntry = state[restoreKey] ||= {};
-      const elementEntry = keyEntry[elementSelector] ||= {};
-      if (elementSelector === "window") {
-        elementEntry.scrollX = window.scrollX || 0;
-        elementEntry.scrollY = window.scrollY || 0;
-      } else if (elementSelector) {
-        const element = document.querySelector(elementSelector);
-        if (element) {
-          elementEntry.scrollX = element.scrollLeft || 0;
-          elementEntry.scrollY = element.scrollTop || 0;
-        }
-      }
-      return state;
-    });
-  };
-  if (typeof document !== "undefined") {
-    document.addEventListener("scroll", throttle(onScroll, 100), true);
-  }
-  router.subscribe("onRendered", (event) => {
-    const cacheKey = getKey(event.toLocation);
-    const resetScroll = event.toLocation.state.__TSR_resetScroll ?? true;
-    if (!resetScroll) {
-      return;
-    }
-    if (typeof router.options.scrollRestoration === "function") {
-      const shouldRestore = router.options.scrollRestoration({
-        location: router.latestLocation
-      });
-      if (!shouldRestore) {
-        return;
-      }
-    }
-    restoreScroll({
-      storageKey,
-      key: cacheKey,
-      behavior: router.options.scrollRestorationBehavior,
-      shouldScrollRestoration: router.isScrollRestoring,
-      scrollToTopSelectors: router.options.scrollToTopSelectors,
-      location: router.history.location
-    });
-    if (router.isScrollRestoring) {
-      scrollRestorationCache.set((state) => {
-        state[cacheKey] ||= {};
-        return state;
-      });
-    }
-  });
-}
-function handleHashScroll(router) {
-  if (typeof document !== "undefined" && document.querySelector) {
-    const hashScrollIntoViewOptions = router.state.location.state.__hashScrollIntoViewOptions ?? true;
-    if (hashScrollIntoViewOptions && router.state.location.hash !== "") {
-      const el = document.getElementById(router.state.location.hash);
-      if (el) {
-        el.scrollIntoView(hashScrollIntoViewOptions);
-      }
-    }
-  }
 }
 function encode(obj, stringify = String) {
   const result = new URLSearchParams();
@@ -1642,15 +1518,6 @@ function redirect(opts) {
 function isRedirect(obj) {
   return obj instanceof Response && !!obj.options;
 }
-function isResolvedRedirect(obj) {
-  return isRedirect(obj) && !!obj.options.href;
-}
-function parseRedirect(obj) {
-  if (obj !== null && typeof obj === "object" && obj.isSerializedRedirect) {
-    return redirect(obj);
-  }
-  return void 0;
-}
 const triggerOnReady = (inner) => {
   if (!inner.rendered) {
     inner.rendered = true;
@@ -1732,10 +1599,7 @@ const handleRedirectAndNotFound = (inner, match, err) => {
 };
 const shouldSkipLoader = (inner, matchId) => {
   const match = inner.router.getMatch(matchId);
-  if (!inner.router.isServer && match._nonReactive.dehydrated) {
-    return true;
-  }
-  if (inner.router.isServer && match.ssr === false) {
+  if (match.ssr === false) {
     return true;
   }
   return false;
@@ -1825,7 +1689,7 @@ const isBeforeLoadSsr = (inner, matchId, index, route) => {
 const setupPendingTimeout = (inner, matchId, route, match) => {
   if (match._nonReactive.pendingTimeout !== void 0) return;
   const pendingMs = route.options.pendingMs ?? inner.router.options.defaultPendingMs;
-  const shouldPending = !!(inner.onReady && !inner.router.isServer && !resolvePreload(inner, matchId) && (route.options.loader || route.options.beforeLoad || routeNeedsPreload(route)) && typeof pendingMs === "number" && pendingMs !== Infinity && (route.options.pendingComponent ?? inner.router.options?.defaultPendingComponent));
+  const shouldPending = !!(inner.onReady && false);
   if (shouldPending) {
     const pendingTimeout = setTimeout(() => {
       triggerOnReady(inner);
@@ -1957,7 +1821,7 @@ const handleBeforeLoad = (inner, index) => {
   const { id: matchId, routeId } = inner.matches[index];
   const route = inner.router.looseRoutesById[routeId];
   const serverSsr = () => {
-    if (inner.router.isServer) {
+    {
       const maybePromise = isBeforeLoadSsr(inner, matchId, index, route);
       if (isPromise(maybePromise)) return maybePromise.then(queueExecution);
     }
@@ -2031,7 +1895,7 @@ const runLoader = async (inner, matchId, index, route) => {
   try {
     const match = inner.router.getMatch(matchId);
     try {
-      if (!inner.router.isServer || match.ssr === true) {
+      if (!(isServer ?? inner.router.isServer) || match.ssr === true) {
         loadRouteChunk(route);
       }
       const loaderResult = route.options.loader?.(
@@ -2120,7 +1984,7 @@ const loadRouteMatch = async (inner, index) => {
   let loaderIsRunningAsync = false;
   const route = inner.router.looseRoutesById[routeId];
   if (shouldSkipLoader(inner, matchId)) {
-    if (inner.router.isServer) {
+    {
       return inner.router.getMatch(matchId);
     }
   } else {
@@ -2198,9 +2062,6 @@ async function loadMatches(arg) {
   const inner = Object.assign(arg, {
     matchPromises: []
   });
-  if (!inner.router.isServer && inner.router.state.matches.some((d) => d._forcePending)) {
-    triggerOnReady(inner);
-  }
   try {
     for (let i = 0; i < inner.matches.length; i++) {
       const beforeLoad = handleBeforeLoad(inner, i);
@@ -2385,6 +2246,7 @@ class RouterCore {
     this.tempLocationKey = `${Math.round(
       Math.random() * 1e7
     )}`;
+    this.resetNextScroll = true;
     this.shouldViewTransition = void 0;
     this.isViewTransitionTypesSupported = void 0;
     this.subscribers = /* @__PURE__ */ new Set();
@@ -2406,26 +2268,19 @@ class RouterCore {
         ...newOptions
       };
       this.isServer = this.options.isServer ?? typeof document === "undefined";
-      this.pathParamsDecodeCharMap = this.options.pathParamsAllowedCharacters ? new Map(
-        this.options.pathParamsAllowedCharacters.map((char) => [
-          encodeURIComponent(char),
-          char
-        ])
-      ) : void 0;
+      if (this.options.pathParamsAllowedCharacters)
+        this.pathParamsDecoder = compileDecodeCharMap(
+          this.options.pathParamsAllowedCharacters
+        );
       if (!this.history || this.options.history && this.options.history !== this.history) {
-        if (!this.options.history) {
-          if (!this.isServer) {
-            this.history = createBrowserHistory();
-          }
-        } else {
+        if (!this.options.history) ;
+        else {
           this.history = this.options.history;
         }
       }
       this.origin = this.options.origin;
       if (!this.origin) {
-        if (!this.isServer && window?.origin && window.origin !== "null") {
-          this.origin = window.origin;
-        } else {
+        {
           this.origin = "http://localhost";
         }
       }
@@ -2434,7 +2289,23 @@ class RouterCore {
       }
       if (this.options.routeTree !== this.routeTree) {
         this.routeTree = this.options.routeTree;
-        this.buildRouteTree();
+        let processRouteTreeResult;
+        if (globalThis.__TSR_CACHE__ && globalThis.__TSR_CACHE__.routeTree === this.routeTree) {
+          const cached = globalThis.__TSR_CACHE__;
+          this.resolvePathCache = cached.resolvePathCache;
+          processRouteTreeResult = cached.processRouteTreeResult;
+        } else {
+          this.resolvePathCache = createLRUCache(1e3);
+          processRouteTreeResult = this.buildRouteTree();
+          if (globalThis.__TSR_CACHE__ === void 0) {
+            globalThis.__TSR_CACHE__ = {
+              routeTree: this.routeTree,
+              processRouteTreeResult,
+              resolvePathCache: this.resolvePathCache
+            };
+          }
+        }
+        this.setRoutes(processRouteTreeResult);
       }
       if (!this.__store && this.latestLocation) {
         this.__store = new Store(getInitialRouterState(this.latestLocation), {
@@ -2457,7 +2328,8 @@ class RouterCore {
       if (basepathChanged || rewriteChanged) {
         this.basepath = nextBasepath;
         const rewrites = [];
-        if (trimPath(nextBasepath) !== "") {
+        const trimmed = trimPath(nextBasepath);
+        if (trimmed && trimmed !== "/") {
           rewrites.push(
             rewriteBasepath({
               basepath: nextBasepath
@@ -2492,7 +2364,7 @@ class RouterCore {
       );
     };
     this.buildRouteTree = () => {
-      const { routesById, routesByPath, processedTree } = processRouteTree(
+      const result = processRouteTree(
         this.routeTree,
         this.options.caseSensitive,
         (route, i) => {
@@ -2502,18 +2374,9 @@ class RouterCore {
         }
       );
       if (this.options.routeMasks) {
-        processRouteMasks(this.options.routeMasks, processedTree);
-      }
-      this.routesById = routesById;
-      this.routesByPath = routesByPath;
-      this.processedTree = processedTree;
-      const notFoundRoute = this.options.notFoundRoute;
-      if (notFoundRoute) {
-        notFoundRoute.init({
-          originalIndex: 99999999999
-        });
-        this.routesById[notFoundRoute.id] = notFoundRoute;
+        processRouteMasks(this.options.routeMasks, result.processedTree);
       }
+      return result;
     };
     this.subscribe = (eventType, fn) => {
       const listener = {
@@ -2546,8 +2409,8 @@ class RouterCore {
         return {
           href: fullPath,
           publicHref: href,
-          url,
           pathname: decodePath(url.pathname),
+          external: !!this.rewrite && url.origin !== this.origin,
           searchStr,
           search: replaceEqualDeep(previousLocation?.search, parsedSearch),
           hash: decodePath(url.hash.split("#").reverse()[0] ?? ""),
@@ -2568,7 +2431,6 @@ class RouterCore {
       }
       return location;
     };
-    this.resolvePathCache = createLRUCache(1e3);
     this.resolvePathWithBase = (from, path) => {
       const resolvedPath = resolvePath({
         base: from,
@@ -2586,9 +2448,9 @@ class RouterCore {
             search: locationSearchOrOpts
           },
           opts
-        ).matches;
+        );
       }
-      return this.matchRoutesInternal(pathnameOrNext, locationSearchOrOpts).matches;
+      return this.matchRoutesInternal(pathnameOrNext, locationSearchOrOpts);
     };
     this.getMatchedRoutes = (pathname) => {
       return getMatchedRoutes({
@@ -2623,15 +2485,12 @@ class RouterCore {
     this.buildLocation = (opts) => {
       const build = (dest = {}) => {
         const currentLocation = dest._fromLocation || this.pendingBuiltLocation || this.latestLocation;
-        const allCurrentLocationMatches = this.matchRoutes(currentLocation, {
-          _buildLocation: true
-        });
-        const lastMatch = last(allCurrentLocationMatches);
+        const lightweightResult = this.matchRoutesLightweight(currentLocation);
         if (dest.from && false) ;
-        const defaultedFromPath = dest.unsafeRelative === "path" ? currentLocation.pathname : dest.from ?? lastMatch.fullPath;
+        const defaultedFromPath = dest.unsafeRelative === "path" ? currentLocation.pathname : dest.from ?? lightweightResult.fullPath;
         const fromPath = this.resolvePathWithBase(defaultedFromPath, ".");
-        const fromSearch = lastMatch.search;
-        const fromParams = { ...lastMatch.params };
+        const fromSearch = lightweightResult.search;
+        const fromParams = { ...lightweightResult.params };
         const nextTo = dest.to ? this.resolvePathWithBase(fromPath, `${dest.to}`) : this.resolvePathWithBase(fromPath, ".");
         const nextParams = dest.params === false || dest.params === null ? {} : (dest.params ?? true) === true ? fromParams : Object.assign(
           fromParams,
@@ -2643,14 +2502,12 @@ class RouterCore {
         }).interpolatedPath;
         const destMatchResult = this.getMatchedRoutes(interpolatedNextTo);
         let destRoutes = destMatchResult.matchedRoutes;
-        const rawParams = destMatchResult.routeParams;
         const isGlobalNotFound = destMatchResult.foundRoute ? destMatchResult.foundRoute.path !== "/" && destMatchResult.routeParams["**"] : trimPathRight(interpolatedNextTo);
-        let globalNotFoundRouteId;
         if (isGlobalNotFound) {
           if (this.options.notFoundRoute) {
             destRoutes = [...destRoutes, this.options.notFoundRoute];
           } else {
-            globalNotFoundRouteId = findGlobalNotFoundRouteId(
+            findGlobalNotFoundRouteId(
               this.options.notFoundMode,
               destRoutes
             );
@@ -2672,7 +2529,7 @@ class RouterCore {
           interpolatePath({
             path: nextTo,
             params: nextParams,
-            decodeCharMap: this.pathParamsDecodeCharMap
+            decoder: this.pathParamsDecoder
           }).interpolatedPath
         );
         let nextSearch = fromSearch;
@@ -2706,31 +2563,34 @@ class RouterCore {
         const hashStr = hash ? `#${hash}` : "";
         let nextState = dest.state === true ? currentLocation.state : dest.state ? functionalUpdate(dest.state, currentLocation.state) : {};
         nextState = replaceEqualDeep(currentLocation.state, nextState);
-        const snapshotParams = {
-          ...rawParams,
-          ...nextParams
-        };
-        const matchSnapshot = buildMatchSnapshotFromRoutes({
-          routes: destRoutes,
-          params: snapshotParams,
-          searchStr,
-          globalNotFoundRouteId
-        });
         const fullPath = `${nextPathname}${searchStr}${hashStr}`;
-        const url = new URL(fullPath, this.origin);
-        const rewrittenUrl = executeRewriteOutput(this.rewrite, url);
-        const encodedHref = url.href.replace(url.origin, "");
+        let href;
+        let publicHref;
+        let external = false;
+        if (this.rewrite) {
+          const url = new URL(fullPath, this.origin);
+          const rewrittenUrl = executeRewriteOutput(this.rewrite, url);
+          href = url.href.replace(url.origin, "");
+          if (rewrittenUrl.origin !== this.origin) {
+            publicHref = rewrittenUrl.href;
+            external = true;
+          } else {
+            publicHref = rewrittenUrl.pathname + rewrittenUrl.search + rewrittenUrl.hash;
+          }
+        } else {
+          href = encodeNonAscii(fullPath);
+          publicHref = href;
+        }
         return {
-          publicHref: rewrittenUrl.pathname + rewrittenUrl.search + rewrittenUrl.hash,
-          href: encodedHref,
-          url: rewrittenUrl,
+          publicHref,
+          href,
           pathname: nextPathname,
           search: nextSearch,
           searchStr,
           state: nextState,
           hash: hash ?? "",
-          unmaskOnReload: dest.unmaskOnReload,
-          _matchSnapshot: matchSnapshot
+          external,
+          unmaskOnReload: dest.unmaskOnReload
         };
       };
       const buildWithMatches = (dest = {}, maskedDest) => {
@@ -2802,73 +2662,50 @@ class RouterCore {
       });
       if (isSameUrl && isSameState()) {
         this.load();
-        return this.commitLocationPromise;
-      }
-      let {
-        // eslint-disable-next-line prefer-const
-        maskedLocation,
-        // eslint-disable-next-line prefer-const
-        hashScrollIntoView,
-        // don't pass url into history since it is a URL instance that cannot be serialized
-        // eslint-disable-next-line prefer-const
-        url: _url,
-        ...nextHistory
-      } = next;
-      if (maskedLocation) {
-        nextHistory = {
-          ...maskedLocation,
-          state: {
-            ...maskedLocation.state,
-            __tempKey: void 0,
-            __tempLocation: {
-              ...nextHistory,
-              search: nextHistory.searchStr,
-              state: {
-                ...nextHistory.state,
-                __tempKey: void 0,
-                __tempLocation: void 0,
-                __TSR_key: void 0,
-                key: void 0
-                // TODO: Remove in v2 - use __TSR_key instead
+      } else {
+        let {
+          // eslint-disable-next-line prefer-const
+          maskedLocation,
+          // eslint-disable-next-line prefer-const
+          hashScrollIntoView,
+          ...nextHistory
+        } = next;
+        if (maskedLocation) {
+          nextHistory = {
+            ...maskedLocation,
+            state: {
+              ...maskedLocation.state,
+              __tempKey: void 0,
+              __tempLocation: {
+                ...nextHistory,
+                search: nextHistory.searchStr,
+                state: {
+                  ...nextHistory.state,
+                  __tempKey: void 0,
+                  __tempLocation: void 0,
+                  __TSR_key: void 0,
+                  key: void 0
+                  // TODO: Remove in v2 - use __TSR_key instead
+                }
               }
             }
+          };
+          if (nextHistory.unmaskOnReload ?? this.options.unmaskOnReload ?? false) {
+            nextHistory.state.__tempKey = this.tempLocationKey;
           }
-        };
-        if (nextHistory.unmaskOnReload ?? this.options.unmaskOnReload ?? false) {
-          nextHistory.state.__tempKey = this.tempLocationKey;
         }
+        nextHistory.state.__hashScrollIntoViewOptions = hashScrollIntoView ?? this.options.defaultHashScrollIntoView ?? true;
+        this.shouldViewTransition = viewTransition;
+        this.history[next.replace ? "replace" : "push"](
+          nextHistory.publicHref,
+          nextHistory.state,
+          { ignoreBlocker }
+        );
       }
-      nextHistory.state.__hashScrollIntoViewOptions = hashScrollIntoView ?? this.options.defaultHashScrollIntoView ?? true;
-      nextHistory.state.__TSR_resetScroll = next.resetScroll ?? true;
-      this.shouldViewTransition = viewTransition;
-      nextHistory.state.__TSR_sessionId = this.sessionId;
-      nextHistory.state.__TSR_matches = next._matchSnapshot ?? buildMatchSnapshot({
-        matchResult: this.getMatchedRoutes(next.pathname),
-        pathname: next.pathname,
-        searchStr: next.searchStr,
-        notFoundRoute: this.options.notFoundRoute,
-        notFoundMode: this.options.notFoundMode
-      });
-      const precomputedLocation = {
-        ...next,
-        publicHref: nextHistory.publicHref,
-        state: nextHistory.state,
-        maskedLocation
-      };
-      const result = await this.history[next.replace ? "replace" : "push"](
-        nextHistory.publicHref,
-        nextHistory.state,
-        { ignoreBlocker, skipTransitionerLoad: true }
-      );
-      if (result.type === "BLOCKED") {
-        this.commitLocationPromise?.resolve();
-        return this.commitLocationPromise;
-      }
-      if (this.history.location.href !== nextHistory.publicHref) {
-        return this.commitLocationPromise;
+      this.resetNextScroll = next.resetScroll ?? true;
+      if (!this.history.subscribers.size) {
+        this.load();
       }
-      this.latestLocation = precomputedLocation;
-      this.load({ _skipUpdateLatestLocation: true });
       return this.commitLocationPromise;
     };
     this.buildAndCommitLocation = ({
@@ -2932,8 +2769,8 @@ class RouterCore {
       if (reloadDocument) {
         if (to !== void 0 || !href) {
           const location = this.buildLocation({ to, ...rest });
-          href = href ?? location.url.href;
-          publicHref = publicHref ?? location.url.href;
+          href = href ?? location.publicHref;
+          publicHref = publicHref ?? location.publicHref;
         }
         const reloadHref = !hrefIsUrl && publicHref ? publicHref : href;
         if (isDangerousProtocol(reloadHref)) {
@@ -2970,12 +2807,10 @@ class RouterCore {
         _isNavigate: true
       });
     };
-    this.beforeLoad = (opts) => {
+    this.beforeLoad = () => {
       this.cancelMatches();
-      if (!opts?._skipUpdateLatestLocation) {
-        this.updateLatestLocation();
-      }
-      if (this.isServer) {
+      this.updateLatestLocation();
+      {
         const nextLocation = this.buildLocation({
           to: this.latestLocation.pathname,
           search: true,
@@ -2984,13 +2819,12 @@ class RouterCore {
           state: true,
           _includeValidateSearch: true
         });
-        if (this.latestLocation.publicHref !== nextLocation.publicHref || nextLocation.url.origin !== this.origin) {
+        if (this.latestLocation.publicHref !== nextLocation.publicHref) {
           const href = this.getParsedLocationHref(nextLocation);
           throw redirect({ href });
         }
       }
-      const snapshot = this.latestLocation.state.__TSR_sessionId === this.sessionId ? this.latestLocation.state.__TSR_matches : void 0;
-      const pendingMatches = this.matchRoutes(this.latestLocation, { snapshot });
+      const pendingMatches = this.matchRoutes(this.latestLocation);
       this.__store.setState((s) => ({
         ...s,
         status: "pending",
@@ -3011,9 +2845,7 @@ class RouterCore {
       loadPromise = new Promise((resolve) => {
         this.startTransition(async () => {
           try {
-            this.beforeLoad({
-              _skipUpdateLatestLocation: opts?._skipUpdateLatestLocation
-            });
+            this.beforeLoad();
             const next = this.latestLocation;
             const prevLocation = this.state.resolvedLocation;
             if (!this.state.redirect) {
@@ -3098,13 +2930,6 @@ class RouterCore {
           } catch (err) {
             if (isRedirect(err)) {
               redirect2 = err;
-              if (!this.isServer) {
-                this.navigate({
-                  ...redirect2.options,
-                  replace: true,
-                  ignoreBlocker: true
-                });
-              }
             } else if (isNotFound(err)) {
               notFound = err;
             }
@@ -3208,11 +3033,7 @@ class RouterCore {
       return this.load({ sync: opts?.sync });
     };
     this.getParsedLocationHref = (location) => {
-      let href = location.url.href;
-      if (this.origin && location.url.origin === this.origin) {
-        href = href.replace(this.origin, "") || "/";
-      }
-      return href;
+      return location.publicHref || "/";
     };
     this.resolveRedirect = (redirect2) => {
       const locationHeader = redirect2.headers.get("Location");
@@ -3370,7 +3191,6 @@ class RouterCore {
         (d) => d.status === "notFound" || d.globalNotFound
       );
     };
-    this.sessionId = typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
     this.update({
       defaultPreloadDelay: 50,
       defaultPendingMs: 1e3,
@@ -3395,61 +3215,53 @@ class RouterCore {
   get state() {
     return this.__store.state;
   }
+  setRoutes({
+    routesById,
+    routesByPath,
+    processedTree
+  }) {
+    this.routesById = routesById;
+    this.routesByPath = routesByPath;
+    this.processedTree = processedTree;
+    const notFoundRoute = this.options.notFoundRoute;
+    if (notFoundRoute) {
+      notFoundRoute.init({
+        originalIndex: 99999999999
+      });
+      this.routesById[notFoundRoute.id] = notFoundRoute;
+    }
+  }
   get looseRoutesById() {
     return this.routesById;
   }
   matchRoutesInternal(next, opts) {
-    const snapshot = opts?.snapshot;
-    const snapshotValid = snapshot && snapshot.routeIds.length > 0 && snapshot.routeIds.every((id) => this.routesById[id]);
-    let matchedRoutes;
-    let routeParams;
-    let rawParams;
-    let globalNotFoundRouteId;
-    let parsedParams;
-    if (snapshotValid) {
-      matchedRoutes = snapshot.routeIds.map((id) => this.routesById[id]);
-      routeParams = { ...snapshot.params };
-      rawParams = { ...snapshot.params };
-      globalNotFoundRouteId = snapshot.globalNotFoundRouteId;
-      parsedParams = snapshot.parsedParams;
-    } else {
-      const matchedRoutesResult = this.getMatchedRoutes(next.pathname);
-      const { foundRoute, routeParams: rp } = matchedRoutesResult;
-      routeParams = rp;
-      rawParams = { ...rp };
-      matchedRoutes = matchedRoutesResult.matchedRoutes;
-      parsedParams = matchedRoutesResult.parsedParams;
-      let isGlobalNotFound = false;
-      if (
-        // If we found a route, and it's not an index route and we have left over path
-        foundRoute ? foundRoute.path !== "/" && routeParams["**"] : (
-          // Or if we didn't find a route and we have left over path
-          trimPathRight(next.pathname)
-        )
-      ) {
-        if (this.options.notFoundRoute) {
-          matchedRoutes = [...matchedRoutes, this.options.notFoundRoute];
-        } else {
-          isGlobalNotFound = true;
-        }
+    const matchedRoutesResult = this.getMatchedRoutes(next.pathname);
+    const { foundRoute, routeParams, parsedParams } = matchedRoutesResult;
+    let { matchedRoutes } = matchedRoutesResult;
+    let isGlobalNotFound = false;
+    if (
+      // If we found a route, and it's not an index route and we have left over path
+      foundRoute ? foundRoute.path !== "/" && routeParams["**"] : (
+        // Or if we didn't find a route and we have left over path
+        trimPathRight(next.pathname)
+      )
+    ) {
+      if (this.options.notFoundRoute) {
+        matchedRoutes = [...matchedRoutes, this.options.notFoundRoute];
+      } else {
+        isGlobalNotFound = true;
       }
-      globalNotFoundRouteId = isGlobalNotFound ? findGlobalNotFoundRouteId(this.options.notFoundMode, matchedRoutes) : void 0;
     }
+    const globalNotFoundRouteId = isGlobalNotFound ? findGlobalNotFoundRouteId(this.options.notFoundMode, matchedRoutes) : void 0;
     const matches = [];
     const getParentContext = (parentMatch) => {
       const parentMatchId = parentMatch?.id;
       const parentContext = !parentMatchId ? this.options.context ?? void 0 : parentMatch.context ?? this.options.context ?? void 0;
       return parentContext;
     };
-    const canUseCachedSearch = snapshotValid && snapshot.searchStr === next.searchStr && snapshot.validatedSearches?.length === matchedRoutes.length;
-    const validatedSearchesToCache = [];
     matchedRoutes.forEach((route, index) => {
       const parentMatch = matches[index - 1];
       const [preMatchSearch, strictMatchSearch, searchError] = (() => {
-        if (canUseCachedSearch) {
-          const cached = snapshot.validatedSearches[index];
-          return [cached.search, cached.strictSearch, void 0];
-        }
         const parentSearch = parentMatch?.search ?? next.search;
         const parentStrictSearch = parentMatch?._strictSearch ?? void 0;
         try {
@@ -3475,12 +3287,6 @@ class RouterCore {
           return [parentSearch, {}, searchParamError];
         }
       })();
-      if (!canUseCachedSearch) {
-        validatedSearchesToCache.push({
-          search: preMatchSearch,
-          strictSearch: strictMatchSearch
-        });
-      }
       const loaderDeps = route.options.loaderDeps?.({
         search: preMatchSearch
       }) ?? "";
@@ -3488,7 +3294,7 @@ class RouterCore {
       const { interpolatedPath, usedParams } = interpolatePath({
         path: route.fullPath,
         params: routeParams,
-        decodeCharMap: this.pathParamsDecodeCharMap
+        decoder: this.pathParamsDecoder
       });
       const matchId = (
         // route.id for disambiguation
@@ -3503,32 +3309,18 @@ class RouterCore {
       const strictParams = existingMatch?._strictParams ?? usedParams;
       let paramsError = void 0;
       if (!existingMatch) {
-        if (route.options.skipRouteOnParseError) {
-          for (const key in usedParams) {
-            if (key in parsedParams) {
-              strictParams[key] = parsedParams[key];
-            }
+        try {
+          extractStrictParams(route, usedParams, parsedParams, strictParams);
+        } catch (err) {
+          if (isNotFound(err) || isRedirect(err)) {
+            paramsError = err;
+          } else {
+            paramsError = new PathParamError(err.message, {
+              cause: err
+            });
           }
-        } else {
-          const strictParseParams = route.options.params?.parse ?? route.options.parseParams;
-          if (strictParseParams) {
-            try {
-              Object.assign(
-                strictParams,
-                strictParseParams(strictParams)
-              );
-            } catch (err) {
-              if (isNotFound(err) || isRedirect(err)) {
-                paramsError = err;
-              } else {
-                paramsError = new PathParamError(err.message, {
-                  cause: err
-                });
-              }
-              if (opts?.throwOnError) {
-                throw paramsError;
-              }
-            }
+          if (opts?.throwOnError) {
+            throw paramsError;
           }
         }
       }
@@ -3548,7 +3340,7 @@ class RouterCore {
         const status = route.options.loader || route.options.beforeLoad || route.lazyFn || routeNeedsPreload(route) ? "pending" : "success";
         match = {
           id: matchId,
-          ssr: this.isServer ? void 0 : route.options.ssr,
+          ssr: void 0,
           index,
           routeId: route.id,
           params: previousMatch ? replaceEqualDeep(previousMatch.params, routeParams) : routeParams,
@@ -3594,17 +3386,10 @@ class RouterCore {
       };
       matches.push(match);
     });
-    if (!canUseCachedSearch && validatedSearchesToCache.length > 0) {
-      const existingSnapshot = next.state?.__TSR_matches;
-      if (existingSnapshot) {
-        existingSnapshot.searchStr = next.searchStr;
-        existingSnapshot.validatedSearches = validatedSearchesToCache;
-      }
-    }
     matches.forEach((match, index) => {
       const route = this.looseRoutesById[match.routeId];
       const existingMatch = this.getMatch(match.id);
-      if (!existingMatch && opts?._buildLocation !== true) {
+      if (!existingMatch) {
         const parentMatch = matches[index - 1];
         const parentContext = getParentContext(parentMatch);
         if (route.options.context) {
@@ -3629,7 +3414,54 @@ class RouterCore {
         };
       }
     });
-    return { matches, rawParams };
+    return matches;
+  }
+  /**
+   * Lightweight route matching for buildLocation.
+   * Only computes fullPath, accumulated search, and params - skipping expensive
+   * operations like AbortController, ControlledPromise, loaderDeps, and full match objects.
+   */
+  matchRoutesLightweight(location) {
+    const { matchedRoutes, routeParams, parsedParams } = this.getMatchedRoutes(
+      location.pathname
+    );
+    const lastRoute = last(matchedRoutes);
+    const accumulatedSearch = { ...location.search };
+    for (const route of matchedRoutes) {
+      try {
+        Object.assign(
+          accumulatedSearch,
+          validateSearch(route.options.validateSearch, accumulatedSearch)
+        );
+      } catch {
+      }
+    }
+    const lastStateMatch = last(this.state.matches);
+    const canReuseParams = lastStateMatch && lastStateMatch.routeId === lastRoute.id && location.pathname === this.state.location.pathname;
+    let params;
+    if (canReuseParams) {
+      params = lastStateMatch.params;
+    } else {
+      const strictParams = { ...routeParams };
+      for (const route of matchedRoutes) {
+        try {
+          extractStrictParams(
+            route,
+            routeParams,
+            parsedParams ?? {},
+            strictParams
+          );
+        } catch {
+        }
+      }
+      params = strictParams;
+    }
+    return {
+      matchedRoutes,
+      fullPath: lastRoute.fullPath,
+      search: accumulatedSearch,
+      params
+    };
   }
 }
 class SearchParamError extends Error {
@@ -3678,7 +3510,7 @@ function getMatchedRoutes({
   const routeParams = {};
   const trimmedPath = trimPathRight(pathname);
   let foundRoute = void 0;
-  let parsedParams = {};
+  let parsedParams = void 0;
   const match = findRouteMatch(trimmedPath, processedTree, true);
   if (match) {
     foundRoute = match.route;
@@ -3688,64 +3520,6 @@ function getMatchedRoutes({
   const matchedRoutes = match?.branch || [routesById[rootRouteId]];
   return { matchedRoutes, routeParams, foundRoute, parsedParams };
 }
-function buildMatchSnapshot({
-  matchResult,
-  pathname,
-  searchStr,
-  notFoundRoute,
-  notFoundMode
-}) {
-  const snapshot = {
-    routeIds: matchResult.matchedRoutes.map((r) => r.id),
-    params: matchResult.routeParams,
-    parsedParams: matchResult.parsedParams,
-    searchStr
-  };
-  const isGlobalNotFound = matchResult.foundRoute ? matchResult.foundRoute.path !== "/" && matchResult.routeParams["**"] : trimPathRight(pathname);
-  if (isGlobalNotFound) {
-    if (notFoundRoute) {
-      snapshot.globalNotFoundRouteId = notFoundRoute.id;
-    } else {
-      if (notFoundMode !== "root") {
-        for (let i = matchResult.matchedRoutes.length - 1; i >= 0; i--) {
-          const route = matchResult.matchedRoutes[i];
-          if (route.children) {
-            snapshot.globalNotFoundRouteId = route.id;
-            break;
-          }
-        }
-      }
-      if (!snapshot.globalNotFoundRouteId) {
-        snapshot.globalNotFoundRouteId = rootRouteId;
-      }
-    }
-  }
-  return snapshot;
-}
-function buildMatchSnapshotFromRoutes({
-  routes,
-  params,
-  searchStr,
-  globalNotFoundRouteId
-}) {
-  const stringParams = {};
-  for (const key in params) {
-    const value = params[key];
-    if (value != null) {
-      stringParams[key] = String(value);
-    }
-  }
-  const snapshot = {
-    routeIds: routes.map((r) => r.id),
-    params: stringParams,
-    parsedParams: params,
-    searchStr
-  };
-  if (globalNotFoundRouteId) {
-    snapshot.globalNotFoundRouteId = globalNotFoundRouteId;
-  }
-  return snapshot;
-}
 function applySearchMiddleware({
   search,
   dest,
@@ -3841,7 +3615,21 @@ function findGlobalNotFoundRouteId(notFoundMode, routes) {
   }
   return rootRouteId;
 }
-const preloadWarning = "Error preloading route! ☝️";
+function extractStrictParams(route, referenceParams, parsedParams, accumulatedParams) {
+  const parseParams = route.options.params?.parse ?? route.options.parseParams;
+  if (parseParams) {
+    if (route.options.skipRouteOnParseError) {
+      for (const key in referenceParams) {
+        if (key in parsedParams) {
+          accumulatedParams[key] = parsedParams[key];
+        }
+      }
+    } else {
+      const result = parseParams(accumulatedParams);
+      Object.assign(accumulatedParams, result);
+    }
+  }
+}
 class BaseRoute {
   constructor(options) {
     this.init = (opts) => {
@@ -3929,620 +3717,7 @@ class BaseRootRoute extends BaseRoute {
     super(options);
   }
 }
-const GLOBAL_TSR = "$_TSR";
 const TSR_SCRIPT_BARRIER_ID = "$tsr-stream-barrier";
-function createSerializationAdapter(opts) {
-  return opts;
-}
-function makeSsrSerovalPlugin(serializationAdapter, options) {
-  return ni({
-    tag: "$TSR/t/" + serializationAdapter.key,
-    test: serializationAdapter.test,
-    parse: {
-      stream(value, ctx) {
-        return ctx.parse(serializationAdapter.toSerializable(value));
-      }
-    },
-    serialize(node, ctx) {
-      options.didRun = true;
-      return GLOBAL_TSR + '.t.get("' + serializationAdapter.key + '")(' + ctx.serialize(node) + ")";
-    },
-    // we never deserialize on the server during SSR
-    deserialize: void 0
-  });
-}
-function makeSerovalPlugin(serializationAdapter) {
-  return ni({
-    tag: "$TSR/t/" + serializationAdapter.key,
-    test: serializationAdapter.test,
-    parse: {
-      sync(value, ctx) {
-        return ctx.parse(serializationAdapter.toSerializable(value));
-      },
-      async async(value, ctx) {
-        return await ctx.parse(serializationAdapter.toSerializable(value));
-      },
-      stream(value, ctx) {
-        return ctx.parse(serializationAdapter.toSerializable(value));
-      }
-    },
-    // we don't generate JS code outside of SSR (for now)
-    serialize: void 0,
-    deserialize(node, ctx) {
-      return serializationAdapter.fromSerializable(ctx.deserialize(node));
-    }
-  });
-}
-const ShallowErrorPlugin = /* @__PURE__ */ ni({
-  tag: "$TSR/Error",
-  test(value) {
-    return value instanceof Error;
-  },
-  parse: {
-    sync(value, ctx) {
-      return {
-        message: ctx.parse(value.message)
-      };
-    },
-    async async(value, ctx) {
-      return {
-        message: await ctx.parse(value.message)
-      };
-    },
-    stream(value, ctx) {
-      return {
-        message: ctx.parse(value.message)
-      };
-    }
-  },
-  serialize(node, ctx) {
-    return "new Error(" + ctx.serialize(node.message) + ")";
-  },
-  deserialize(node, ctx) {
-    return new Error(ctx.deserialize(node.message));
-  }
-});
-class RawStream {
-  constructor(stream, options) {
-    this.stream = stream;
-    this.hint = options?.hint ?? "binary";
-  }
-}
-const BufferCtor = globalThis.Buffer;
-const hasNodeBuffer = !!BufferCtor && typeof BufferCtor.from === "function";
-function uint8ArrayToBase64(bytes) {
-  if (bytes.length === 0) return "";
-  if (hasNodeBuffer) {
-    return BufferCtor.from(bytes).toString("base64");
-  }
-  const CHUNK_SIZE = 32768;
-  const chunks = [];
-  for (let i = 0; i < bytes.length; i += CHUNK_SIZE) {
-    const chunk = bytes.subarray(i, i + CHUNK_SIZE);
-    chunks.push(String.fromCharCode.apply(null, chunk));
-  }
-  return btoa(chunks.join(""));
-}
-function base64ToUint8Array(base64) {
-  if (base64.length === 0) return new Uint8Array(0);
-  if (hasNodeBuffer) {
-    const buf = BufferCtor.from(base64, "base64");
-    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-  }
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return bytes;
-}
-const RAW_STREAM_FACTORY_BINARY = /* @__PURE__ */ Object.create(null);
-const RAW_STREAM_FACTORY_TEXT = /* @__PURE__ */ Object.create(null);
-const RAW_STREAM_FACTORY_CONSTRUCTOR_BINARY = (stream) => new ReadableStream({
-  start(controller) {
-    stream.on({
-      next(base64) {
-        try {
-          controller.enqueue(base64ToUint8Array(base64));
-        } catch {
-        }
-      },
-      throw(error) {
-        controller.error(error);
-      },
-      return() {
-        try {
-          controller.close();
-        } catch {
-        }
-      }
-    });
-  }
-});
-const textEncoderForFactory = new TextEncoder();
-const RAW_STREAM_FACTORY_CONSTRUCTOR_TEXT = (stream) => {
-  return new ReadableStream({
-    start(controller) {
-      stream.on({
-        next(value) {
-          try {
-            if (typeof value === "string") {
-              controller.enqueue(textEncoderForFactory.encode(value));
-            } else {
-              controller.enqueue(base64ToUint8Array(value.$b64));
-            }
-          } catch {
-          }
-        },
-        throw(error) {
-          controller.error(error);
-        },
-        return() {
-          try {
-            controller.close();
-          } catch {
-          }
-        }
-      });
-    }
-  });
-};
-const FACTORY_BINARY = `(s=>new ReadableStream({start(c){s.on({next(b){try{const d=atob(b),a=new Uint8Array(d.length);for(let i=0;i<d.length;i++)a[i]=d.charCodeAt(i);c.enqueue(a)}catch(_){}},throw(e){c.error(e)},return(){try{c.close()}catch(_){}}})}}))`;
-const FACTORY_TEXT = `(s=>{const e=new TextEncoder();return new ReadableStream({start(c){s.on({next(v){try{if(typeof v==='string'){c.enqueue(e.encode(v))}else{const d=atob(v.$b64),a=new Uint8Array(d.length);for(let i=0;i<d.length;i++)a[i]=d.charCodeAt(i);c.enqueue(a)}}catch(_){}},throw(x){c.error(x)},return(){try{c.close()}catch(_){}}})}})})`;
-function toBinaryStream(readable) {
-  const stream = te();
-  const reader = readable.getReader();
-  (async () => {
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          stream.return(void 0);
-          break;
-        }
-        stream.next(uint8ArrayToBase64(value));
-      }
-    } catch (error) {
-      stream.throw(error);
-    } finally {
-      reader.releaseLock();
-    }
-  })();
-  return stream;
-}
-function toTextStream(readable) {
-  const stream = te();
-  const reader = readable.getReader();
-  const decoder = new TextDecoder("utf-8", { fatal: true });
-  (async () => {
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          try {
-            const remaining = decoder.decode();
-            if (remaining.length > 0) {
-              stream.next(remaining);
-            }
-          } catch {
-          }
-          stream.return(void 0);
-          break;
-        }
-        try {
-          const text = decoder.decode(value, { stream: true });
-          if (text.length > 0) {
-            stream.next(text);
-          }
-        } catch {
-          stream.next({ $b64: uint8ArrayToBase64(value) });
-        }
-      }
-    } catch (error) {
-      stream.throw(error);
-    } finally {
-      reader.releaseLock();
-    }
-  })();
-  return stream;
-}
-const RawStreamFactoryBinaryPlugin = ni({
-  tag: "tss/RawStreamFactory",
-  test(value) {
-    return value === RAW_STREAM_FACTORY_BINARY;
-  },
-  parse: {
-    sync() {
-      return void 0;
-    },
-    async() {
-      return Promise.resolve(void 0);
-    },
-    stream() {
-      return void 0;
-    }
-  },
-  serialize() {
-    return FACTORY_BINARY;
-  },
-  deserialize() {
-    return RAW_STREAM_FACTORY_BINARY;
-  }
-});
-const RawStreamFactoryTextPlugin = ni({
-  tag: "tss/RawStreamFactoryText",
-  test(value) {
-    return value === RAW_STREAM_FACTORY_TEXT;
-  },
-  parse: {
-    sync() {
-      return void 0;
-    },
-    async() {
-      return Promise.resolve(void 0);
-    },
-    stream() {
-      return void 0;
-    }
-  },
-  serialize() {
-    return FACTORY_TEXT;
-  },
-  deserialize() {
-    return RAW_STREAM_FACTORY_TEXT;
-  }
-});
-const RawStreamSSRPlugin = ni({
-  tag: "tss/RawStream",
-  extends: [RawStreamFactoryBinaryPlugin, RawStreamFactoryTextPlugin],
-  test(value) {
-    return value instanceof RawStream;
-  },
-  parse: {
-    sync(value, ctx) {
-      const factory = value.hint === "text" ? RAW_STREAM_FACTORY_TEXT : RAW_STREAM_FACTORY_BINARY;
-      return {
-        hint: value.hint,
-        factory: ctx.parse(factory),
-        stream: ctx.parse(te())
-      };
-    },
-    async async(value, ctx) {
-      const factory = value.hint === "text" ? RAW_STREAM_FACTORY_TEXT : RAW_STREAM_FACTORY_BINARY;
-      const encodedStream = value.hint === "text" ? toTextStream(value.stream) : toBinaryStream(value.stream);
-      return {
-        hint: value.hint,
-        factory: await ctx.parse(factory),
-        stream: await ctx.parse(encodedStream)
-      };
-    },
-    stream(value, ctx) {
-      const factory = value.hint === "text" ? RAW_STREAM_FACTORY_TEXT : RAW_STREAM_FACTORY_BINARY;
-      const encodedStream = value.hint === "text" ? toTextStream(value.stream) : toBinaryStream(value.stream);
-      return {
-        hint: value.hint,
-        factory: ctx.parse(factory),
-        stream: ctx.parse(encodedStream)
-      };
-    }
-  },
-  serialize(node, ctx) {
-    return "(" + ctx.serialize(node.factory) + ")(" + ctx.serialize(node.stream) + ")";
-  },
-  deserialize(node, ctx) {
-    const stream = ctx.deserialize(node.stream);
-    return node.hint === "text" ? RAW_STREAM_FACTORY_CONSTRUCTOR_TEXT(stream) : RAW_STREAM_FACTORY_CONSTRUCTOR_BINARY(stream);
-  }
-});
-function createRawStreamRPCPlugin(onRawStream) {
-  let nextStreamId = 1;
-  return ni({
-    tag: "tss/RawStream",
-    test(value) {
-      return value instanceof RawStream;
-    },
-    parse: {
-      async(value) {
-        const streamId = nextStreamId++;
-        onRawStream(streamId, value.stream);
-        return Promise.resolve({ streamId });
-      },
-      stream(value) {
-        const streamId = nextStreamId++;
-        onRawStream(streamId, value.stream);
-        return { streamId };
-      }
-    },
-    serialize() {
-      throw new Error(
-        "RawStreamRPCPlugin.serialize should not be called. RPC uses JSON serialization, not JS code generation."
-      );
-    },
-    deserialize() {
-      throw new Error(
-        "RawStreamRPCPlugin.deserialize should not be called. Use createRawStreamDeserializePlugin on client."
-      );
-    }
-  });
-}
-const defaultSerovalPlugins = [
-  ShallowErrorPlugin,
-  // RawStreamSSRPlugin must come before ReadableStreamPlugin to match first
-  RawStreamSSRPlugin,
-  // ReadableStreamNode is not exported by seroval
-  p
-];
-const minifiedTsrBootStrapScript = "self.$_TSR={h(){this.hydrated=!0,this.c()},e(){this.streamEnded=!0,this.c()},c(){this.hydrated&&this.streamEnded&&(delete self.$_TSR,delete self.$R.tsr)},p(e){this.initialized?e():this.buffer.push(e)},buffer:[]};\n";
-const SCOPE_ID = "tsr";
-function dehydrateMatch(match) {
-  const dehydratedMatch = {
-    i: match.id,
-    u: match.updatedAt,
-    s: match.status
-  };
-  const properties = [
-    ["__beforeLoadContext", "b"],
-    ["loaderData", "l"],
-    ["error", "e"],
-    ["ssr", "ssr"]
-  ];
-  for (const [key, shorthand] of properties) {
-    if (match[key] !== void 0) {
-      dehydratedMatch[shorthand] = match[key];
-    }
-  }
-  return dehydratedMatch;
-}
-const INITIAL_SCRIPTS = [
-  mn(SCOPE_ID),
-  minifiedTsrBootStrapScript
-];
-class ScriptBuffer {
-  constructor(router) {
-    this._scriptBarrierLifted = false;
-    this._cleanedUp = false;
-    this._pendingMicrotask = false;
-    this.router = router;
-    this._queue = INITIAL_SCRIPTS.slice();
-  }
-  enqueue(script) {
-    if (this._cleanedUp) return;
-    this._queue.push(script);
-    if (this._scriptBarrierLifted && !this._pendingMicrotask) {
-      this._pendingMicrotask = true;
-      queueMicrotask(() => {
-        this._pendingMicrotask = false;
-        this.injectBufferedScripts();
-      });
-    }
-  }
-  liftBarrier() {
-    if (this._scriptBarrierLifted || this._cleanedUp) return;
-    this._scriptBarrierLifted = true;
-    if (this._queue.length > 0 && !this._pendingMicrotask) {
-      this._pendingMicrotask = true;
-      queueMicrotask(() => {
-        this._pendingMicrotask = false;
-        this.injectBufferedScripts();
-      });
-    }
-  }
-  /**
-   * Flushes any pending scripts synchronously.
-   * Call this before emitting onSerializationFinished to ensure all scripts are injected.
-   *
-   * IMPORTANT: Only injects if the barrier has been lifted. Before the barrier is lifted,
-   * scripts should remain in the queue so takeBufferedScripts() can retrieve them
-   */
-  flush() {
-    if (!this._scriptBarrierLifted) return;
-    if (this._cleanedUp) return;
-    this._pendingMicrotask = false;
-    const scriptsToInject = this.takeAll();
-    if (scriptsToInject && this.router?.serverSsr) {
-      this.router.serverSsr.injectScript(scriptsToInject);
-    }
-  }
-  takeAll() {
-    const bufferedScripts = this._queue;
-    this._queue = [];
-    if (bufferedScripts.length === 0) {
-      return void 0;
-    }
-    return bufferedScripts.join(";") + ";document.currentScript.remove()";
-  }
-  injectBufferedScripts() {
-    if (this._cleanedUp) return;
-    if (this._queue.length === 0) return;
-    const scriptsToInject = this.takeAll();
-    if (scriptsToInject && this.router?.serverSsr) {
-      this.router.serverSsr.injectScript(scriptsToInject);
-    }
-  }
-  cleanup() {
-    this._cleanedUp = true;
-    this._queue = [];
-    this.router = void 0;
-  }
-}
-function attachRouterServerSsrUtils({
-  router,
-  manifest
-}) {
-  router.ssr = {
-    manifest
-  };
-  let _dehydrated = false;
-  let _serializationFinished = false;
-  const renderFinishedListeners = [];
-  const serializationFinishedListeners = [];
-  const scriptBuffer = new ScriptBuffer(router);
-  let injectedHtmlBuffer = [];
-  router.serverSsr = {
-    injectHtml: (html) => {
-      if (!html) return;
-      injectedHtmlBuffer.push(html);
-      router.emit({
-        type: "onInjectedHtml"
-      });
-    },
-    injectScript: (script) => {
-      if (!script) return;
-      const html = `<script${router.options.ssr?.nonce ? ` nonce='${router.options.ssr.nonce}'` : ""}>${script}<\/script>`;
-      router.serverSsr.injectHtml(html);
-    },
-    dehydrate: async () => {
-      invariant(!_dehydrated);
-      let matchesToDehydrate = router.state.matches;
-      if (router.isShell()) {
-        matchesToDehydrate = matchesToDehydrate.slice(0, 1);
-      }
-      const matches = matchesToDehydrate.map(dehydrateMatch);
-      let manifestToDehydrate = void 0;
-      if (manifest) {
-        const currentRouteIds = new Set(
-          router.state.matches.map((k) => k.routeId)
-        );
-        const filteredRoutes = Object.fromEntries(
-          Object.entries(manifest.routes).flatMap(
-            ([routeId, routeManifest]) => {
-              if (currentRouteIds.has(routeId)) {
-                return [[routeId, routeManifest]];
-              } else if (routeManifest.assets && routeManifest.assets.length > 0) {
-                return [
-                  [
-                    routeId,
-                    {
-                      assets: routeManifest.assets
-                    }
-                  ]
-                ];
-              }
-              return [];
-            }
-          )
-        );
-        manifestToDehydrate = {
-          routes: filteredRoutes
-        };
-      }
-      const dehydratedRouter = {
-        manifest: manifestToDehydrate,
-        matches
-      };
-      const lastMatchId = matchesToDehydrate[matchesToDehydrate.length - 1]?.id;
-      if (lastMatchId) {
-        dehydratedRouter.lastMatchId = lastMatchId;
-      }
-      const dehydratedData = await router.options.dehydrate?.();
-      if (dehydratedData) {
-        dehydratedRouter.dehydratedData = dehydratedData;
-      }
-      _dehydrated = true;
-      const trackPlugins = { didRun: false };
-      const serializationAdapters = router.options.serializationAdapters;
-      const plugins = serializationAdapters ? serializationAdapters.map((t) => makeSsrSerovalPlugin(t, trackPlugins)).concat(defaultSerovalPlugins) : defaultSerovalPlugins;
-      const signalSerializationComplete = () => {
-        _serializationFinished = true;
-        try {
-          serializationFinishedListeners.forEach((l) => l());
-          router.emit({ type: "onSerializationFinished" });
-        } catch (err) {
-          console.error("Serialization listener error:", err);
-        } finally {
-          serializationFinishedListeners.length = 0;
-          renderFinishedListeners.length = 0;
-        }
-      };
-      cn(dehydratedRouter, {
-        refs: /* @__PURE__ */ new Map(),
-        plugins,
-        onSerialize: (data, initial) => {
-          let serialized = initial ? GLOBAL_TSR + ".router=" + data : data;
-          if (trackPlugins.didRun) {
-            serialized = GLOBAL_TSR + ".p(()=>" + serialized + ")";
-          }
-          scriptBuffer.enqueue(serialized);
-        },
-        scopeId: SCOPE_ID,
-        onDone: () => {
-          scriptBuffer.enqueue(GLOBAL_TSR + ".e()");
-          scriptBuffer.flush();
-          signalSerializationComplete();
-        },
-        onError: (err) => {
-          console.error("Serialization error:", err);
-          signalSerializationComplete();
-        }
-      });
-    },
-    isDehydrated() {
-      return _dehydrated;
-    },
-    isSerializationFinished() {
-      return _serializationFinished;
-    },
-    onRenderFinished: (listener) => renderFinishedListeners.push(listener),
-    onSerializationFinished: (listener) => serializationFinishedListeners.push(listener),
-    setRenderFinished: () => {
-      try {
-        renderFinishedListeners.forEach((l) => l());
-      } catch (err) {
-        console.error("Error in render finished listener:", err);
-      } finally {
-        renderFinishedListeners.length = 0;
-      }
-      scriptBuffer.liftBarrier();
-    },
-    takeBufferedScripts() {
-      const scripts = scriptBuffer.takeAll();
-      const serverBufferedScript = {
-        tag: "script",
-        attrs: {
-          nonce: router.options.ssr?.nonce,
-          className: "$tsr",
-          id: TSR_SCRIPT_BARRIER_ID
-        },
-        children: scripts
-      };
-      return serverBufferedScript;
-    },
-    liftScriptBarrier() {
-      scriptBuffer.liftBarrier();
-    },
-    takeBufferedHtml() {
-      if (injectedHtmlBuffer.length === 0) {
-        return void 0;
-      }
-      const buffered = injectedHtmlBuffer.join("");
-      injectedHtmlBuffer = [];
-      return buffered;
-    },
-    cleanup() {
-      if (!router.serverSsr) return;
-      renderFinishedListeners.length = 0;
-      serializationFinishedListeners.length = 0;
-      injectedHtmlBuffer = [];
-      scriptBuffer.cleanup();
-      router.serverSsr = void 0;
-    }
-  };
-}
-function getOrigin(request) {
-  try {
-    return new URL(request.url).origin;
-  } catch {
-  }
-  return "http://localhost";
-}
-function getNormalizedURL(url, base) {
-  if (typeof url === "string") url = url.replace("\\", "%5C");
-  const rawUrl = new URL(url, base);
-  const decodedPathname = decodePath(rawUrl.pathname);
-  const searchParams = new URLSearchParams(rawUrl.search);
-  const normalizedHref = decodedPathname + (searchParams.size > 0 ? "?" : "") + searchParams.toString() + rawUrl.hash;
-  return new URL(normalizedHref, rawUrl.origin);
-}
 function defineHandlerCallback(handler) {
   return handler;
 }
@@ -4596,6 +3771,87 @@ function findLastClosingTagEnd(str) {
   return -1;
 }
 function transformStreamWithRouter(router, appStream, opts) {
+  const serializationAlreadyFinished = router.serverSsr?.isSerializationFinished() ?? false;
+  const initialBufferedHtml = router.serverSsr?.takeBufferedHtml();
+  if (serializationAlreadyFinished && !initialBufferedHtml) {
+    let cleanedUp2 = false;
+    let controller2;
+    let isStreamClosed2 = false;
+    let lifetimeTimeoutHandle2;
+    const cleanup2 = () => {
+      if (cleanedUp2) return;
+      cleanedUp2 = true;
+      if (lifetimeTimeoutHandle2 !== void 0) {
+        clearTimeout(lifetimeTimeoutHandle2);
+        lifetimeTimeoutHandle2 = void 0;
+      }
+      router.serverSsr?.cleanup();
+    };
+    const safeClose2 = () => {
+      if (isStreamClosed2) return;
+      isStreamClosed2 = true;
+      try {
+        controller2?.close();
+      } catch {
+      }
+    };
+    const safeError2 = (error) => {
+      if (isStreamClosed2) return;
+      isStreamClosed2 = true;
+      try {
+        controller2?.error(error);
+      } catch {
+      }
+    };
+    const lifetimeMs2 = DEFAULT_LIFETIME_TIMEOUT_MS;
+    lifetimeTimeoutHandle2 = setTimeout(() => {
+      if (!cleanedUp2 && !isStreamClosed2) {
+        console.warn(
+          `SSR stream transform exceeded maximum lifetime (${lifetimeMs2}ms), forcing cleanup`
+        );
+        safeError2(new Error("Stream lifetime exceeded"));
+        cleanup2();
+      }
+    }, lifetimeMs2);
+    const stream2 = new ReadableStream$1({
+      start(c) {
+        controller2 = c;
+      },
+      cancel() {
+        isStreamClosed2 = true;
+        cleanup2();
+      }
+    });
+    (async () => {
+      const reader = appStream.getReader();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (cleanedUp2 || isStreamClosed2) return;
+          controller2?.enqueue(value);
+        }
+        if (cleanedUp2 || isStreamClosed2) return;
+        router.serverSsr?.setRenderFinished();
+        safeClose2();
+        cleanup2();
+      } catch (error) {
+        if (cleanedUp2) return;
+        console.error("Error reading appStream:", error);
+        router.serverSsr?.setRenderFinished();
+        safeError2(error);
+        cleanup2();
+      } finally {
+        reader.releaseLock();
+      }
+    })().catch((error) => {
+      if (cleanedUp2) return;
+      console.error("Error in stream transform:", error);
+      safeError2(error);
+      cleanup2();
+    });
+    return stream2;
+  }
   let stopListeningToInjectedHtml;
   let stopListeningToSerializationFinished;
   let serializationTimeoutHandle;
@@ -4603,31 +3859,14 @@ function transformStreamWithRouter(router, appStream, opts) {
   let cleanedUp = false;
   let controller;
   let isStreamClosed = false;
-  const serializationAlreadyFinished = router.serverSsr?.isSerializationFinished() ?? false;
-  function cleanup() {
-    if (cleanedUp) return;
-    cleanedUp = true;
-    try {
-      stopListeningToInjectedHtml?.();
-      stopListeningToSerializationFinished?.();
-    } catch (e) {
-    }
-    stopListeningToInjectedHtml = void 0;
-    stopListeningToSerializationFinished = void 0;
-    if (serializationTimeoutHandle !== void 0) {
-      clearTimeout(serializationTimeoutHandle);
-      serializationTimeoutHandle = void 0;
-    }
-    if (lifetimeTimeoutHandle !== void 0) {
-      clearTimeout(lifetimeTimeoutHandle);
-      lifetimeTimeoutHandle = void 0;
-    }
-    pendingRouterHtmlParts = [];
-    leftover = "";
-    pendingClosingTags = "";
-    router.serverSsr?.cleanup();
-  }
   const textDecoder = new TextDecoder();
+  let pendingRouterHtml = initialBufferedHtml ?? "";
+  let leftover = "";
+  let pendingClosingTags = "";
+  const MAX_LEFTOVER_CHARS = 2048;
+  let isAppRendering = true;
+  let streamBarrierLifted = false;
+  let serializationFinished = serializationAlreadyFinished;
   function safeEnqueue(chunk) {
     if (isStreamClosed) return;
     if (typeof chunk === "string") {
@@ -4652,6 +3891,29 @@ function transformStreamWithRouter(router, appStream, opts) {
     } catch {
     }
   }
+  function cleanup() {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    try {
+      stopListeningToInjectedHtml?.();
+      stopListeningToSerializationFinished?.();
+    } catch {
+    }
+    stopListeningToInjectedHtml = void 0;
+    stopListeningToSerializationFinished = void 0;
+    if (serializationTimeoutHandle !== void 0) {
+      clearTimeout(serializationTimeoutHandle);
+      serializationTimeoutHandle = void 0;
+    }
+    if (lifetimeTimeoutHandle !== void 0) {
+      clearTimeout(lifetimeTimeoutHandle);
+      lifetimeTimeoutHandle = void 0;
+    }
+    pendingRouterHtml = "";
+    leftover = "";
+    pendingClosingTags = "";
+    router.serverSsr?.cleanup();
+  }
   const stream = new ReadableStream$1({
     start(c) {
       controller = c;
@@ -4661,21 +3923,14 @@ function transformStreamWithRouter(router, appStream, opts) {
       cleanup();
     }
   });
-  let isAppRendering = true;
-  let streamBarrierLifted = false;
-  let leftover = "";
-  let pendingClosingTags = "";
-  let serializationFinished = serializationAlreadyFinished;
-  let pendingRouterHtmlParts = [];
-  const bufferedHtml = router.serverSsr?.takeBufferedHtml();
-  if (bufferedHtml) {
-    pendingRouterHtmlParts.push(bufferedHtml);
-  }
   function flushPendingRouterHtml() {
-    if (pendingRouterHtmlParts.length > 0) {
-      safeEnqueue(pendingRouterHtmlParts.join(""));
-      pendingRouterHtmlParts = [];
-    }
+    if (!pendingRouterHtml) return;
+    safeEnqueue(pendingRouterHtml);
+    pendingRouterHtml = "";
+  }
+  function appendRouterHtml(html) {
+    if (!html) return;
+    pendingRouterHtml += html;
   }
   function tryFinish() {
     if (isAppRendering || !serializationFinished) return;
@@ -4707,8 +3962,8 @@ function transformStreamWithRouter(router, appStream, opts) {
       if (cleanedUp || isStreamClosed) return;
       const html = router.serverSsr?.takeBufferedHtml();
       if (!html) return;
-      if (isAppRendering) {
-        pendingRouterHtmlParts.push(html);
+      if (isAppRendering || leftover || pendingClosingTags) {
+        appendRouterHtml(html);
       } else {
         safeEnqueue(html);
       }
@@ -4729,13 +3984,18 @@ function transformStreamWithRouter(router, appStream, opts) {
         if (done) break;
         if (cleanedUp || isStreamClosed) return;
         const text = value instanceof Uint8Array ? textDecoder.decode(value, { stream: true }) : String(value);
-        const chunkString = leftover + text;
+        const chunkString = leftover ? leftover + text : text;
         if (!streamBarrierLifted) {
           if (chunkString.includes(TSR_SCRIPT_BARRIER_ID)) {
             streamBarrierLifted = true;
             router.serverSsr?.liftScriptBarrier();
           }
         }
+        if (pendingClosingTags) {
+          pendingClosingTags += chunkString;
+          leftover = "";
+          continue;
+        }
         const bodyEndIndex = chunkString.indexOf(BODY_END_TAG);
         const htmlEndIndex = chunkString.indexOf(HTML_END_TAG);
         if (bodyEndIndex !== -1 && htmlEndIndex !== -1 && bodyEndIndex < htmlEndIndex) {
@@ -4750,8 +4010,19 @@ function transformStreamWithRouter(router, appStream, opts) {
           safeEnqueue(chunkString.slice(0, lastClosingTagEnd));
           flushPendingRouterHtml();
           leftover = chunkString.slice(lastClosingTagEnd);
+          if (leftover.length > MAX_LEFTOVER_CHARS) {
+            safeEnqueue(leftover.slice(0, leftover.length - MAX_LEFTOVER_CHARS));
+            leftover = leftover.slice(-MAX_LEFTOVER_CHARS);
+          }
         } else {
-          leftover = chunkString;
+          const combined = chunkString;
+          if (combined.length > MAX_LEFTOVER_CHARS) {
+            const flushUpto = combined.length - MAX_LEFTOVER_CHARS;
+            safeEnqueue(combined.slice(0, flushUpto));
+            leftover = combined.slice(flushUpto);
+          } else {
+            leftover = combined;
+          }
         }
       }
       if (cleanedUp || isStreamClosed) return;
@@ -4790,40 +4061,25 @@ function transformStreamWithRouter(router, appStream, opts) {
   return stream;
 }
 export {
-  attachRouterServerSsrUtils as A,
   BaseRootRoute as B,
-  createSerializationAdapter as C,
-  createRawStreamRPCPlugin as D,
-  isResolvedRedirect as E,
-  executeRewriteInput as F,
-  defaultSerovalPlugins as G,
-  makeSerovalPlugin as H,
-  defineHandlerCallback as I,
   RouterCore as R,
   restoreScroll as a,
   rootRouteId as b,
-  createControlledPromise as c,
+  isRedirect as c,
   defaultGetScrollRestorationKey as d,
   escapeHtml as e,
-  isRedirect as f,
+  transformPipeableStreamWithRouter as f,
   getLocationChangeInfo as g,
-  handleHashScroll as h,
+  isDangerousProtocol as h,
   isNotFound as i,
-  transformReadableStreamWithRouter as j,
-  transformPipeableStreamWithRouter as k,
-  isDangerousProtocol as l,
+  exactPathTest as j,
+  removeTrailingSlash as k,
+  deepEqual as l,
   functionalUpdate as m,
-  exactPathTest as n,
-  removeTrailingSlash as o,
-  preloadWarning as p,
-  deepEqual as q,
+  BaseRoute as n,
+  isModuleNotFoundError as o,
+  defineHandlerCallback as p,
   replaceEqualDeep as r,
   storageKey as s,
-  trimPathRight as t,
-  BaseRoute as u,
-  isModuleNotFoundError as v,
-  parseRedirect as w,
-  mergeHeaders as x,
-  getNormalizedURL as y,
-  getOrigin as z
+  transformReadableStreamWithRouter as t
 };