vorma 0.83.0 → 0.85.0-pre.0

package/npm_dist/internal/framework/_typescript/client/index.js

@@ -5,7 +5,7 @@ import { findNestedMatches as findNestedMatches2 } from "vorma/kit/matcher/find-
 import { getIsGETRequest as getIsGETRequest2 } from "vorma/kit/url";
 
 // internal/framework/_typescript/client/src/vorma_ctx/vorma_ctx.ts
-var VORMA_SYMBOL = Symbol.for("__vorma_internal__");
+var VORMA_SYMBOL = /* @__PURE__ */ Symbol.for("__vorma_internal__");
 function __getVormaClientGlobal() {
   const dangerousGlobalThis = globalThis;
   function get(key) {
@@ -1139,8 +1139,114 @@ async function __reRenderAppInner(props) {
 }
 
 // internal/framework/_typescript/client/src/client.ts
+function hasServerLoaderRemoval(ctx) {
+  for (const pattern of ctx.currentMatchedPatterns) {
+    const hasServerLoader = ctx.routeManifest[pattern] === 1;
+    if (hasServerLoader) {
+      const stillMatched = ctx.matchResult.matches.some(
+        (m) => m.registeredPattern.originalPattern === pattern
+      );
+      if (!stillMatched) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function hasNewClientLoader(ctx) {
+  for (const m of ctx.matchResult.matches) {
+    const pattern = m.registeredPattern.originalPattern;
+    const hasClientLoader = !!ctx.patternToWaitFnMap[pattern];
+    const wasAlreadyMatched = ctx.currentMatchedPatterns.includes(pattern);
+    if (hasClientLoader && !wasAlreadyMatched) {
+      return true;
+    }
+  }
+  return false;
+}
+function findOutermostLoaderIndex(ctx) {
+  for (let i = ctx.matchResult.matches.length - 1; i >= 0; i--) {
+    const match = ctx.matchResult.matches[i];
+    if (!match) continue;
+    const pattern = match.registeredPattern.originalPattern;
+    const hasServerLoader = ctx.routeManifest[pattern] === 1;
+    const hasClientLoader = !!ctx.patternToWaitFnMap[pattern];
+    if (hasServerLoader || hasClientLoader) {
+      return i;
+    }
+  }
+  return -1;
+}
+function didSearchParamsChange(ctx) {
+  const currentUrlObj = new URL(window.location.href);
+  const currentParamsSorted = Array.from(
+    currentUrlObj.searchParams.entries()
+  ).sort();
+  const targetParamsSorted = Array.from(
+    ctx.url.searchParams.entries()
+  ).sort();
+  return !jsonDeepEquals2(currentParamsSorted, targetParamsSorted);
+}
+function didOutermostParamsChange(ctx, outermostLoaderIndex) {
+  const outermostMatch = ctx.matchResult.matches[outermostLoaderIndex];
+  if (!outermostMatch) return false;
+  for (const seg of outermostMatch.registeredPattern.normalizedSegments) {
+    if (seg.segType === "dynamic") {
+      const paramName = seg.normalizedVal.substring(1);
+      if (ctx.matchResult.params[paramName] !== ctx.currentParams[paramName]) {
+        return true;
+      }
+    }
+  }
+  const hasSplat = outermostMatch.registeredPattern.lastSegType === "splat";
+  if (hasSplat) {
+    if (!jsonDeepEquals2(ctx.matchResult.splatValues, ctx.currentSplatValues)) {
+      return true;
+    }
+  }
+  return false;
+}
+function buildSkipResult(ctx) {
+  const importURLs = [];
+  const exportKeys = [];
+  const loadersData = [];
+  for (let i = 0; i < ctx.matchResult.matches.length; i++) {
+    const match = ctx.matchResult.matches[i];
+    if (!match) continue;
+    const pattern = match.registeredPattern.originalPattern;
+    const moduleInfo = ctx.clientModuleMap[pattern];
+    if (!moduleInfo) {
+      return { canSkip: false };
+    }
+    importURLs.push(moduleInfo.importURL);
+    exportKeys.push(moduleInfo.exportKey);
+    const hasServerLoader = ctx.routeManifest[pattern] === 1;
+    if (!hasServerLoader) {
+      loadersData.push(void 0);
+    } else {
+      const currentPatternIndex = ctx.currentMatchedPatterns.indexOf(pattern);
+      if (currentPatternIndex === -1) {
+        return { canSkip: false };
+      }
+      loadersData.push(ctx.currentLoadersData[currentPatternIndex]);
+    }
+  }
+  return {
+    canSkip: true,
+    matchResult: ctx.matchResult,
+    importURLs,
+    exportKeys,
+    loadersData
+  };
+}
 var NavigationStateManager = class {
-  _navigations = /* @__PURE__ */ new Map();
+  // Single slot for active user/browser/redirect navigation
+  _activeNavigation = null;
+  // Separate cache for prefetches (can have multiple to different URLs)
+  _prefetchCache = /* @__PURE__ */ new Map();
+  // Single slot for pending revalidation (at most one, coalesced)
+  _pendingRevalidation = null;
+  // Submissions tracked separately
   _submissions = /* @__PURE__ */ new Map();
   lastDispatchedStatus = null;
   dispatchStatusEventDebounced;
@@ -1153,22 +1259,49 @@ var NavigationStateManager = class {
   async navigate(props) {
     const control = this.beginNavigation(props);
     try {
-      const result = await control.promise;
-      if (!result) {
-        return { didNavigate: false };
-      }
-      const targetUrl = new URL(props.href, window.location.href).href;
-      const entry = this._navigations.get(targetUrl);
-      if (!entry) {
-        return { didNavigate: false };
-      }
-      if (entry.intent === "navigate" || entry.intent === "revalidate") {
-        const now = Date.now();
-        lastTriggeredNavOrRevalidateTimestampMS = now;
-      }
-      await this.processNavigationResult(result, entry);
-      if (entry.intent === "none" && entry.type === "prefetch") {
-        return { didNavigate: false };
+      const outcome = await control.promise;
+      switch (outcome.type) {
+        case "aborted":
+          return { didNavigate: false };
+        case "redirect": {
+          const targetUrl = new URL(props.href, window.location.href).href;
+          const entry = this.findNavigationEntry(targetUrl);
+          if (!entry) {
+            return { didNavigate: false };
+          }
+          if (entry.type === "prefetch" && entry.intent === "none") {
+            this.deleteNavigation(targetUrl);
+            return { didNavigate: false };
+          }
+          this.deleteNavigation(targetUrl);
+          await effectuateRedirectDataResult(
+            outcome.redirectData,
+            props.redirectCount || 0,
+            props
+          );
+          return { didNavigate: false };
+        }
+        case "success": {
+          const targetUrl = new URL(props.href, window.location.href).href;
+          const entry = this.findNavigationEntry(targetUrl);
+          if (!entry) {
+            return { didNavigate: false };
+          }
+          if (entry.intent === "navigate" || entry.intent === "revalidate") {
+            lastTriggeredNavOrRevalidateTimestampMS = Date.now();
+          }
+          await this.processSuccessfulNavigation(outcome, entry);
+          if (entry.intent === "none" && entry.type === "prefetch") {
+            return { didNavigate: false };
+          }
+          return { didNavigate: true };
+        }
+        default: {
+          const _exhaustive = outcome;
+          throw new Error(
+            `Unexpected navigation outcome type: ${_exhaustive.type}`
+          );
+        }
       }
     } catch (error) {
       const targetUrl = new URL(props.href, window.location.href).href;
@@ -1178,47 +1311,72 @@ var NavigationStateManager = class {
       }
       return { didNavigate: false };
     }
-    return { didNavigate: true };
   }
   beginNavigation(props) {
-    const existing = this._navigations.get(
-      new URL(props.href, window.location.href).href
-    );
+    const targetUrl = new URL(props.href, window.location.href).href;
     switch (props.navigationType) {
       case "userNavigation":
-        return this.beginUserNavigation(props, existing);
+        return this.beginUserNavigation(props, targetUrl);
       case "prefetch":
-        return this.beginPrefetch(props, existing);
+        return this.beginPrefetch(props, targetUrl);
       case "revalidation":
         return this.beginRevalidation(props);
       case "browserHistory":
       case "redirect":
       default:
-        return this.createNavigation(props, "navigate");
+        return this.createActiveNavigation(props, "navigate");
     }
   }
-  beginUserNavigation(props, existing) {
-    const targetUrl = new URL(props.href, window.location.href).href;
-    this.abortAllNavigationsExcept(targetUrl);
-    if (existing) {
-      if (existing.type === "prefetch") {
-        this.upgradeNavigation(targetUrl, {
-          type: "userNavigation",
-          intent: "navigate",
-          scrollToTop: props.scrollToTop,
-          replace: props.replace,
-          state: props.state
-        });
-        return existing.control;
+  beginUserNavigation(props, targetUrl) {
+    if (this._activeNavigation && this._activeNavigation.targetUrl !== targetUrl) {
+      this._activeNavigation.control.abortController?.abort();
+      this._activeNavigation = null;
+    }
+    for (const [url, prefetch] of this._prefetchCache.entries()) {
+      if (url !== targetUrl) {
+        prefetch.control.abortController?.abort();
+        this._prefetchCache.delete(url);
       }
-      return existing.control;
     }
-    return this.createNavigation(props, "navigate");
+    if (this._pendingRevalidation && this._pendingRevalidation.targetUrl !== targetUrl) {
+      this._pendingRevalidation.control.abortController?.abort();
+      this._pendingRevalidation = null;
+    }
+    if (this._activeNavigation?.targetUrl === targetUrl) {
+      return this._activeNavigation.control;
+    }
+    const existingPrefetch = this._prefetchCache.get(targetUrl);
+    if (existingPrefetch) {
+      this._prefetchCache.delete(targetUrl);
+      existingPrefetch.type = "userNavigation";
+      existingPrefetch.intent = "navigate";
+      existingPrefetch.scrollToTop = props.scrollToTop;
+      existingPrefetch.replace = props.replace;
+      existingPrefetch.state = props.state;
+      this._activeNavigation = existingPrefetch;
+      this.scheduleStatusUpdate();
+      return existingPrefetch.control;
+    }
+    if (this._pendingRevalidation?.targetUrl === targetUrl) {
+      this._pendingRevalidation.type = "userNavigation";
+      this._pendingRevalidation.intent = "navigate";
+      this._pendingRevalidation.scrollToTop = props.scrollToTop;
+      this._pendingRevalidation.replace = props.replace;
+      this._pendingRevalidation.state = props.state;
+      return this._pendingRevalidation.control;
+    }
+    return this.createActiveNavigation(props, "navigate");
   }
-  beginPrefetch(props, existing) {
-    const targetUrl = new URL(props.href, window.location.href).href;
-    if (existing) {
-      return existing.control;
+  beginPrefetch(props, targetUrl) {
+    if (this._activeNavigation?.targetUrl === targetUrl) {
+      return this._activeNavigation.control;
+    }
+    const existingPrefetch = this._prefetchCache.get(targetUrl);
+    if (existingPrefetch) {
+      return existingPrefetch.control;
+    }
+    if (this._pendingRevalidation?.targetUrl === targetUrl) {
+      return this._pendingRevalidation.control;
     }
     const currentUrl = new URL(window.location.href);
     const targetUrlObj = new URL(targetUrl);
@@ -1227,29 +1385,23 @@ var NavigationStateManager = class {
     if (currentUrl.href === targetUrlObj.href) {
       return {
         abortController: new AbortController(),
-        promise: Promise.resolve(void 0)
+        promise: Promise.resolve({ type: "aborted" })
       };
     }
-    return this.createNavigation(props, "none");
+    return this.createPrefetch(props, targetUrl);
   }
   beginRevalidation(props) {
     const currentUrl = window.location.href;
-    const existing = this._navigations.get(currentUrl);
-    if (existing?.type === "revalidation" && Date.now() - existing.startTime < this.REVALIDATION_COALESCE_MS) {
-      return existing.control;
+    if (this._pendingRevalidation && Date.now() - this._pendingRevalidation.startTime < this.REVALIDATION_COALESCE_MS) {
+      return this._pendingRevalidation.control;
     }
-    for (const [key, nav] of this._navigations.entries()) {
-      if (nav.type === "revalidation") {
-        nav.control.abortController?.abort();
-        this.deleteNavigation(key);
-      }
+    if (this._pendingRevalidation) {
+      this._pendingRevalidation.control.abortController?.abort();
+      this._pendingRevalidation = null;
     }
-    return this.createNavigation(
-      { ...props, href: currentUrl },
-      "revalidate"
-    );
+    return this.createRevalidation({ ...props, href: currentUrl });
   }
-  createNavigation(props, intent) {
+  createActiveNavigation(props, intent) {
     const controller = new AbortController();
     const targetUrl = new URL(props.href, window.location.href).href;
     const entry = {
@@ -1272,24 +1424,80 @@ var NavigationStateManager = class {
       replace: props.replace,
       state: props.state
     };
-    this.setNavigation(targetUrl, entry);
+    this._activeNavigation = entry;
+    this.scheduleStatusUpdate();
     return entry.control;
   }
-  upgradeNavigation(href, updates) {
-    const existing = this._navigations.get(href);
-    if (!existing) return;
-    this.setNavigation(href, {
-      ...existing,
-      ...updates
-    });
+  createPrefetch(props, targetUrl) {
+    const controller = new AbortController();
+    const entry = {
+      control: {
+        abortController: controller,
+        promise: this.fetchRouteData(controller, props).catch(
+          (error) => {
+            this._prefetchCache.delete(targetUrl);
+            throw error;
+          }
+        )
+      },
+      type: "prefetch",
+      intent: "none",
+      phase: "fetching",
+      startTime: Date.now(),
+      targetUrl,
+      originUrl: window.location.href,
+      scrollToTop: props.scrollToTop,
+      replace: props.replace,
+      state: props.state
+    };
+    this._prefetchCache.set(targetUrl, entry);
+    return entry.control;
   }
-  transitionPhase(href, phase) {
-    const existing = this._navigations.get(href);
-    if (!existing) return;
-    this.setNavigation(href, {
-      ...existing,
-      phase
-    });
+  createRevalidation(props) {
+    const controller = new AbortController();
+    const targetUrl = new URL(props.href, window.location.href).href;
+    const entry = {
+      control: {
+        abortController: controller,
+        promise: this.fetchRouteData(controller, props).catch(
+          (error) => {
+            if (this._pendingRevalidation?.targetUrl === targetUrl) {
+              this._pendingRevalidation = null;
+              this.scheduleStatusUpdate();
+            }
+            throw error;
+          }
+        )
+      },
+      type: "revalidation",
+      intent: "revalidate",
+      phase: "fetching",
+      startTime: Date.now(),
+      targetUrl,
+      originUrl: window.location.href,
+      scrollToTop: props.scrollToTop,
+      replace: props.replace,
+      state: props.state
+    };
+    this._pendingRevalidation = entry;
+    this.scheduleStatusUpdate();
+    return entry.control;
+  }
+  transitionPhase(targetUrl, phase) {
+    if (this._activeNavigation?.targetUrl === targetUrl) {
+      this._activeNavigation.phase = phase;
+      this.scheduleStatusUpdate();
+      return;
+    }
+    const prefetch = this._prefetchCache.get(targetUrl);
+    if (prefetch) {
+      prefetch.phase = phase;
+      return;
+    }
+    if (this._pendingRevalidation?.targetUrl === targetUrl) {
+      this._pendingRevalidation.phase = phase;
+      this.scheduleStatusUpdate();
+    }
   }
   canSkipServerFetch(targetUrl) {
     const routeManifest = __vormaClientGlobal.get("routeManifest");
@@ -1300,182 +1508,49 @@ var NavigationStateManager = class {
     if (!patternRegistry) {
       return { canSkip: false };
     }
-    const patternToWaitFnMap = __vormaClientGlobal.get("patternToWaitFnMap") || {};
     const url = new URL(targetUrl);
     const matchResult = findNestedMatches2(patternRegistry, url.pathname);
     if (!matchResult) {
       return { canSkip: false };
     }
-    const clientModuleMap = __vormaClientGlobal.get("clientModuleMap") || {};
-    const currentMatchedPatterns = __vormaClientGlobal.get("matchedPatterns") || [];
-    const currentParams = __vormaClientGlobal.get("params") || {};
-    const currentSplatValues = __vormaClientGlobal.get("splatValues") || [];
-    const currentLoadersData = __vormaClientGlobal.get("loadersData") || [];
-    for (const pattern of currentMatchedPatterns) {
-      const hasServerLoader = routeManifest[pattern] === 1;
-      if (hasServerLoader) {
-        const stillMatched = matchResult.matches.some(
-          (m) => m.registeredPattern.originalPattern === pattern
-        );
-        if (!stillMatched) {
-          return { canSkip: false };
-        }
-      }
-    }
-    for (const m of matchResult.matches) {
-      const pattern = m.registeredPattern.originalPattern;
-      const hasClientLoader = !!patternToWaitFnMap[pattern];
-      const wasAlreadyMatched = currentMatchedPatterns.includes(pattern);
-      if (hasClientLoader && !wasAlreadyMatched) {
-        return { canSkip: false };
-      }
+    const ctx = {
+      routeManifest,
+      patternRegistry,
+      patternToWaitFnMap: __vormaClientGlobal.get("patternToWaitFnMap") || {},
+      clientModuleMap: __vormaClientGlobal.get("clientModuleMap") || {},
+      currentMatchedPatterns: __vormaClientGlobal.get("matchedPatterns") || [],
+      currentParams: __vormaClientGlobal.get("params") || {},
+      currentSplatValues: __vormaClientGlobal.get("splatValues") || [],
+      currentLoadersData: __vormaClientGlobal.get("loadersData") || [],
+      url,
+      matchResult
+    };
+    if (hasServerLoaderRemoval(ctx)) {
+      return { canSkip: false };
     }
-    let outermostLoaderIndex = -1;
-    for (let i = matchResult.matches.length - 1; i >= 0; i--) {
-      const match = matchResult.matches[i];
-      if (!match) continue;
-      const pattern = match.registeredPattern.originalPattern;
-      const hasServerLoader = routeManifest[pattern] === 1;
-      const hasClientLoader = !!patternToWaitFnMap[pattern];
-      if (hasServerLoader || hasClientLoader) {
-        outermostLoaderIndex = i;
-        break;
-      }
-    }
-    const currentUrlObj = new URL(window.location.href);
-    const currentParamsSorted = Array.from(
-      currentUrlObj.searchParams.entries()
-    ).sort();
-    const targetParamsSorted = Array.from(
-      url.searchParams.entries()
-    ).sort();
-    const searchChanged = !jsonDeepEquals2(
-      currentParamsSorted,
-      targetParamsSorted
-    );
-    if (searchChanged && outermostLoaderIndex !== -1) {
+    if (hasNewClientLoader(ctx)) {
       return { canSkip: false };
     }
-    if (outermostLoaderIndex !== -1) {
-      const outermostMatch = matchResult.matches[outermostLoaderIndex];
-      if (outermostMatch) {
-        for (const seg of outermostMatch.registeredPattern.normalizedSegments) {
-          if (seg.segType === "dynamic") {
-            const paramName = seg.normalizedVal.substring(1);
-            if (matchResult.params[paramName] !== currentParams[paramName]) {
-              return { canSkip: false };
-            }
-          }
-        }
-        const hasSplat = outermostMatch.registeredPattern.lastSegType === "splat";
-        if (hasSplat) {
-          if (!jsonDeepEquals2(
-            matchResult.splatValues,
-            currentSplatValues
-          )) {
-            return { canSkip: false };
-          }
-        }
-      }
+    const outermostLoaderIndex = findOutermostLoaderIndex(ctx);
+    if (outermostLoaderIndex !== -1 && didSearchParamsChange(ctx)) {
+      return { canSkip: false };
     }
-    const importURLs = [];
-    const exportKeys = [];
-    const loadersData = [];
-    for (let i = 0; i < matchResult.matches.length; i++) {
-      const match = matchResult.matches[i];
-      if (!match) continue;
-      const pattern = match.registeredPattern.originalPattern;
-      const moduleInfo = clientModuleMap[pattern];
-      if (!moduleInfo) {
-        return { canSkip: false };
-      }
-      importURLs.push(moduleInfo.importURL);
-      exportKeys.push(moduleInfo.exportKey);
-      const hasServerLoader = routeManifest[pattern] === 1;
-      if (!hasServerLoader) {
-        loadersData.push(void 0);
-      } else {
-        const currentPatternIndex = currentMatchedPatterns.indexOf(pattern);
-        if (currentPatternIndex === -1) {
-          return { canSkip: false };
-        }
-        loadersData.push(currentLoadersData[currentPatternIndex]);
-      }
+    if (outermostLoaderIndex !== -1 && didOutermostParamsChange(ctx, outermostLoaderIndex)) {
+      return { canSkip: false };
     }
-    return {
-      canSkip: true,
-      matchResult,
-      importURLs,
-      exportKeys,
-      loadersData
-    };
+    return buildSkipResult(ctx);
   }
   async fetchRouteData(controller, props) {
     try {
       const url = new URL(props.href, window.location.href);
       if (props.navigationType !== "revalidation" && props.navigationType !== "action") {
         const skipCheck = this.canSkipServerFetch(url.href);
-        if (skipCheck.canSkip && skipCheck.matchResult) {
-          const { importURLs, exportKeys, loadersData } = skipCheck;
-          const json2 = {
-            matchedPatterns: skipCheck.matchResult.matches.map(
-              (m) => m.registeredPattern.originalPattern
-            ),
-            loadersData,
-            importURLs,
-            exportKeys,
-            hasRootData: __vormaClientGlobal.get("hasRootData"),
-            params: skipCheck.matchResult.params,
-            splatValues: skipCheck.matchResult.splatValues,
-            deps: [],
-            cssBundles: [],
-            outermostServerError: void 0,
-            outermostServerErrorIdx: void 0,
-            errorExportKeys: [],
-            title: void 0,
-            metaHeadEls: void 0,
-            restHeadEls: void 0,
-            activeComponents: void 0
-          };
-          const response2 = new Response(JSON.stringify(json2), {
-            status: 200,
-            headers: {
-              "Content-Type": "application/json",
-              "X-Vorma-Build-Id": __vormaClientGlobal.get("buildID") || "1"
-            }
-          });
-          const currentClientLoadersData = __vormaClientGlobal.get("clientLoadersData") || [];
-          const patternToWaitFnMap2 = __vormaClientGlobal.get("patternToWaitFnMap") || {};
-          const runningLoaders2 = /* @__PURE__ */ new Map();
-          for (let i = 0; i < json2.matchedPatterns.length; i++) {
-            const pattern = json2.matchedPatterns[i];
-            if (!pattern) continue;
-            if (patternToWaitFnMap2[pattern]) {
-              const currentMatchedPatterns = __vormaClientGlobal.get("matchedPatterns") || [];
-              const currentPatternIndex = currentMatchedPatterns.indexOf(pattern);
-              if (currentPatternIndex !== -1 && currentClientLoadersData[currentPatternIndex] !== void 0) {
-                runningLoaders2.set(
-                  pattern,
-                  Promise.resolve(
-                    currentClientLoadersData[currentPatternIndex]
-                  )
-                );
-              }
-            }
-          }
-          const waitFnPromise2 = completeClientLoaders(
-            json2,
-            __vormaClientGlobal.get("buildID") || "1",
-            runningLoaders2,
-            controller.signal
-          );
-          return {
-            response: response2,
+        if (skipCheck.canSkip) {
+          return this.buildClientOnlyOutcome(
+            skipCheck,
             props,
-            json: json2,
-            cssBundlePromises: [],
-            waitFnPromise: waitFnPromise2
-          };
+            controller
+          );
         }
       }
       url.searchParams.set(
@@ -1557,7 +1632,7 @@ var NavigationStateManager = class {
       const responseNotOK = !response?.ok && response?.status !== 304;
       if (redirected || !response) {
         controller.abort();
-        return void 0;
+        return { type: "aborted" };
       }
       if (responseNotOK) {
         controller.abort();
@@ -1565,7 +1640,7 @@ var NavigationStateManager = class {
       }
       if (redirectData?.status === "should") {
         controller.abort();
-        return { response, redirectData, props };
+        return { type: "redirect", redirectData, props };
       }
       if (!json) {
         controller.abort();
@@ -1586,7 +1661,14 @@ var NavigationStateManager = class {
       for (const bundle of json.cssBundles ?? []) {
         cssBundlePromises.push(AssetManager.preloadCSS(bundle));
       }
-      return { response, json, props, cssBundlePromises, waitFnPromise };
+      return {
+        type: "success",
+        response,
+        json,
+        props,
+        cssBundlePromises,
+        waitFnPromise
+      };
     } catch (error) {
       if (!isAbortError(error)) {
         logError("Navigation failed", error);
@@ -1594,34 +1676,80 @@ var NavigationStateManager = class {
       throw error;
     }
   }
-  async processNavigationResult(result, entry) {
-    try {
-      if (!result) return;
-      if ("redirectData" in result) {
-        if (entry.type === "prefetch" && entry.intent === "none") {
-          this.deleteNavigation(entry.targetUrl);
-          return;
-        }
-        this.deleteNavigation(entry.targetUrl);
-        await effectuateRedirectDataResult(
-          result.redirectData,
-          result.props.redirectCount || 0,
-          result.props
-        );
-        return;
+  buildClientOnlyOutcome(skipCheck, props, controller) {
+    const { matchResult, importURLs, exportKeys, loadersData } = skipCheck;
+    const json = {
+      matchedPatterns: matchResult.matches.map(
+        (m) => m.registeredPattern.originalPattern
+      ),
+      loadersData,
+      importURLs,
+      exportKeys,
+      hasRootData: __vormaClientGlobal.get("hasRootData"),
+      params: matchResult.params,
+      splatValues: matchResult.splatValues,
+      deps: [],
+      cssBundles: [],
+      outermostServerError: void 0,
+      outermostServerErrorIdx: void 0,
+      errorExportKeys: [],
+      title: void 0,
+      metaHeadEls: void 0,
+      restHeadEls: void 0,
+      activeComponents: void 0
+    };
+    const response = new Response(JSON.stringify(json), {
+      status: 200,
+      headers: {
+        "Content-Type": "application/json",
+        "X-Vorma-Build-Id": __vormaClientGlobal.get("buildID") || "1"
       }
-      if (!("json" in result)) {
-        logError("Invalid navigation result: no JSON or redirect");
-        return;
+    });
+    const currentClientLoadersData = __vormaClientGlobal.get("clientLoadersData") || [];
+    const patternToWaitFnMap = __vormaClientGlobal.get("patternToWaitFnMap") || {};
+    const runningLoaders = /* @__PURE__ */ new Map();
+    for (let i = 0; i < json.matchedPatterns.length; i++) {
+      const pattern = json.matchedPatterns[i];
+      if (!pattern) continue;
+      if (patternToWaitFnMap[pattern]) {
+        const currentMatchedPatterns = __vormaClientGlobal.get("matchedPatterns") || [];
+        const currentPatternIndex = currentMatchedPatterns.indexOf(pattern);
+        if (currentPatternIndex !== -1 && currentClientLoadersData[currentPatternIndex] !== void 0) {
+          runningLoaders.set(
+            pattern,
+            Promise.resolve(
+              currentClientLoadersData[currentPatternIndex]
+            )
+          );
+        }
       }
+    }
+    const waitFnPromise = completeClientLoaders(
+      json,
+      __vormaClientGlobal.get("buildID") || "1",
+      runningLoaders,
+      controller.signal
+    );
+    return {
+      type: "success",
+      response,
+      props,
+      json,
+      cssBundlePromises: [],
+      waitFnPromise
+    };
+  }
+  async processSuccessfulNavigation(outcome, entry) {
+    try {
+      const { response, json, props, cssBundlePromises, waitFnPromise } = outcome;
       const currentBuildID = __vormaClientGlobal.get("buildID");
-      const responseBuildID = getBuildIDFromResponse(result.response);
+      const responseBuildID = getBuildIDFromResponse(response);
       if (responseBuildID === currentBuildID) {
         const clientModuleMap = __vormaClientGlobal.get("clientModuleMap") || {};
-        const matchedPatterns = result.json.matchedPatterns || [];
-        const importURLs = result.json.importURLs || [];
-        const exportKeys = result.json.exportKeys || [];
-        const errorExportKeys = result.json.errorExportKeys || [];
+        const matchedPatterns = json.matchedPatterns || [];
+        const importURLs = json.importURLs || [];
+        const exportKeys = json.exportKeys || [];
+        const errorExportKeys = json.errorExportKeys || [];
         for (let i = 0; i < matchedPatterns.length; i++) {
           const pattern = matchedPatterns[i];
           const importURL = importURLs[i];
@@ -1636,8 +1764,8 @@ var NavigationStateManager = class {
           }
         }
         __vormaClientGlobal.set("clientModuleMap", clientModuleMap);
-        if (result.json.cssBundles && result.json.cssBundles.length > 0) {
-          AssetManager.applyCSS(result.json.cssBundles);
+        if (json.cssBundles && json.cssBundles.length > 0) {
+          AssetManager.applyCSS(json.cssBundles);
         }
       }
       if (entry.type === "revalidation") {
@@ -1648,19 +1776,19 @@ var NavigationStateManager = class {
         }
       }
       this.transitionPhase(entry.targetUrl, "waiting");
-      if (!this._navigations.has(entry.targetUrl)) {
+      if (!this.findNavigationEntry(entry.targetUrl)) {
         return;
       }
       const oldID = __vormaClientGlobal.get("buildID");
-      const newID = getBuildIDFromResponse(result.response);
+      const newID = getBuildIDFromResponse(response);
       if (newID && newID !== oldID) {
         dispatchBuildIDEvent({ newID, oldID });
       }
-      const clientLoadersResult = await result.waitFnPromise;
+      const clientLoadersResult = await waitFnPromise;
       setClientLoadersState(clientLoadersResult);
-      if (result.cssBundlePromises.length > 0) {
+      if (cssBundlePromises.length > 0) {
         try {
-          await Promise.all(result.cssBundlePromises);
+          await Promise.all(cssBundlePromises);
         } catch (error) {
           logError("Error preloading CSS bundles:", error);
         }
@@ -1675,12 +1803,12 @@ var NavigationStateManager = class {
       this.transitionPhase(entry.targetUrl, "rendering");
       try {
         await __reRenderApp({
-          json: result.json,
+          json,
           navigationType: entry.type,
           runHistoryOptions: entry.intent === "navigate" ? {
             href: entry.targetUrl,
-            scrollStateToRestore: result.props.scrollStateToRestore,
-            replace: entry.replace || result.props.replace,
+            scrollStateToRestore: props.scrollStateToRestore,
+            replace: entry.replace || props.replace,
             scrollToTop: entry.scrollToTop,
             state: entry.state
           } : void 0,
@@ -1703,7 +1831,7 @@ var NavigationStateManager = class {
   }
   async submit(url, requestInit, options) {
     const abortController = new AbortController();
-    const submissionKey = options?.dedupeKey ? `submission:${options.dedupeKey}` : Symbol("submission");
+    const submissionKey = options?.dedupeKey ? `submission:${options.dedupeKey}` : /* @__PURE__ */ Symbol("submission");
     if (typeof submissionKey === "string") {
       const existing = this._submissions.get(submissionKey);
       if (existing) {
@@ -1775,59 +1903,93 @@ var NavigationStateManager = class {
       this.scheduleStatusUpdate();
     }
   }
-  setNavigation(key, entry) {
-    this._navigations.set(key, entry);
-    this.scheduleStatusUpdate();
+  findNavigationEntry(targetUrl) {
+    if (this._activeNavigation?.targetUrl === targetUrl) {
+      return this._activeNavigation;
+    }
+    const prefetch = this._prefetchCache.get(targetUrl);
+    if (prefetch) {
+      return prefetch;
+    }
+    if (this._pendingRevalidation?.targetUrl === targetUrl) {
+      return this._pendingRevalidation;
+    }
+    return void 0;
   }
   deleteNavigation(key) {
-    const result = this._navigations.delete(key);
-    if (result) {
+    if (this._activeNavigation?.targetUrl === key) {
+      this._activeNavigation = null;
       this.scheduleStatusUpdate();
+      return true;
+    }
+    if (this._prefetchCache.has(key)) {
+      this._prefetchCache.delete(key);
+      return true;
     }
-    return result;
+    if (this._pendingRevalidation?.targetUrl === key) {
+      this._pendingRevalidation = null;
+      this.scheduleStatusUpdate();
+      return true;
+    }
+    return false;
   }
   removeNavigation(key) {
-    this.deleteNavigation(key);
+    const entry = this.findNavigationEntry(key);
+    if (entry) {
+      entry.control.abortController?.abort();
+      this.deleteNavigation(key);
+    }
   }
   getNavigation(key) {
-    return this._navigations.get(key);
+    return this.findNavigationEntry(key);
   }
   hasNavigation(key) {
-    return this._navigations.has(key);
+    return this.findNavigationEntry(key) !== void 0;
   }
   getNavigationsSize() {
-    return this._navigations.size;
+    let size = 0;
+    if (this._activeNavigation) size++;
+    size += this._prefetchCache.size;
+    if (this._pendingRevalidation) size++;
+    return size;
   }
   getNavigations() {
-    return this._navigations;
-  }
-  abortAllNavigationsExcept(excludeHref) {
-    for (const [href, nav] of this._navigations.entries()) {
-      if (href !== excludeHref) {
-        nav.control.abortController?.abort();
-        this.deleteNavigation(href);
-      }
+    const map = /* @__PURE__ */ new Map();
+    if (this._activeNavigation) {
+      map.set(this._activeNavigation.targetUrl, this._activeNavigation);
+    }
+    for (const [key, entry] of this._prefetchCache) {
+      map.set(key, entry);
     }
+    if (this._pendingRevalidation) {
+      map.set(
+        this._pendingRevalidation.targetUrl,
+        this._pendingRevalidation
+      );
+    }
+    return map;
   }
   getStatus() {
-    const navigations = Array.from(this._navigations.values());
-    const submissions = Array.from(this._submissions.values());
-    const isNavigating = navigations.some(
-      (nav) => nav.intent === "navigate" && nav.phase !== "complete"
-    );
-    const isRevalidating = navigations.some(
-      (nav) => nav.type === "revalidation" && nav.phase !== "complete"
-    );
-    const isSubmitting = submissions.some(
+    const isNavigating = this._activeNavigation !== null && this._activeNavigation.intent === "navigate" && this._activeNavigation.phase !== "complete";
+    const isRevalidating = this._pendingRevalidation !== null && this._pendingRevalidation.phase !== "complete";
+    const isSubmitting = Array.from(this._submissions.values()).some(
       (x) => !x.skipGlobalLoadingIndicator
     );
     return { isNavigating, isSubmitting, isRevalidating };
   }
   clearAll() {
-    for (const nav of this._navigations.values()) {
-      nav.control.abortController?.abort();
+    if (this._activeNavigation) {
+      this._activeNavigation.control.abortController?.abort();
+      this._activeNavigation = null;
+    }
+    for (const prefetch of this._prefetchCache.values()) {
+      prefetch.control.abortController?.abort();
+    }
+    this._prefetchCache.clear();
+    if (this._pendingRevalidation) {
+      this._pendingRevalidation.control.abortController?.abort();
+      this._pendingRevalidation = null;
     }
-    this._navigations.clear();
     for (const sub of this._submissions.values()) {
       sub.control.abortController?.abort();
     }
@@ -2228,22 +2390,42 @@ function __makeLinkOnClickFn(callbacks) {
         state: callbacks.state
       });
       if (!control.promise) return;
-      const res = await control.promise;
-      if (!res) {
-        const targetUrl2 = new URL(anchor.href, window.location.href).href;
-        navigationStateManager.removeNavigation(targetUrl2);
-        return;
-      }
-      await callbacks.beforeRender?.(e);
+      const outcome = await control.promise;
       const targetUrl = new URL(anchor.href, window.location.href).href;
-      const entry = navigationStateManager.getNavigation(targetUrl);
-      if (entry) {
-        await navigationStateManager["processNavigationResult"](
-          res,
-          entry
-        );
+      switch (outcome.type) {
+        case "aborted":
+          navigationStateManager.removeNavigation(targetUrl);
+          return;
+        case "redirect": {
+          await callbacks.beforeRender?.(e);
+          navigationStateManager.removeNavigation(targetUrl);
+          await effectuateRedirectDataResult(
+            outcome.redirectData,
+            outcome.props.redirectCount || 0,
+            outcome.props
+          );
+          await callbacks.afterRender?.(e);
+          return;
+        }
+        case "success": {
+          await callbacks.beforeRender?.(e);
+          const entry = navigationStateManager.getNavigation(targetUrl);
+          if (entry) {
+            await navigationStateManager.processSuccessfulNavigation(
+              outcome,
+              entry
+            );
+          }
+          await callbacks.afterRender?.(e);
+          return;
+        }
+        default: {
+          const _exhaustive = outcome;
+          throw new Error(
+            `Unexpected outcome type: ${_exhaustive.type}`
+          );
+        }
       }
-      await callbacks.afterRender?.(e);
     }
   };
 }