vorma 0.0.0-pre.0 → 0.82.0

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

@@ -0,0 +1,2489 @@
+// internal/framework/_typescript/client/src/client.ts
+import { debounce } from "vorma/kit/debounce";
+import { jsonDeepEquals as jsonDeepEquals2 } from "vorma/kit/json";
+import { findNestedMatches as findNestedMatches2 } from "vorma/kit/matcher/find-nested";
+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__");
+function __getVormaClientGlobal() {
+  const dangerousGlobalThis = globalThis;
+  function get(key) {
+    return dangerousGlobalThis[VORMA_SYMBOL][key];
+  }
+  function set(key, value) {
+    dangerousGlobalThis[VORMA_SYMBOL][key] = value;
+  }
+  return { get, set };
+}
+var __vormaClientGlobal = __getVormaClientGlobal();
+function getRouterData() {
+  const rootData = __vormaClientGlobal.get("hasRootData") ? __vormaClientGlobal.get("loadersData")[0] : null;
+  return {
+    buildID: __vormaClientGlobal.get("buildID") || "",
+    matchedPatterns: __vormaClientGlobal.get("matchedPatterns") || [],
+    splatValues: __vormaClientGlobal.get("splatValues") || [],
+    params: __vormaClientGlobal.get("params") || {},
+    rootData
+  };
+}
+
+// internal/framework/_typescript/client/src/resolve_public_href.ts
+function resolvePublicHref(relativeHref) {
+  let baseURL = __vormaClientGlobal.get("viteDevURL");
+  if (!baseURL) {
+    baseURL = __vormaClientGlobal.get("publicPathPrefix");
+  }
+  if (baseURL.endsWith("/")) {
+    baseURL = baseURL.slice(0, -1);
+  }
+  let final = relativeHref.startsWith("/") ? baseURL + relativeHref : baseURL + "/" + relativeHref;
+  return final;
+}
+
+// internal/framework/_typescript/client/src/asset_manager.ts
+var AssetManager = class {
+  static preloadModule(url) {
+    const href = resolvePublicHref(url);
+    if (document.querySelector(
+      `link[rel="modulepreload"][href="${CSS.escape(href)}"]`
+    )) {
+      return;
+    }
+    const link = document.createElement("link");
+    link.rel = "modulepreload";
+    link.href = href;
+    document.head.appendChild(link);
+  }
+  static preloadCSS(url) {
+    const href = resolvePublicHref(url);
+    if (document.querySelector(
+      `link[rel="preload"][href="${CSS.escape(href)}"]`
+    )) {
+      return Promise.resolve();
+    }
+    const link = document.createElement("link");
+    link.rel = "preload";
+    link.setAttribute("as", "style");
+    link.href = href;
+    document.head.appendChild(link);
+    return new Promise((resolve, reject) => {
+      link.onload = () => resolve();
+      link.onerror = reject;
+    });
+  }
+  static applyCSS(bundles) {
+    window.requestAnimationFrame(() => {
+      const prefix = __vormaClientGlobal.get("publicPathPrefix");
+      for (const bundle of bundles) {
+        if (document.querySelector(
+          `link[data-vorma-css-bundle="${bundle}"]`
+        )) {
+          continue;
+        }
+        const link = document.createElement("link");
+        link.rel = "stylesheet";
+        link.href = prefix + bundle;
+        link.setAttribute("data-vorma-css-bundle", bundle);
+        document.head.appendChild(link);
+      }
+    });
+  }
+};
+
+// internal/framework/_typescript/client/src/client_loaders.ts
+import { findNestedMatches } from "vorma/kit/matcher/find-nested";
+import { registerPattern } from "vorma/kit/matcher/register";
+
+// internal/framework/_typescript/client/src/component_loader.ts
+import { jsonDeepEquals } from "vorma/kit/json";
+function getEffectiveErrorData() {
+  const serverErrorIdx = __vormaClientGlobal.get("outermostServerErrorIdx");
+  const clientErrorIdx = __vormaClientGlobal.get("outermostClientErrorIdx");
+  let errorIdx;
+  if (serverErrorIdx != null && clientErrorIdx != null) {
+    errorIdx = Math.min(serverErrorIdx, clientErrorIdx);
+  } else {
+    errorIdx = serverErrorIdx ?? clientErrorIdx;
+  }
+  return {
+    index: errorIdx,
+    error: errorIdx === serverErrorIdx ? __vormaClientGlobal.get("outermostServerError") : errorIdx === clientErrorIdx ? __vormaClientGlobal.get("outermostClientError") : void 0
+  };
+}
+var ComponentLoader = class {
+  static async loadComponents(importURLs) {
+    const dedupedURLs = [...new Set(importURLs)];
+    const modules = await Promise.all(
+      dedupedURLs.map(async (url) => {
+        if (!url) return void 0;
+        return import(
+          /* @vite-ignore */
+          resolvePublicHref(url)
+        );
+      })
+    );
+    return new Map(dedupedURLs.map((url, i) => [url, modules[i]]));
+  }
+  static async handleComponents(importURLs) {
+    const modulesMap = await this.loadComponents(importURLs);
+    const originalImportURLs = __vormaClientGlobal.get("importURLs");
+    const exportKeys = __vormaClientGlobal.get("exportKeys") ?? [];
+    const newActiveComponents = originalImportURLs.map(
+      (url, i) => {
+        const module = modulesMap.get(url);
+        const key = exportKeys[i] ?? "default";
+        return module?.[key] ?? null;
+      }
+    );
+    if (!jsonDeepEquals(
+      newActiveComponents,
+      __vormaClientGlobal.get("activeComponents")
+    )) {
+      __vormaClientGlobal.set("activeComponents", newActiveComponents);
+    }
+  }
+  static async handleErrorBoundaryComponent(importURLs) {
+    const modulesMap = await this.loadComponents(importURLs);
+    const originalImportURLs = __vormaClientGlobal.get("importURLs");
+    const errorIdx = getEffectiveErrorData().index;
+    if (errorIdx != null) {
+      const errorModuleURL = originalImportURLs[errorIdx];
+      let errorComponent;
+      if (errorModuleURL) {
+        const errorModule = modulesMap.get(errorModuleURL);
+        const errorKeys = __vormaClientGlobal.get("errorExportKeys");
+        const errorKey = errorKeys ? errorKeys[errorIdx] : null;
+        if (errorKey && errorModule) {
+          errorComponent = errorModule[errorKey];
+        }
+      }
+      const newErrorBoundary = errorComponent ?? __vormaClientGlobal.get("defaultErrorBoundary");
+      const currentErrorBoundary = __vormaClientGlobal.get(
+        "activeErrorBoundary"
+      );
+      if (currentErrorBoundary !== newErrorBoundary) {
+        __vormaClientGlobal.set(
+          "activeErrorBoundary",
+          newErrorBoundary
+        );
+      }
+    }
+  }
+};
+
+// internal/framework/_typescript/client/src/utils/logging.ts
+function logInfo(message, ...optionalParams) {
+  console.log("Vorma:", message, ...optionalParams);
+}
+function logError(message, ...optionalParams) {
+  console.error("Vorma:", message, ...optionalParams);
+}
+
+// internal/framework/_typescript/client/src/utils/errors.ts
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+function panic(msg) {
+  logError("Panic");
+  throw new Error(msg ?? "panic");
+}
+
+// internal/framework/_typescript/client/src/client_loaders.ts
+function setClientLoadersState(clr) {
+  if (clr) {
+    __vormaClientGlobal.set("clientLoadersData", clr.data ?? []);
+    __vormaClientGlobal.set(
+      "outermostClientErrorIdx",
+      clr.errorMessage ? clr.data.length - 1 : void 0
+    );
+    __vormaClientGlobal.set("outermostClientError", clr.errorMessage);
+  }
+}
+function deriveAndSetErrorState() {
+  const effectiveErrData = getEffectiveErrorData();
+  __vormaClientGlobal.set("outermostErrorIdx", effectiveErrData.index);
+  __vormaClientGlobal.set("outermostError", effectiveErrData.error);
+}
+async function setupClientLoaders() {
+  const clientLoadersResult = await runWaitFns(
+    {
+      hasRootData: __vormaClientGlobal.get("hasRootData"),
+      importURLs: __vormaClientGlobal.get("importURLs"),
+      loadersData: __vormaClientGlobal.get("loadersData"),
+      matchedPatterns: __vormaClientGlobal.get("matchedPatterns"),
+      params: __vormaClientGlobal.get("params"),
+      splatValues: __vormaClientGlobal.get("splatValues")
+    },
+    __vormaClientGlobal.get("buildID"),
+    new AbortController().signal
+  );
+  setClientLoadersState(clientLoadersResult);
+  deriveAndSetErrorState();
+}
+async function __registerClientLoaderPattern(pattern) {
+  registerPattern(__vormaClientGlobal.get("patternRegistry"), pattern);
+}
+async function findPartialMatchesOnClient(pathname) {
+  const patternToWaitFnMap = __vormaClientGlobal.get("patternToWaitFnMap");
+  if (Object.keys(patternToWaitFnMap).length === 0) {
+    return null;
+  }
+  const patternRegistry = __vormaClientGlobal.get("patternRegistry");
+  const fullResult = findNestedMatches(patternRegistry, pathname);
+  if (fullResult) {
+    return fullResult;
+  }
+  const segments = pathname.split("/").filter(Boolean);
+  for (let i = segments.length; i >= 0; i--) {
+    const partialPath = i === 0 ? "/" : "/" + segments.slice(0, i).join("/");
+    const result = findNestedMatches(patternRegistry, partialPath);
+    if (result) {
+      return result;
+    }
+  }
+  return null;
+}
+async function executeClientLoaders(json, buildID, signal, runningLoaders) {
+  await ComponentLoader.loadComponents(json.importURLs);
+  const matchedPatterns = json.matchedPatterns ?? [];
+  const patternToWaitFnMap = __vormaClientGlobal.get("patternToWaitFnMap");
+  const outermostServerErrorIdx = __vormaClientGlobal.get(
+    "outermostServerErrorIdx"
+  );
+  const loaderPromises = [];
+  const abortControllers = [];
+  let i = 0;
+  for (const pattern of matchedPatterns) {
+    if (outermostServerErrorIdx !== void 0 && i === outermostServerErrorIdx) {
+      loaderPromises.push(Promise.resolve());
+      abortControllers.push(null);
+      i++;
+      continue;
+    }
+    if (runningLoaders?.has(pattern)) {
+      loaderPromises.push(runningLoaders.get(pattern));
+      abortControllers.push(null);
+    } else if (patternToWaitFnMap[pattern]) {
+      const controller = new AbortController();
+      abortControllers.push(controller);
+      if (signal.aborted) {
+        controller.abort();
+      } else {
+        signal.addEventListener("abort", () => controller.abort(), {
+          once: true
+        });
+      }
+      const serverDataPromise = Promise.resolve({
+        matchedPatterns: json.matchedPatterns,
+        loaderData: json.loadersData[i],
+        rootData: json.hasRootData ? json.loadersData[0] : null,
+        buildID
+      });
+      const loaderPromise = patternToWaitFnMap[pattern]({
+        params: json.params || {},
+        splatValues: json.splatValues || [],
+        serverDataPromise,
+        signal: controller.signal
+      });
+      loaderPromises.push(loaderPromise);
+    } else {
+      loaderPromises.push(Promise.resolve());
+      abortControllers.push(null);
+    }
+    i++;
+  }
+  const wrappedPromises = loaderPromises.map(async (promise, index) => {
+    return promise.catch((error) => {
+      if (!isAbortError(error)) {
+        for (let j = index + 1; j < abortControllers.length; j++) {
+          abortControllers[j]?.abort();
+        }
+      }
+      throw error;
+    });
+  });
+  const results = await Promise.allSettled(wrappedPromises);
+  const data = [];
+  let errorMessage;
+  for (let i2 = 0; i2 < results.length; i2++) {
+    const result = results[i2];
+    if (!result) {
+      data.push(void 0);
+      continue;
+    }
+    if (result.status === "fulfilled") {
+      data.push(result.value);
+    } else {
+      if (!isAbortError(result.reason)) {
+        const pattern = matchedPatterns[i2];
+        logError(
+          `Client loader error for pattern ${pattern}:`,
+          result.reason
+        );
+        errorMessage = result.reason instanceof Error ? result.reason.message : String(result.reason);
+      }
+      data.push(void 0);
+      break;
+    }
+  }
+  return { data, errorMessage };
+}
+async function runWaitFns(json, buildID, signal) {
+  return executeClientLoaders(json, buildID, signal);
+}
+async function completeClientLoaders(json, buildID, runningLoaders, signal) {
+  return executeClientLoaders(json, buildID, signal, runningLoaders);
+}
+
+// internal/framework/_typescript/client/src/events.ts
+var VORMA_ROUTE_CHANGE_EVENT_KEY = "vorma:route-change";
+var addRouteChangeListener = makeListenerAdder(
+  VORMA_ROUTE_CHANGE_EVENT_KEY
+);
+function dispatchRouteChangeEvent(detail) {
+  window.dispatchEvent(
+    new CustomEvent(VORMA_ROUTE_CHANGE_EVENT_KEY, { detail })
+  );
+}
+var STATUS_EVENT_KEY = "vorma:status";
+function dispatchStatusEvent(detail) {
+  window.dispatchEvent(new CustomEvent(STATUS_EVENT_KEY, { detail }));
+}
+var addStatusListener = makeListenerAdder(STATUS_EVENT_KEY);
+var BUILD_ID_EVENT_KEY = "vorma:build-id";
+function dispatchBuildIDEvent(detail) {
+  window.dispatchEvent(new CustomEvent(BUILD_ID_EVENT_KEY, { detail }));
+}
+var addBuildIDListener = makeListenerAdder(BUILD_ID_EVENT_KEY);
+var LOCATION_EVENT_KEY = "vorma:location";
+function dispatchLocationEvent() {
+  window.dispatchEvent(new CustomEvent(LOCATION_EVENT_KEY));
+}
+var addLocationListener = makeListenerAdder(LOCATION_EVENT_KEY);
+function makeListenerAdder(key) {
+  return function addListener(listener) {
+    window.addEventListener(key, listener);
+    return () => window.removeEventListener(key, listener);
+  };
+}
+
+// node_modules/@babel/runtime/helpers/esm/extends.js
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+
+// node_modules/history/index.js
+var Action;
+(function(Action2) {
+  Action2["Pop"] = "POP";
+  Action2["Push"] = "PUSH";
+  Action2["Replace"] = "REPLACE";
+})(Action || (Action = {}));
+var readOnly = true ? function(obj) {
+  return Object.freeze(obj);
+} : function(obj) {
+  return obj;
+};
+function warning(cond, message) {
+  if (!cond) {
+    if (typeof console !== "undefined") console.warn(message);
+    try {
+      throw new Error(message);
+    } catch (e) {
+    }
+  }
+}
+var BeforeUnloadEventType = "beforeunload";
+var PopStateEventType = "popstate";
+function createBrowserHistory(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var _options = options, _options$window = _options.window, window2 = _options$window === void 0 ? document.defaultView : _options$window;
+  var globalHistory = window2.history;
+  function getIndexAndLocation() {
+    var _window$location = window2.location, pathname = _window$location.pathname, search = _window$location.search, hash = _window$location.hash;
+    var state = globalHistory.state || {};
+    return [state.idx, readOnly({
+      pathname,
+      search,
+      hash,
+      state: state.usr || null,
+      key: state.key || "default"
+    })];
+  }
+  var blockedPopTx = null;
+  function handlePop() {
+    if (blockedPopTx) {
+      blockers.call(blockedPopTx);
+      blockedPopTx = null;
+    } else {
+      var nextAction = Action.Pop;
+      var _getIndexAndLocation = getIndexAndLocation(), nextIndex = _getIndexAndLocation[0], nextLocation = _getIndexAndLocation[1];
+      if (blockers.length) {
+        if (nextIndex != null) {
+          var delta = index - nextIndex;
+          if (delta) {
+            blockedPopTx = {
+              action: nextAction,
+              location: nextLocation,
+              retry: function retry() {
+                go(delta * -1);
+              }
+            };
+            go(delta);
+          }
+        } else {
+          true ? warning(
+            false,
+            // TODO: Write up a doc that explains our blocking strategy in
+            // detail and link to it here so people can understand better what
+            // is going on and how to avoid it.
+            "You are trying to block a POP navigation to a location that was not created by the history library. The block will fail silently in production, but in general you should do all navigation with the history library (instead of using window.history.pushState directly) to avoid this situation."
+          ) : void 0;
+        }
+      } else {
+        applyTx(nextAction);
+      }
+    }
+  }
+  window2.addEventListener(PopStateEventType, handlePop);
+  var action = Action.Pop;
+  var _getIndexAndLocation2 = getIndexAndLocation(), index = _getIndexAndLocation2[0], location2 = _getIndexAndLocation2[1];
+  var listeners = createEvents();
+  var blockers = createEvents();
+  if (index == null) {
+    index = 0;
+    globalHistory.replaceState(_extends({}, globalHistory.state, {
+      idx: index
+    }), "");
+  }
+  function createHref(to) {
+    return typeof to === "string" ? to : createPath(to);
+  }
+  function getNextLocation(to, state) {
+    if (state === void 0) {
+      state = null;
+    }
+    return readOnly(_extends({
+      pathname: location2.pathname,
+      hash: "",
+      search: ""
+    }, typeof to === "string" ? parsePath(to) : to, {
+      state,
+      key: createKey()
+    }));
+  }
+  function getHistoryStateAndUrl(nextLocation, index2) {
+    return [{
+      usr: nextLocation.state,
+      key: nextLocation.key,
+      idx: index2
+    }, createHref(nextLocation)];
+  }
+  function allowTx(action2, location3, retry) {
+    return !blockers.length || (blockers.call({
+      action: action2,
+      location: location3,
+      retry
+    }), false);
+  }
+  function applyTx(nextAction) {
+    action = nextAction;
+    var _getIndexAndLocation3 = getIndexAndLocation();
+    index = _getIndexAndLocation3[0];
+    location2 = _getIndexAndLocation3[1];
+    listeners.call({
+      action,
+      location: location2
+    });
+  }
+  function push(to, state) {
+    var nextAction = Action.Push;
+    var nextLocation = getNextLocation(to, state);
+    function retry() {
+      push(to, state);
+    }
+    if (allowTx(nextAction, nextLocation, retry)) {
+      var _getHistoryStateAndUr = getHistoryStateAndUrl(nextLocation, index + 1), historyState = _getHistoryStateAndUr[0], url = _getHistoryStateAndUr[1];
+      try {
+        globalHistory.pushState(historyState, "", url);
+      } catch (error) {
+        window2.location.assign(url);
+      }
+      applyTx(nextAction);
+    }
+  }
+  function replace(to, state) {
+    var nextAction = Action.Replace;
+    var nextLocation = getNextLocation(to, state);
+    function retry() {
+      replace(to, state);
+    }
+    if (allowTx(nextAction, nextLocation, retry)) {
+      var _getHistoryStateAndUr2 = getHistoryStateAndUrl(nextLocation, index), historyState = _getHistoryStateAndUr2[0], url = _getHistoryStateAndUr2[1];
+      globalHistory.replaceState(historyState, "", url);
+      applyTx(nextAction);
+    }
+  }
+  function go(delta) {
+    globalHistory.go(delta);
+  }
+  var history2 = {
+    get action() {
+      return action;
+    },
+    get location() {
+      return location2;
+    },
+    createHref,
+    push,
+    replace,
+    go,
+    back: function back() {
+      go(-1);
+    },
+    forward: function forward() {
+      go(1);
+    },
+    listen: function listen(listener) {
+      return listeners.push(listener);
+    },
+    block: function block(blocker) {
+      var unblock = blockers.push(blocker);
+      if (blockers.length === 1) {
+        window2.addEventListener(BeforeUnloadEventType, promptBeforeUnload);
+      }
+      return function() {
+        unblock();
+        if (!blockers.length) {
+          window2.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);
+        }
+      };
+    }
+  };
+  return history2;
+}
+function promptBeforeUnload(event) {
+  event.preventDefault();
+  event.returnValue = "";
+}
+function createEvents() {
+  var handlers = [];
+  return {
+    get length() {
+      return handlers.length;
+    },
+    push: function push(fn) {
+      handlers.push(fn);
+      return function() {
+        handlers = handlers.filter(function(handler) {
+          return handler !== fn;
+        });
+      };
+    },
+    call: function call(arg) {
+      handlers.forEach(function(fn) {
+        return fn && fn(arg);
+      });
+    }
+  };
+}
+function createKey() {
+  return Math.random().toString(36).substr(2, 8);
+}
+function createPath(_ref) {
+  var _ref$pathname = _ref.pathname, pathname = _ref$pathname === void 0 ? "/" : _ref$pathname, _ref$search = _ref.search, search = _ref$search === void 0 ? "" : _ref$search, _ref$hash = _ref.hash, hash = _ref$hash === void 0 ? "" : _ref$hash;
+  if (search && search !== "?") pathname += search.charAt(0) === "?" ? search : "?" + search;
+  if (hash && hash !== "#") pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
+  return pathname;
+}
+function parsePath(path) {
+  var parsedPath = {};
+  if (path) {
+    var hashIndex = path.indexOf("#");
+    if (hashIndex >= 0) {
+      parsedPath.hash = path.substr(hashIndex);
+      path = path.substr(0, hashIndex);
+    }
+    var searchIndex = path.indexOf("?");
+    if (searchIndex >= 0) {
+      parsedPath.search = path.substr(searchIndex);
+      path = path.substr(0, searchIndex);
+    }
+    if (path) {
+      parsedPath.pathname = path;
+    }
+  }
+  return parsedPath;
+}
+
+// internal/framework/_typescript/client/src/scroll_state_manager.ts
+var ScrollStateManager = class {
+  STORAGE_KEY = "__vorma__scrollStateMap";
+  PAGE_REFRESH_KEY = "__vorma__pageRefreshScrollState";
+  MAX_ENTRIES = 50;
+  saveState(key, state) {
+    const map = this.getMap();
+    map.set(key, state);
+    if (map.size > this.MAX_ENTRIES) {
+      const firstKey = map.keys().next().value;
+      if (firstKey) map.delete(firstKey);
+    }
+    this.saveMap(map);
+  }
+  getState(key) {
+    return this.getMap().get(key);
+  }
+  savePageRefreshState() {
+    const state = {
+      x: window.scrollX,
+      y: window.scrollY,
+      unix: Date.now(),
+      href: window.location.href
+    };
+    sessionStorage.setItem(this.PAGE_REFRESH_KEY, JSON.stringify(state));
+  }
+  restorePageRefreshState() {
+    const stored = sessionStorage.getItem(this.PAGE_REFRESH_KEY);
+    if (!stored) return;
+    try {
+      const state = JSON.parse(stored);
+      if (state.href === window.location.href && Date.now() - state.unix < 5e3) {
+        sessionStorage.removeItem(this.PAGE_REFRESH_KEY);
+        window.requestAnimationFrame(() => {
+          __applyScrollState({ x: state.x, y: state.y });
+        });
+      }
+    } catch {
+    }
+  }
+  getMap() {
+    const stored = sessionStorage.getItem(this.STORAGE_KEY);
+    if (!stored) return /* @__PURE__ */ new Map();
+    try {
+      return new Map(JSON.parse(stored));
+    } catch {
+      return /* @__PURE__ */ new Map();
+    }
+  }
+  saveMap(map) {
+    sessionStorage.setItem(
+      this.STORAGE_KEY,
+      JSON.stringify(Array.from(map.entries()))
+    );
+  }
+};
+var scrollStateManager = new ScrollStateManager();
+function __applyScrollState(state) {
+  if (!state) {
+    const id = window.location.hash.slice(1);
+    if (id) {
+      document.getElementById(id)?.scrollIntoView();
+    }
+    return;
+  }
+  if ("hash" in state) {
+    if (state.hash) {
+      document.getElementById(state.hash)?.scrollIntoView();
+    }
+  } else {
+    window.scrollTo(state.x, state.y);
+  }
+}
+function saveScrollState() {
+  const lastKnownLocation = HistoryManager.getLastKnownLocation();
+  scrollStateManager.saveState(lastKnownLocation.key, {
+    x: window.scrollX,
+    y: window.scrollY
+  });
+}
+
+// internal/framework/_typescript/client/src/history/history.ts
+var HistoryManager = class {
+  static instance;
+  static lastKnownLocation;
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = createBrowserHistory();
+      this.lastKnownLocation = this.instance.location;
+    }
+    return this.instance;
+  }
+  static getLastKnownLocation() {
+    return this.lastKnownLocation;
+  }
+  static updateLastKnownLocation(location2) {
+    this.lastKnownLocation = location2;
+  }
+  static init() {
+    const instance = this.getInstance();
+    instance.listen(customHistoryListener);
+    this.setManualScrollRestoration();
+  }
+  static setManualScrollRestoration() {
+    if (history.scrollRestoration && history.scrollRestoration !== "manual") {
+      history.scrollRestoration = "manual";
+    }
+  }
+};
+async function customHistoryListener({
+  action,
+  location: location2
+}) {
+  const lastKnownLocation = HistoryManager.getLastKnownLocation();
+  if (location2.key !== lastKnownLocation.key) {
+    dispatchLocationEvent();
+  }
+  const popWithinSameDoc = action === "POP" && location2.pathname === lastKnownLocation.pathname && location2.search === lastKnownLocation.search;
+  const removingHash = popWithinSameDoc && lastKnownLocation.hash && !location2.hash;
+  const addingHash = popWithinSameDoc && !lastKnownLocation.hash && location2.hash;
+  const updatingHash = popWithinSameDoc && location2.hash;
+  if (!popWithinSameDoc) {
+    saveScrollState();
+  }
+  let navigationSucceeded = true;
+  if (action === "POP") {
+    const newHash = location2.hash.slice(1);
+    if (addingHash || updatingHash) {
+      __applyScrollState({ hash: newHash });
+    }
+    if (removingHash) {
+      const stored = scrollStateManager.getState(location2.key);
+      __applyScrollState(stored ?? { x: 0, y: 0 });
+    }
+    if (!popWithinSameDoc) {
+      const result = await navigationStateManager.navigate({
+        href: window.location.href,
+        navigationType: "browserHistory",
+        scrollStateToRestore: scrollStateManager.getState(location2.key)
+      });
+      if (!result.didNavigate) {
+        navigationSucceeded = false;
+        logError(
+          "Browser POP navigation failed, attempting hard reload of the destination."
+        );
+        window.location.reload();
+      }
+    }
+  }
+  if (navigationSucceeded) {
+    HistoryManager.updateLastKnownLocation(location2);
+  }
+}
+
+// internal/framework/_typescript/client/src/redirects/redirects.ts
+import {
+  getHrefDetails,
+  getIsGETRequest
+} from "vorma/kit/url";
+
+// internal/framework/_typescript/client/src/hard_reload.ts
+var VORMA_HARD_RELOAD_QUERY_PARAM = "vorma_reload";
+
+// internal/framework/_typescript/client/src/redirects/redirects.ts
+function getBuildIDFromResponse(response) {
+  return response?.headers.get("X-Vorma-Build-Id") || "";
+}
+function parseFetchResponseForRedirectData(reqInit, res) {
+  const latestBuildID = getBuildIDFromResponse(res);
+  const vormaReloadTarget = res.headers.get("X-Vorma-Reload");
+  if (vormaReloadTarget) {
+    const newURL2 = new URL(vormaReloadTarget, window.location.href);
+    const hrefDetails2 = getHrefDetails(newURL2.href);
+    if (!hrefDetails2.isHTTP) {
+      return null;
+    }
+    return {
+      hrefDetails: hrefDetails2,
+      status: "should",
+      href: vormaReloadTarget,
+      shouldRedirectStrategy: "hard",
+      latestBuildID
+    };
+  }
+  if (res.redirected) {
+    const newURL2 = new URL(res.url, window.location.href);
+    const hrefDetails2 = getHrefDetails(newURL2.href);
+    if (!hrefDetails2.isHTTP) {
+      return null;
+    }
+    const isCurrent = newURL2.href === window.location.href;
+    if (isCurrent) {
+      return { hrefDetails: hrefDetails2, status: "did", href: newURL2.href };
+    }
+    const wasGETRequest = getIsGETRequest(reqInit);
+    if (!wasGETRequest) {
+      logInfo("Not a GET request. No way to handle.");
+      return null;
+    }
+    return {
+      hrefDetails: hrefDetails2,
+      status: "should",
+      href: newURL2.href,
+      shouldRedirectStrategy: hrefDetails2.isInternal ? "soft" : "hard",
+      latestBuildID
+    };
+  }
+  const clientRedirectHeader = res.headers.get("X-Client-Redirect");
+  if (!clientRedirectHeader) {
+    return null;
+  }
+  const newURL = new URL(clientRedirectHeader, window.location.href);
+  const hrefDetails = getHrefDetails(newURL.href);
+  if (!hrefDetails.isHTTP) {
+    return null;
+  }
+  return {
+    hrefDetails,
+    status: "should",
+    href: hrefDetails.absoluteURL,
+    shouldRedirectStrategy: hrefDetails.isInternal ? "soft" : "hard",
+    latestBuildID
+  };
+}
+async function effectuateRedirectDataResult(redirectData, redirectCount, originalProps) {
+  if (redirectData.status !== "should") {
+    return null;
+  }
+  const navEntries = navigationStateManager.getNavigations().entries();
+  for (const [key, nav] of navEntries) {
+    if (nav.type === "redirect" || nav.type === "revalidation") {
+      nav.control.abortController?.abort();
+      navigationStateManager.removeNavigation(key);
+    }
+  }
+  if (redirectData.shouldRedirectStrategy === "hard") {
+    if (!redirectData.hrefDetails.isHTTP) return null;
+    if (redirectData.hrefDetails.isExternal) {
+      window.location.href = redirectData.href;
+    } else {
+      const url = new URL(redirectData.href, window.location.href);
+      url.searchParams.set(
+        VORMA_HARD_RELOAD_QUERY_PARAM,
+        redirectData.latestBuildID
+      );
+      window.location.href = url.href;
+    }
+    return {
+      hrefDetails: redirectData.hrefDetails,
+      status: "did",
+      href: redirectData.href
+    };
+  }
+  if (redirectData.shouldRedirectStrategy === "soft") {
+    await navigationStateManager.navigate({
+      href: redirectData.href,
+      navigationType: "redirect",
+      redirectCount: redirectCount + 1,
+      state: originalProps?.state,
+      replace: originalProps?.replace,
+      scrollToTop: originalProps?.scrollToTop
+    });
+    return {
+      hrefDetails: redirectData.hrefDetails,
+      status: "did",
+      href: redirectData.href
+    };
+  }
+  return null;
+}
+async function handleRedirects(props) {
+  const MAX_REDIRECTS = 10;
+  const redirectCount = props.redirectCount || 0;
+  if (redirectCount >= MAX_REDIRECTS) {
+    logError("Too many redirects");
+    return { redirectData: null, response: void 0 };
+  }
+  const bodyParentObj = {};
+  const isGET = getIsGETRequest(props.requestInit);
+  if (props.requestInit && (props.requestInit.body !== void 0 || !isGET)) {
+    if (props.requestInit.body instanceof FormData || typeof props.requestInit.body === "string") {
+      bodyParentObj.body = props.requestInit.body;
+    } else {
+      bodyParentObj.body = JSON.stringify(props.requestInit.body);
+    }
+  }
+  const headers = new Headers(props.requestInit?.headers);
+  headers.set("X-Accepts-Client-Redirect", "1");
+  bodyParentObj.headers = headers;
+  const finalRequestInit = {
+    signal: props.abortController.signal,
+    ...props.requestInit,
+    ...bodyParentObj
+  };
+  const res = await fetch(props.url, finalRequestInit);
+  let redirectData = parseFetchResponseForRedirectData(finalRequestInit, res);
+  return { redirectData, response: res };
+}
+
+// internal/framework/_typescript/client/src/head_elements/head_elements.ts
+function getStartAndEndComments(type) {
+  const startMarker = `data-vorma="${type}-start"`;
+  const endMarker = `data-vorma="${type}-end"`;
+  const start = findComment(startMarker);
+  const end = findComment(endMarker);
+  return { startComment: start, endComment: end };
+}
+function findComment(matchingText) {
+  const walker = document.createTreeWalker(
+    document.head,
+    NodeFilter.SHOW_COMMENT,
+    {
+      acceptNode(node) {
+        return node.nodeValue?.trim() === matchingText.trim() ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+      }
+    }
+  );
+  return walker.nextNode();
+}
+function updateHeadEls(type, blocks) {
+  const { startComment, endComment } = getStartAndEndComments(type);
+  if (!startComment || !endComment || !endComment.parentNode) {
+    return;
+  }
+  const parent = endComment.parentNode;
+  const currentNodes = [];
+  let nodePtr = startComment.nextSibling;
+  while (nodePtr != null && nodePtr !== endComment) {
+    currentNodes.push(nodePtr);
+    nodePtr = nodePtr.nextSibling;
+  }
+  const currentElements = currentNodes.filter(
+    (node) => node.nodeType === Node.ELEMENT_NODE
+  );
+  const newElements = [];
+  const newElementFingerprints = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    if (!block.tag) {
+      continue;
+    }
+    const newEl = document.createElement(block.tag);
+    if (block.attributesKnownSafe) {
+      for (const key of Object.keys(block.attributesKnownSafe)) {
+        const value = block.attributesKnownSafe[key];
+        if (value === null || value === void 0) {
+          panic(
+            `Attribute value for '${key}' in tag '${block.tag}' cannot be null or undefined.`
+          );
+        }
+        newEl.setAttribute(key, value);
+      }
+    }
+    if (block.booleanAttributes) {
+      for (const key of block.booleanAttributes) {
+        newEl.setAttribute(key, "");
+      }
+    }
+    if (block.dangerousInnerHTML) {
+      newEl.innerHTML = block.dangerousInnerHTML;
+    }
+    const fingerprint = createElementFingerprint(newEl);
+    if (newElementFingerprints.has(fingerprint)) {
+      const elementToRemove = newElementFingerprints.get(fingerprint);
+      if (elementToRemove) {
+        const indexToRemove = newElements.indexOf(elementToRemove);
+        if (indexToRemove > -1) {
+          newElements.splice(indexToRemove, 1);
+        }
+      }
+    }
+    newElements.push(newEl);
+    newElementFingerprints.set(fingerprint, newEl);
+  }
+  const currentElementsMap = /* @__PURE__ */ new Map();
+  for (const el of currentElements) {
+    const fingerprint = createElementFingerprint(el);
+    if (!currentElementsMap.has(fingerprint)) {
+      currentElementsMap.set(fingerprint, []);
+    }
+    currentElementsMap.get(fingerprint)?.push(el);
+  }
+  const finalElements = [];
+  const usedCurrentElements = /* @__PURE__ */ new Set();
+  for (const newEl of newElements) {
+    const fingerprint = createElementFingerprint(newEl);
+    const matchingCurrentElementsList = currentElementsMap.get(fingerprint) || [];
+    const matchingElement = matchingCurrentElementsList.find(
+      (el) => !usedCurrentElements.has(el)
+    );
+    if (matchingElement) {
+      usedCurrentElements.add(matchingElement);
+      finalElements.push(matchingElement);
+    } else {
+      finalElements.push(newEl);
+    }
+  }
+  const desiredPositions = /* @__PURE__ */ new Map();
+  finalElements.forEach((el, index) => {
+    desiredPositions.set(el, index);
+  });
+  const remainingCurrentElements = new Set(currentElements);
+  for (const currentElement of currentElements) {
+    if (!usedCurrentElements.has(currentElement)) {
+      parent.removeChild(currentElement);
+      remainingCurrentElements.delete(currentElement);
+    }
+  }
+  let lastProcessedElement = null;
+  for (let i = 0; i < finalElements.length; i++) {
+    const element = finalElements[i];
+    if (!element) {
+      continue;
+    }
+    const isExistingElement = usedCurrentElements.has(element);
+    if (isExistingElement) {
+      const nextElementInDOM = lastProcessedElement ? lastProcessedElement.nextElementSibling : startComment.nextElementSibling;
+      if (nextElementInDOM !== element) {
+        parent.insertBefore(element, nextElementInDOM || endComment);
+      }
+      remainingCurrentElements.delete(element);
+      lastProcessedElement = element;
+    } else {
+      const insertBefore = lastProcessedElement ? lastProcessedElement.nextSibling : startComment.nextSibling;
+      parent.insertBefore(element, insertBefore || endComment);
+      lastProcessedElement = element;
+    }
+  }
+}
+function createElementFingerprint(element) {
+  const attributes = [];
+  for (let i = 0; i < element.attributes.length; i++) {
+    const attr = element.attributes[i];
+    if (!attr) {
+      continue;
+    }
+    const value = element.hasAttribute(attr.name) && attr.value === "" ? "" : attr.value;
+    attributes.push(`${attr.name}="${value}"`);
+  }
+  attributes.sort();
+  return `${element.tagName.toUpperCase()}|${attributes.join(",")}|${(element.innerHTML || "").trim()}`;
+}
+
+// internal/framework/_typescript/client/src/rendering.ts
+async function __reRenderApp(props) {
+  const shouldUseViewTransitions = __vormaClientGlobal.get("useViewTransitions") && !!document.startViewTransition && props.navigationType !== "prefetch" && props.navigationType !== "revalidation";
+  if (shouldUseViewTransitions) {
+    const transition = document.startViewTransition(async () => {
+      await __reRenderAppInner(props);
+    });
+    await transition.finished;
+  } else {
+    await __reRenderAppInner(props);
+  }
+}
+async function __reRenderAppInner(props) {
+  const { json, navigationType, runHistoryOptions } = props;
+  const stateKeys = [
+    "outermostServerError",
+    "outermostServerErrorIdx",
+    "errorExportKeys",
+    "matchedPatterns",
+    "loadersData",
+    "importURLs",
+    "exportKeys",
+    "hasRootData",
+    "params",
+    "splatValues"
+  ];
+  for (const key of stateKeys) {
+    __vormaClientGlobal.set(key, json[key]);
+  }
+  deriveAndSetErrorState();
+  await ComponentLoader.handleComponents(json.importURLs);
+  await ComponentLoader.handleErrorBoundaryComponent(json.importURLs);
+  let scrollStateToDispatch;
+  if (runHistoryOptions) {
+    const { href, scrollStateToRestore, replace, scrollToTop } = runHistoryOptions;
+    const hash = href.split("#")[1];
+    const history2 = HistoryManager.getInstance();
+    if (navigationType === "userNavigation" || navigationType === "redirect") {
+      const target = new URL(href, window.location.href).href;
+      const current = new URL(window.location.href).href;
+      if (target !== current && !replace) {
+        history2.push(href, runHistoryOptions.state);
+      } else {
+        history2.replace(href, runHistoryOptions.state);
+      }
+      scrollStateToDispatch = hash ? { hash } : scrollToTop !== false ? { x: 0, y: 0 } : void 0;
+    }
+    if (navigationType === "browserHistory") {
+      scrollStateToDispatch = scrollStateToRestore ?? (hash ? { hash } : void 0);
+    }
+  }
+  if (json.title !== void 0) {
+    const tempTxt = document.createElement("textarea");
+    tempTxt.innerHTML = json.title?.dangerousInnerHTML || "";
+    if (document.title !== tempTxt.value) {
+      document.title = tempTxt.value;
+    }
+  }
+  if (json.cssBundles) {
+    AssetManager.applyCSS(json.cssBundles);
+  }
+  dispatchRouteChangeEvent({ __scrollState: scrollStateToDispatch });
+  if (json.metaHeadEls !== void 0) {
+    updateHeadEls("meta", json.metaHeadEls ?? []);
+  }
+  if (json.restHeadEls !== void 0) {
+    updateHeadEls("rest", json.restHeadEls ?? []);
+  }
+  props.onFinish();
+}
+
+// internal/framework/_typescript/client/src/client.ts
+var NavigationStateManager = class {
+  _navigations = /* @__PURE__ */ new Map();
+  _submissions = /* @__PURE__ */ new Map();
+  lastDispatchedStatus = null;
+  dispatchStatusEventDebounced;
+  REVALIDATION_COALESCE_MS = 8;
+  constructor() {
+    this.dispatchStatusEventDebounced = debounce(() => {
+      this.dispatchStatusEvent();
+    }, 8);
+  }
+  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 };
+      }
+    } catch (error) {
+      const targetUrl = new URL(props.href, window.location.href).href;
+      this.deleteNavigation(targetUrl);
+      if (!isAbortError(error)) {
+        logError("Navigate error:", error);
+      }
+      return { didNavigate: false };
+    }
+    return { didNavigate: true };
+  }
+  beginNavigation(props) {
+    const existing = this._navigations.get(
+      new URL(props.href, window.location.href).href
+    );
+    switch (props.navigationType) {
+      case "userNavigation":
+        return this.beginUserNavigation(props, existing);
+      case "prefetch":
+        return this.beginPrefetch(props, existing);
+      case "revalidation":
+        return this.beginRevalidation(props);
+      case "browserHistory":
+      case "redirect":
+      default:
+        return this.createNavigation(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;
+      }
+      return existing.control;
+    }
+    return this.createNavigation(props, "navigate");
+  }
+  beginPrefetch(props, existing) {
+    const targetUrl = new URL(props.href, window.location.href).href;
+    if (existing) {
+      return existing.control;
+    }
+    const currentUrl = new URL(window.location.href);
+    const targetUrlObj = new URL(targetUrl);
+    currentUrl.hash = "";
+    targetUrlObj.hash = "";
+    if (currentUrl.href === targetUrlObj.href) {
+      return {
+        abortController: new AbortController(),
+        promise: Promise.resolve(void 0)
+      };
+    }
+    return this.createNavigation(props, "none");
+  }
+  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;
+    }
+    for (const [key, nav] of this._navigations.entries()) {
+      if (nav.type === "revalidation") {
+        nav.control.abortController?.abort();
+        this.deleteNavigation(key);
+      }
+    }
+    return this.createNavigation(
+      { ...props, href: currentUrl },
+      "revalidate"
+    );
+  }
+  createNavigation(props, intent) {
+    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) => {
+            this.deleteNavigation(targetUrl);
+            throw error;
+          }
+        )
+      },
+      type: props.navigationType,
+      intent,
+      phase: "fetching",
+      startTime: Date.now(),
+      targetUrl,
+      originUrl: window.location.href,
+      scrollToTop: props.scrollToTop,
+      replace: props.replace,
+      state: props.state
+    };
+    this.setNavigation(targetUrl, entry);
+    return entry.control;
+  }
+  upgradeNavigation(href, updates) {
+    const existing = this._navigations.get(href);
+    if (!existing) return;
+    this.setNavigation(href, {
+      ...existing,
+      ...updates
+    });
+  }
+  transitionPhase(href, phase) {
+    const existing = this._navigations.get(href);
+    if (!existing) return;
+    this.setNavigation(href, {
+      ...existing,
+      phase
+    });
+  }
+  canSkipServerFetch(targetUrl) {
+    const routeManifest = __vormaClientGlobal.get("routeManifest");
+    if (!routeManifest) {
+      return { canSkip: false };
+    }
+    const patternRegistry = __vormaClientGlobal.get("patternRegistry");
+    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 };
+      }
+    }
+    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) {
+      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 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]);
+      }
+    }
+    return {
+      canSkip: true,
+      matchResult,
+      importURLs,
+      exportKeys,
+      loadersData
+    };
+  }
+  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,
+            props,
+            json: json2,
+            cssBundlePromises: [],
+            waitFnPromise: waitFnPromise2
+          };
+        }
+      }
+      url.searchParams.set(
+        "vorma_json",
+        __vormaClientGlobal.get("buildID") || "1"
+      );
+      if (props.navigationType === "revalidation") {
+        const deploymentID = __vormaClientGlobal.get("deploymentID");
+        if (deploymentID) {
+          url.searchParams.set("dpl", deploymentID);
+        }
+      }
+      const serverPromise = handleRedirects({
+        abortController: controller,
+        url,
+        isPrefetch: props.navigationType === "prefetch",
+        redirectCount: props.redirectCount
+      }).then(async (result) => {
+        if (result.response && result.response.ok && !result.redirectData?.status) {
+          const json2 = await result.response.json();
+          return { ...result, json: json2 };
+        }
+        return { ...result, json: void 0 };
+      });
+      const pathname = url.pathname;
+      const matchResult = await findPartialMatchesOnClient(pathname);
+      const patternToWaitFnMap = __vormaClientGlobal.get("patternToWaitFnMap");
+      const runningLoaders = /* @__PURE__ */ new Map();
+      if (matchResult) {
+        const { params, splatValues, matches } = matchResult;
+        for (let i = 0; i < matches.length; i++) {
+          const match = matches[i];
+          if (!match) continue;
+          const pattern = match.registeredPattern.originalPattern;
+          const loaderFn = patternToWaitFnMap[pattern];
+          if (loaderFn) {
+            const serverDataPromise = serverPromise.then(
+              ({
+                response: response2,
+                json: json2
+              }) => {
+                if (!response2 || !response2.ok || !json2) {
+                  return {
+                    matchedPatterns: [],
+                    loaderData: void 0,
+                    rootData: null,
+                    buildID: "1"
+                  };
+                }
+                const serverIdx = json2.matchedPatterns?.indexOf(pattern);
+                const loaderData = serverIdx !== -1 && serverIdx !== void 0 ? json2.loadersData[serverIdx] : void 0;
+                const rootData = json2.hasRootData ? json2.loadersData[0] : null;
+                const buildID2 = getBuildIDFromResponse(response2) || "1";
+                return {
+                  matchedPatterns: json2.matchedPatterns || [],
+                  loaderData,
+                  rootData,
+                  buildID: buildID2
+                };
+              }
+            ).catch(() => ({
+              matchedPatterns: [],
+              loaderData: void 0,
+              rootData: null,
+              buildID: "1"
+            }));
+            const loaderPromise = loaderFn({
+              params,
+              splatValues,
+              serverDataPromise,
+              signal: controller.signal
+            });
+            runningLoaders.set(pattern, loaderPromise);
+          }
+        }
+      }
+      const { redirectData, response, json } = await serverPromise;
+      const redirected = redirectData?.status === "did";
+      const responseNotOK = !response?.ok && response?.status !== 304;
+      if (redirected || !response) {
+        controller.abort();
+        return void 0;
+      }
+      if (responseNotOK) {
+        controller.abort();
+        throw new Error(`Fetch failed with status ${response.status}`);
+      }
+      if (redirectData?.status === "should") {
+        controller.abort();
+        return { response, redirectData, props };
+      }
+      if (!json) {
+        controller.abort();
+        throw new Error("No JSON response");
+      }
+      const depsToPreload = import.meta.env.DEV ? [...new Set(json.importURLs)] : json.deps;
+      for (const dep of depsToPreload ?? []) {
+        if (dep) AssetManager.preloadModule(dep);
+      }
+      const buildID = getBuildIDFromResponse(response);
+      const waitFnPromise = completeClientLoaders(
+        json,
+        buildID,
+        runningLoaders,
+        controller.signal
+      );
+      const cssBundlePromises = [];
+      for (const bundle of json.cssBundles ?? []) {
+        cssBundlePromises.push(AssetManager.preloadCSS(bundle));
+      }
+      return { response, json, props, cssBundlePromises, waitFnPromise };
+    } catch (error) {
+      if (!isAbortError(error)) {
+        logError("Navigation failed", error);
+      }
+      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;
+      }
+      if (!("json" in result)) {
+        logError("Invalid navigation result: no JSON or redirect");
+        return;
+      }
+      const currentBuildID = __vormaClientGlobal.get("buildID");
+      const responseBuildID = getBuildIDFromResponse(result.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 || [];
+        for (let i = 0; i < matchedPatterns.length; i++) {
+          const pattern = matchedPatterns[i];
+          const importURL = importURLs[i];
+          const exportKey = exportKeys[i];
+          const errorExportKey = errorExportKeys[i];
+          if (pattern && importURL) {
+            clientModuleMap[pattern] = {
+              importURL,
+              exportKey: exportKey || "default",
+              errorExportKey: errorExportKey || ""
+            };
+          }
+        }
+        __vormaClientGlobal.set("clientModuleMap", clientModuleMap);
+        if (result.json.cssBundles && result.json.cssBundles.length > 0) {
+          AssetManager.applyCSS(result.json.cssBundles);
+        }
+      }
+      if (entry.type === "revalidation") {
+        const currentUrl = window.location.href;
+        if (currentUrl !== entry.originUrl) {
+          this.deleteNavigation(entry.targetUrl);
+          return;
+        }
+      }
+      this.transitionPhase(entry.targetUrl, "waiting");
+      if (!this._navigations.has(entry.targetUrl)) {
+        return;
+      }
+      const oldID = __vormaClientGlobal.get("buildID");
+      const newID = getBuildIDFromResponse(result.response);
+      if (newID && newID !== oldID) {
+        dispatchBuildIDEvent({ newID, oldID });
+      }
+      const clientLoadersResult = await result.waitFnPromise;
+      setClientLoadersState(clientLoadersResult);
+      if (result.cssBundlePromises.length > 0) {
+        try {
+          await Promise.all(result.cssBundlePromises);
+        } catch (error) {
+          logError("Error preloading CSS bundles:", error);
+        }
+      }
+      if (entry.intent === "none") {
+        this.transitionPhase(entry.targetUrl, "complete");
+        return;
+      }
+      if (entry.type === "revalidation" && window.location.href !== entry.originUrl) {
+        return;
+      }
+      this.transitionPhase(entry.targetUrl, "rendering");
+      try {
+        await __reRenderApp({
+          json: result.json,
+          navigationType: entry.type,
+          runHistoryOptions: entry.intent === "navigate" ? {
+            href: entry.targetUrl,
+            scrollStateToRestore: result.props.scrollStateToRestore,
+            replace: entry.replace || result.props.replace,
+            scrollToTop: entry.scrollToTop,
+            state: entry.state
+          } : void 0,
+          onFinish: () => {
+            this.transitionPhase(entry.targetUrl, "complete");
+          }
+        });
+      } catch (error) {
+        this.transitionPhase(entry.targetUrl, "complete");
+        if (!isAbortError(error)) {
+          logError("Error completing navigation", error);
+        }
+        throw error;
+      }
+    } finally {
+      if (!(entry.type === "prefetch" && entry.intent === "none")) {
+        this.deleteNavigation(entry.targetUrl);
+      }
+    }
+  }
+  async submit(url, requestInit, options) {
+    const abortController = new AbortController();
+    const submissionKey = options?.dedupeKey ? `submission:${options.dedupeKey}` : Symbol("submission");
+    if (typeof submissionKey === "string") {
+      const existing = this._submissions.get(submissionKey);
+      if (existing) {
+        existing.control.abortController?.abort("deduped");
+      }
+    }
+    const entry = {
+      control: {
+        abortController,
+        promise: Promise.resolve()
+      },
+      startTime: Date.now(),
+      skipGlobalLoadingIndicator: options?.skipGlobalLoadingIndicator
+    };
+    this._submissions.set(submissionKey, entry);
+    this.scheduleStatusUpdate();
+    try {
+      const urlToUse = new URL(url, window.location.href);
+      const headers = new Headers(requestInit?.headers);
+      const deploymentID = __vormaClientGlobal.get("deploymentID");
+      if (deploymentID) {
+        headers.set("x-deployment-id", deploymentID);
+      }
+      const finalRequestInit = {
+        ...requestInit,
+        headers,
+        signal: abortController.signal
+      };
+      const { redirectData, response } = await handleRedirects({
+        abortController,
+        url: urlToUse,
+        isPrefetch: false,
+        redirectCount: 0,
+        requestInit: finalRequestInit
+      });
+      const oldID = __vormaClientGlobal.get("buildID");
+      const newID = getBuildIDFromResponse(response);
+      if (newID && newID !== oldID) {
+        dispatchBuildIDEvent({ newID, oldID });
+      }
+      if (!response || !response.ok) {
+        return {
+          success: false,
+          error: String(response?.status || "unknown")
+        };
+      }
+      if (redirectData?.status === "should") {
+        await effectuateRedirectDataResult(redirectData, 0);
+        return { success: true, data: void 0 };
+      }
+      const data = await response.json();
+      const isGET = getIsGETRequest2(requestInit);
+      const redirected = redirectData?.status === "did";
+      if (!isGET && !redirected && options?.revalidate !== false) {
+        await revalidate();
+      }
+      return { success: true, data };
+    } catch (error) {
+      if (isAbortError(error)) {
+        return { success: false, error: "Aborted" };
+      }
+      logError(error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    } finally {
+      this._submissions.delete(submissionKey);
+      this.scheduleStatusUpdate();
+    }
+  }
+  setNavigation(key, entry) {
+    this._navigations.set(key, entry);
+    this.scheduleStatusUpdate();
+  }
+  deleteNavigation(key) {
+    const result = this._navigations.delete(key);
+    if (result) {
+      this.scheduleStatusUpdate();
+    }
+    return result;
+  }
+  removeNavigation(key) {
+    this.deleteNavigation(key);
+  }
+  getNavigation(key) {
+    return this._navigations.get(key);
+  }
+  hasNavigation(key) {
+    return this._navigations.has(key);
+  }
+  getNavigationsSize() {
+    return this._navigations.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);
+      }
+    }
+  }
+  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(
+      (x) => !x.skipGlobalLoadingIndicator
+    );
+    return { isNavigating, isSubmitting, isRevalidating };
+  }
+  clearAll() {
+    for (const nav of this._navigations.values()) {
+      nav.control.abortController?.abort();
+    }
+    this._navigations.clear();
+    for (const sub of this._submissions.values()) {
+      sub.control.abortController?.abort();
+    }
+    this._submissions.clear();
+    this.scheduleStatusUpdate();
+  }
+  scheduleStatusUpdate() {
+    this.dispatchStatusEventDebounced();
+  }
+  dispatchStatusEvent() {
+    const newStatus = this.getStatus();
+    if (jsonDeepEquals2(this.lastDispatchedStatus, newStatus)) {
+      return;
+    }
+    this.lastDispatchedStatus = newStatus;
+    dispatchStatusEvent(newStatus);
+  }
+};
+var navigationStateManager = new NavigationStateManager();
+async function vormaNavigate(href, options) {
+  const url = new URL(href, window.location.href);
+  if (options?.search !== void 0) {
+    url.search = options.search;
+  }
+  if (options?.hash !== void 0) {
+    url.hash = options.hash;
+  }
+  await navigationStateManager.navigate({
+    href: url.href,
+    navigationType: "userNavigation",
+    replace: options?.replace,
+    scrollToTop: options?.scrollToTop,
+    state: options?.state
+  });
+}
+var lastTriggeredNavOrRevalidateTimestampMS = Date.now();
+function getLastTriggeredNavOrRevalidateTimestampMS() {
+  return lastTriggeredNavOrRevalidateTimestampMS;
+}
+async function revalidate() {
+  await navigationStateManager.navigate({
+    href: window.location.href,
+    navigationType: "revalidation"
+  });
+}
+async function submit(url, requestInit, options) {
+  return navigationStateManager.submit(url, requestInit, options);
+}
+function getStatus() {
+  return navigationStateManager.getStatus();
+}
+function getLocation() {
+  return {
+    pathname: window.location.pathname,
+    search: window.location.search,
+    hash: window.location.hash,
+    state: HistoryManager.getInstance().location.state
+  };
+}
+function getBuildID() {
+  return __vormaClientGlobal.get("buildID");
+}
+function getRootEl() {
+  return document.getElementById("vorma-root");
+}
+function getHistoryInstance() {
+  return HistoryManager.getInstance();
+}
+
+// internal/framework/_typescript/client/src/error_boundary.ts
+var defaultErrorBoundary = (props) => {
+  return "Route Error: " + props.error;
+};
+
+// internal/framework/_typescript/client/src/global_loading_indicator/global_loading_indicator.ts
+var DEFAULT_DELAY = 12;
+function resolveIncludes(config, includesOption) {
+  const isArray = Array.isArray(config.include);
+  return isArray && config.include?.includes(includesOption);
+}
+function setupGlobalLoadingIndicator(config) {
+  let gliDebounceStartTimer = null;
+  let gliDebounceStopTimer = null;
+  const includesAll = !config.include || config.include === "all";
+  const pc = {
+    includesAll,
+    includesNavigations: resolveIncludes(config, "navigations") || includesAll,
+    includesSubmissions: resolveIncludes(config, "submissions") || includesAll,
+    includesRevalidations: resolveIncludes(config, "revalidations") || includesAll,
+    startDelayMS: config.startDelayMS ?? DEFAULT_DELAY,
+    stopDelayMS: config.stopDelayMS ?? DEFAULT_DELAY
+  };
+  function clearStartTimer() {
+    if (gliDebounceStartTimer) {
+      window.clearTimeout(gliDebounceStartTimer);
+      gliDebounceStartTimer = null;
+    }
+  }
+  function clearStopTimer() {
+    if (gliDebounceStopTimer) {
+      window.clearTimeout(gliDebounceStopTimer);
+      gliDebounceStopTimer = null;
+    }
+  }
+  function clearTimers() {
+    clearStartTimer();
+    clearStopTimer();
+  }
+  function handleStatusChange(e) {
+    const shouldBeWorking = getIsWorking(pc, e);
+    if (shouldBeWorking) {
+      clearStopTimer();
+      if (!gliDebounceStartTimer) {
+        gliDebounceStartTimer = window.setTimeout(() => {
+          gliDebounceStartTimer = null;
+          if (!config.isRunning() && getIsWorking(pc)) {
+            config.start();
+          }
+        }, pc.startDelayMS);
+      }
+    } else {
+      clearStartTimer();
+      if (!gliDebounceStopTimer) {
+        gliDebounceStopTimer = window.setTimeout(() => {
+          gliDebounceStopTimer = null;
+          if (config.isRunning() && !getIsWorking(pc)) {
+            config.stop();
+          }
+        }, pc.stopDelayMS);
+      }
+    }
+  }
+  handleStatusChange();
+  const removeStatusListenerCallback = addStatusListener(handleStatusChange);
+  return () => {
+    removeStatusListenerCallback();
+    clearTimers();
+    if (config.isRunning()) {
+      config.stop();
+    }
+  };
+}
+function getIsWorking(pc, e) {
+  const status = e?.detail ?? getStatus();
+  if (pc.includesAll) {
+    return status.isNavigating || status.isSubmitting || status.isRevalidating;
+  }
+  if (pc.includesNavigations && status.isNavigating) {
+    return true;
+  }
+  if (pc.includesSubmissions && status.isSubmitting) {
+    return true;
+  }
+  if (pc.includesRevalidations && status.isRevalidating) {
+    return true;
+  }
+  return false;
+}
+
+// internal/framework/_typescript/client/src/hmr/hmr.ts
+import { debounce as debounce2 } from "vorma/kit/debounce";
+var devTimeSetupClientLoadersDebounced = () => Promise.resolve();
+var hmrRevalidateSet;
+var __runClientLoadersAfterHMRUpdate = () => {
+};
+function initHMR() {
+  if (import.meta.env.DEV) {
+    window.__waveRevalidate = revalidate;
+    devTimeSetupClientLoadersDebounced = debounce2(async () => {
+      await setupClientLoaders();
+      dispatchRouteChangeEvent({});
+    }, 10);
+    __runClientLoadersAfterHMRUpdate = (importMeta, pattern) => {
+      if (hmrRevalidateSet === void 0) {
+        hmrRevalidateSet = /* @__PURE__ */ new Set();
+      }
+      if (import.meta.env.DEV && import.meta.hot) {
+        const thisURL = new URL(importMeta.url, location.href);
+        thisURL.search = "";
+        const thisPathname = thisURL.pathname;
+        const alreadyRegistered = hmrRevalidateSet.has(thisPathname);
+        if (alreadyRegistered) {
+          return;
+        }
+        hmrRevalidateSet.add(thisPathname);
+        import.meta.hot.on("vite:afterUpdate", (props) => {
+          for (const update of props.updates) {
+            if (update.type === "js-update") {
+              const updateURL = new URL(
+                update.path,
+                location.href
+              );
+              updateURL.search = "";
+              if (updateURL.pathname === thisURL.pathname) {
+                if (__vormaClientGlobal.get("matchedPatterns").includes(pattern)) {
+                  logInfo(
+                    "Refreshing client loaders due to change in pattern:",
+                    pattern
+                  );
+                  devTimeSetupClientLoadersDebounced();
+                }
+              }
+            }
+          }
+        });
+      }
+    };
+  }
+}
+
+// internal/framework/_typescript/client/src/init_client.ts
+import {
+  createPatternRegistry,
+  registerPattern as registerPattern2
+} from "vorma/kit/matcher/register";
+async function initClient(options) {
+  initHMR();
+  window.addEventListener("beforeunload", () => {
+    scrollStateManager.savePageRefreshState();
+  });
+  __vormaClientGlobal.set("vormaAppConfig", options.vormaAppConfig);
+  const clientModuleMap = {};
+  const initialMatchedPatterns = __vormaClientGlobal.get("matchedPatterns") || [];
+  const initialImportURLs = __vormaClientGlobal.get("importURLs") || [];
+  const initialExportKeys = __vormaClientGlobal.get("exportKeys") || [];
+  const initialErrorExportKeys = __vormaClientGlobal.get("errorExportKeys") || [];
+  for (let i = 0; i < initialMatchedPatterns.length; i++) {
+    const pattern = initialMatchedPatterns[i];
+    const importURL = initialImportURLs[i];
+    const exportKey = initialExportKeys[i];
+    const errorExportKey = initialErrorExportKeys[i];
+    if (pattern && importURL) {
+      clientModuleMap[pattern] = {
+        importURL,
+        exportKey: exportKey || "default",
+        errorExportKey: errorExportKey || ""
+      };
+    }
+  }
+  __vormaClientGlobal.set("clientModuleMap", clientModuleMap);
+  const patternRegistry = createPatternRegistry({
+    dynamicParamPrefixRune: options.vormaAppConfig.loadersDynamicRune,
+    splatSegmentRune: options.vormaAppConfig.loadersSplatRune,
+    explicitIndexSegment: options.vormaAppConfig.loadersExplicitIndexSegment
+  });
+  __vormaClientGlobal.set("patternRegistry", patternRegistry);
+  const manifestURL = __vormaClientGlobal.get("routeManifestURL");
+  if (manifestURL) {
+    fetch(manifestURL).then((response) => response.json()).then((manifest) => {
+      __vormaClientGlobal.set("routeManifest", manifest);
+      for (const pattern of Object.keys(manifest)) {
+        registerPattern2(patternRegistry, pattern);
+      }
+    }).catch((error) => {
+      console.warn("Failed to load route manifest:", error);
+    });
+  }
+  if (options.defaultErrorBoundary) {
+    __vormaClientGlobal.set(
+      "defaultErrorBoundary",
+      options.defaultErrorBoundary
+    );
+  } else {
+    __vormaClientGlobal.set("defaultErrorBoundary", defaultErrorBoundary);
+  }
+  if (options.useViewTransitions) {
+    __vormaClientGlobal.set("useViewTransitions", true);
+  }
+  HistoryManager.init();
+  const url = new URL(window.location.href);
+  if (url.searchParams.has(VORMA_HARD_RELOAD_QUERY_PARAM)) {
+    url.searchParams.delete(VORMA_HARD_RELOAD_QUERY_PARAM);
+    HistoryManager.getInstance().replace(url.href);
+  }
+  const importURLs = __vormaClientGlobal.get("importURLs");
+  await ComponentLoader.handleComponents(importURLs);
+  await setupClientLoaders();
+  await ComponentLoader.handleErrorBoundaryComponent(importURLs);
+  options.renderFn();
+  scrollStateManager.restorePageRefreshState();
+  window.addEventListener(
+    "touchstart",
+    () => {
+      __vormaClientGlobal.set("isTouchDevice", true);
+    },
+    { once: true }
+  );
+}
+
+// internal/framework/_typescript/client/src/links.ts
+import { getAnchorDetailsFromEvent, getHrefDetails as getHrefDetails2 } from "vorma/kit/url";
+function __getPrefetchHandlers(input) {
+  const hrefDetails = getHrefDetails2(input.href);
+  if (!hrefDetails.isHTTP) {
+    return;
+  }
+  const { relativeURL } = hrefDetails;
+  if (!relativeURL || hrefDetails.isExternal) {
+    return;
+  }
+  let timer;
+  let prefetchStarted = false;
+  const delayMs = input.delayMs ?? 100;
+  async function prefetch(e) {
+    if (prefetchStarted) return;
+    prefetchStarted = true;
+    if (input.beforeBegin) {
+      await input.beforeBegin(e);
+    }
+    const fullUrl = new URL(relativeURL, window.location.href);
+    if (input.search !== void 0) fullUrl.search = input.search;
+    if (input.hash !== void 0) fullUrl.hash = input.hash;
+    await navigationStateManager.navigate({
+      href: fullUrl.href,
+      navigationType: "prefetch",
+      state: input.state
+    });
+  }
+  function start(e) {
+    if (prefetchStarted) return;
+    timer = window.setTimeout(() => prefetch(e), delayMs);
+  }
+  function stop() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    const targetUrl = new URL(relativeURL, window.location.href).href;
+    const nav = navigationStateManager.getNavigation(targetUrl);
+    if (nav && nav.type === "prefetch" && nav.intent === "none") {
+      nav.control.abortController?.abort();
+      navigationStateManager.removeNavigation(targetUrl);
+    }
+    prefetchStarted = false;
+  }
+  async function onClick(e) {
+    if (e.defaultPrevented) return;
+    const anchorDetails = getAnchorDetailsFromEvent(
+      e
+    );
+    if (!anchorDetails) return;
+    const { isEligibleForDefaultPrevention, isInternal } = anchorDetails;
+    if (!isEligibleForDefaultPrevention || !isInternal) return;
+    if (isJustAHashChange(anchorDetails)) {
+      saveScrollState();
+      return;
+    }
+    e.preventDefault();
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    if (input.beforeBegin && !prefetchStarted) {
+      await input.beforeBegin(e);
+    }
+    if (input.beforeRender) {
+      await input.beforeRender(e);
+    }
+    await vormaNavigate(relativeURL, {
+      scrollToTop: input.scrollToTop,
+      replace: input.replace,
+      search: input.search,
+      hash: input.hash,
+      state: input.state
+    });
+    if (input.afterRender) {
+      await input.afterRender(e);
+    }
+  }
+  return {
+    ...hrefDetails,
+    start,
+    stop,
+    onClick
+  };
+}
+function __makeLinkOnClickFn(callbacks) {
+  return async (e) => {
+    if (e.defaultPrevented) return;
+    const anchorDetails = getAnchorDetailsFromEvent(
+      e
+    );
+    if (!anchorDetails) return;
+    const { anchor, isEligibleForDefaultPrevention, isInternal } = anchorDetails;
+    if (!anchor) return;
+    if (isJustAHashChange(anchorDetails)) {
+      saveScrollState();
+      return;
+    }
+    if (isEligibleForDefaultPrevention && isInternal) {
+      e.preventDefault();
+      await callbacks.beforeBegin?.(e);
+      const control = navigationStateManager.beginNavigation({
+        href: anchor.href,
+        navigationType: "userNavigation",
+        scrollToTop: callbacks.scrollToTop,
+        replace: callbacks.replace,
+        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 targetUrl = new URL(anchor.href, window.location.href).href;
+      const entry = navigationStateManager.getNavigation(targetUrl);
+      if (entry) {
+        await navigationStateManager["processNavigationResult"](
+          res,
+          entry
+        );
+      }
+      await callbacks.afterRender?.(e);
+    }
+  };
+}
+function isJustAHashChange(anchorDetails) {
+  if (!anchorDetails) return false;
+  const { pathname, search, hash } = new URL(
+    anchorDetails.anchor.href,
+    window.location.href
+  );
+  return !!(hash && pathname === window.location.pathname && search === window.location.search);
+}
+
+// internal/framework/_typescript/client/src/static_route_defs/route_def_helpers.ts
+function route(pattern, importPromise, componentKey, errorBoundaryKey) {
+}
+
+// internal/framework/_typescript/client/src/vorma_app_helpers/vorma_app_helpers.ts
+import { serializeToSearchParams } from "vorma/kit/json";
+function buildQueryURL(vormaAppConfig, props) {
+  return buildURL({ vormaAppConfig, props, type: "query" });
+}
+function buildMutationURL(vormaAppConfig, props) {
+  return buildURL({ vormaAppConfig, props, type: "mutation" });
+}
+function resolveBody(props) {
+  const { input } = props;
+  if (input == null || typeof input === "string" || input instanceof Blob || input instanceof FormData || input instanceof URLSearchParams || input instanceof ReadableStream || input instanceof ArrayBuffer || ArrayBuffer.isView(input)) {
+    return input;
+  }
+  return JSON.stringify(input);
+}
+function buildURL(opts) {
+  const base_path = stripTrailingSlash(
+    opts.vormaAppConfig.actionsRouterMountRoot
+  );
+  const resolved_path = __resolvePath(opts);
+  const url = new URL(base_path + resolved_path, getCurrentOrigin());
+  if (opts.type === "query" && opts.props.input) {
+    url.search = serializeToSearchParams(opts.props.input).toString();
+  }
+  return url;
+}
+function __resolvePath(opts) {
+  const { props, vormaAppConfig } = opts;
+  let path = props.pattern;
+  let dynamicParamPrefixRune = vormaAppConfig.actionsDynamicRune;
+  let splatSegmentRune = vormaAppConfig.actionsSplatRune;
+  if (opts.type === "loader") {
+    dynamicParamPrefixRune = vormaAppConfig.loadersDynamicRune;
+    splatSegmentRune = vormaAppConfig.loadersSplatRune;
+  }
+  if ("params" in props && props.params) {
+    for (const [key, value] of Object.entries(props.params)) {
+      path = path.replace(
+        `${dynamicParamPrefixRune}${key}`,
+        String(value)
+      );
+    }
+  }
+  if ("splatValues" in props && props.splatValues) {
+    const splatPath = props.splatValues.join("/");
+    path = path.replace(splatSegmentRune, splatPath);
+  }
+  if (opts.type === "loader" && vormaAppConfig.loadersExplicitIndexSegment) {
+    const indexSegment = `/${vormaAppConfig.loadersExplicitIndexSegment}`;
+    if (path.endsWith(indexSegment)) {
+      path = path.slice(0, -indexSegment.length) || "/";
+    }
+  }
+  return path;
+}
+function getCurrentOrigin() {
+  return new URL(window.location.href).origin;
+}
+function stripTrailingSlash(path) {
+  return path.endsWith("/") ? path.slice(0, -1) : path;
+}
+
+// internal/framework/_typescript/client/src/ui_lib_impl_helpers/link_components.ts
+function linkPropsToPrefetchObj(props) {
+  if (!props.href || props.prefetch !== "intent") {
+    return void 0;
+  }
+  return __getPrefetchHandlers({
+    href: props.href,
+    delayMs: props.prefetchDelayMs,
+    beforeBegin: props.beforeBegin,
+    beforeRender: props.beforeRender,
+    afterRender: props.afterRender,
+    scrollToTop: props.scrollToTop,
+    replace: props.replace,
+    state: props.state
+  });
+}
+function linkPropsToOnClickFn(props) {
+  return __makeLinkOnClickFn({
+    beforeBegin: props.beforeBegin,
+    beforeRender: props.beforeRender,
+    afterRender: props.afterRender,
+    scrollToTop: props.scrollToTop,
+    replace: props.replace,
+    state: props.state
+  });
+}
+var standardCamelHandlerKeys = {
+  onPointerEnter: "onPointerEnter",
+  onFocus: "onFocus",
+  onPointerLeave: "onPointerLeave",
+  onBlur: "onBlur",
+  onTouchCancel: "onTouchCancel",
+  onClick: "onClick"
+};
+function __makeFinalLinkProps(props, keys = standardCamelHandlerKeys) {
+  const prefetchObj = linkPropsToPrefetchObj(props);
+  return {
+    dataExternal: prefetchObj?.isExternal || void 0,
+    onPointerEnter: (e) => {
+      prefetchObj?.start(e);
+      if (isFn(props[keys.onPointerEnter])) {
+        props[keys.onPointerEnter](e);
+      }
+    },
+    onFocus: (e) => {
+      prefetchObj?.start(e);
+      if (isFn(props[keys.onFocus])) {
+        props[keys.onFocus](e);
+      }
+    },
+    onPointerLeave: (e) => {
+      if (!__vormaClientGlobal.get("isTouchDevice")) {
+        prefetchObj?.stop();
+      }
+      if (isFn(props[keys.onPointerLeave])) {
+        props[keys.onPointerLeave](e);
+      }
+    },
+    onBlur: (e) => {
+      prefetchObj?.stop();
+      if (isFn(props[keys.onBlur])) {
+        props[keys.onBlur](e);
+      }
+    },
+    onTouchCancel: (e) => {
+      prefetchObj?.stop();
+      if (isFn(props[keys.onTouchCancel])) {
+        props[keys.onTouchCancel](e);
+      }
+    },
+    onClick: async (e) => {
+      if (isFn(props[keys.onClick])) {
+        props[keys.onClick](e);
+      }
+      if (prefetchObj) {
+        await prefetchObj.onClick(e);
+      } else {
+        await linkPropsToOnClickFn(props)(e);
+      }
+    }
+  };
+}
+function isFn(fn) {
+  return typeof fn === "function";
+}
+
+// internal/framework/_typescript/client/src/ui_lib_impl_helpers/typed_navigate.ts
+function makeTypedNavigate(vormaAppConfig) {
+  return async function typedNavigate(options) {
+    const {
+      pattern,
+      params,
+      splatValues,
+      replace,
+      scrollToTop,
+      search,
+      hash,
+      state
+    } = options;
+    const href = __resolvePath({
+      vormaAppConfig,
+      type: "loader",
+      props: {
+        pattern,
+        ...params && { params },
+        ...splatValues && { splatValues }
+      }
+    });
+    return vormaNavigate(href, {
+      replace,
+      scrollToTop,
+      search,
+      hash,
+      state
+    });
+  };
+}
+
+// internal/framework/_typescript/client/src/window_focus_revalidation/window_focus_revalidation.ts
+import { addOnWindowFocusListener } from "vorma/kit/listeners";
+function revalidateOnWindowFocus(options) {
+  const staleTimeMS = options?.staleTimeMS ?? 5e3;
+  return addOnWindowFocusListener(() => {
+    const status = getStatus();
+    if (!status.isNavigating && !status.isSubmitting && !status.isRevalidating) {
+      if (Date.now() - getLastTriggeredNavOrRevalidateTimestampMS() < staleTimeMS) {
+        return;
+      }
+      revalidate();
+    }
+  });
+}
+export {
+  __applyScrollState,
+  __getPrefetchHandlers,
+  __makeFinalLinkProps,
+  __makeLinkOnClickFn,
+  __registerClientLoaderPattern,
+  __resolvePath,
+  __runClientLoadersAfterHMRUpdate,
+  __vormaClientGlobal,
+  addBuildIDListener,
+  addLocationListener,
+  addRouteChangeListener,
+  addStatusListener,
+  buildMutationURL,
+  buildQueryURL,
+  defaultErrorBoundary,
+  getBuildID,
+  getHistoryInstance,
+  getLocation,
+  getRootEl,
+  getRouterData,
+  getStatus,
+  initClient,
+  makeTypedNavigate,
+  resolveBody,
+  revalidate,
+  revalidateOnWindowFocus,
+  route,
+  setupGlobalLoadingIndicator,
+  submit,
+  vormaNavigate
+};
+//# sourceMappingURL=index.js.map