@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-VCFBQFOV.mjs

@@ -0,0 +1,1093 @@
+import {
+  _hydrateFarmI18n,
+  isFarmLocaleChangeHref
+} from "./chunk-PTLXHRJZ.mjs";
+import {
+  getHashTargetElement
+} from "./chunk-45EUIICW.mjs";
+import {
+  isFarmBlockedNavigationURL,
+  isFarmExternalNavigationURL,
+  resolveFarmNavigationURL
+} from "./chunk-NCIAP562.mjs";
+import {
+  createClientCancellation
+} from "./chunk-H227LYHT.mjs";
+import {
+  FARM_METADATA_ATTRIBUTE,
+  renderMetadataHead,
+  resolveMetadataTitle
+} from "./chunk-S6O2L47H.mjs";
+import {
+  getFarmIslandValueHeaders
+} from "./chunk-NBIVGHAT.mjs";
+import {
+  createFarmDeploymentMismatchError,
+  createFarmDeploymentRequestHeaders,
+  isFarmDeploymentMismatchResponse
+} from "./chunk-UAQD67HM.mjs";
+import {
+  readDeferredDataResponse
+} from "./chunk-K5EW7GUU.mjs";
+
+// src/client/metadata-reconciler.ts
+var MANAGED_ATTRIBUTE = FARM_METADATA_ATTRIBUTE;
+var OWNED_SELECTORS = [
+  'meta[name="description"]',
+  'meta[name="keywords"]',
+  'meta[name="author"]',
+  'meta[name="google-site-verification"]',
+  'meta[name="msvalidate.01"]',
+  'meta[name="yandex-verification"]',
+  'meta[name="creator"]',
+  'meta[name="publisher"]',
+  'meta[name="robots"]',
+  'meta[name="googlebot"]',
+  'link[rel="author"]',
+  'link[rel="canonical"]',
+  'link[rel="alternate"]',
+  'meta[property^="og:"]',
+  'meta[property^="article:"]',
+  'meta[name^="twitter:"]',
+  // Meta tags named by the app carry the marker, since no fixed name matches them.
+  `meta[${MANAGED_ATTRIBUTE}]`
+].join(", ");
+var ICON_SELECTORS = [
+  'link[rel="icon"]',
+  'link[rel="shortcut icon"]',
+  'link[rel="apple-touch-icon"]'
+].join(", ");
+var MANIFEST_SELECTOR = 'link[rel="manifest"]';
+var PAGE_JSON_LD_SELECTOR = `script[type="application/ld+json"][${MANAGED_ATTRIBUTE}]`;
+function removeAll(selector) {
+  for (const element of Array.from(document.head.querySelectorAll(selector))) {
+    element.remove();
+  }
+}
+function applyFarmMetadataToDocument(metadata, pathname) {
+  document.title = resolveMetadataTitle(metadata?.title) || "Farm.js App";
+  const rendered = renderMetadataHead(metadata, { pathname });
+  const template = document.createElement("template");
+  template.innerHTML = rendered.tags;
+  const viewport = document.createElement("template");
+  viewport.innerHTML = rendered.viewport;
+  removeAll(OWNED_SELECTORS);
+  const charset = document.head.querySelector("meta[charset]");
+  for (const element of Array.from(viewport.content.children).reverse()) {
+    const name = element.getAttribute("name");
+    if (name && document.head.querySelector(`meta[name="${name}"]:not([${MANAGED_ATTRIBUTE}])`)) {
+      continue;
+    }
+    document.head.insertBefore(element, charset ? charset.nextSibling : document.head.firstChild);
+  }
+  removeAll(PAGE_JSON_LD_SELECTOR);
+  if (metadata?.icons) removeAll(ICON_SELECTORS);
+  if (metadata?.manifest) removeAll(MANIFEST_SELECTOR);
+  for (const element of Array.from(template.content.children)) {
+    element.setAttribute(MANAGED_ATTRIBUTE, "");
+    document.head.appendChild(element);
+  }
+}
+
+// src/client/spa-router.ts
+var MAX_CONCURRENT_VIEWPORT_PREFETCHES = 4;
+var FARM_PAGE_STATE_KEY = "__farmPageState";
+var FARM_INTERCEPT_FROM_KEY = "__farmInterceptFrom";
+var FARM_HISTORY_INDEX_KEY = "__farmHistoryIndex";
+function readHistoryIndex(state) {
+  if (!state || typeof state !== "object") return null;
+  const value = state[FARM_HISTORY_INDEX_KEY];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+var IDLE_NAVIGATION_STATE = {
+  state: "idle",
+  pending: false,
+  from: null,
+  to: null,
+  action: null,
+  startedAt: null
+};
+function getActiveLayoutChainHeader() {
+  if (typeof document === "undefined") return void 0;
+  const patterns = Array.from(
+    document.querySelectorAll('[data-farm-layout-boundary="true"]')
+  ).map((element) => element.dataset.farmLayoutPattern).filter((pattern) => Boolean(pattern));
+  return patterns.length > 0 ? JSON.stringify(patterns) : void 0;
+}
+var routerInstance = null;
+var SPARouter = class {
+  constructor(options = {}) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.prefetchingUrls = /* @__PURE__ */ new Set();
+    this.pendingPrefetches = /* @__PURE__ */ new Map();
+    this.cacheGeneration = 0;
+    this.observedPrefetchLinks = /* @__PURE__ */ new Map();
+    this.prefetchTimers = /* @__PURE__ */ new Map();
+    this.viewportPrefetchQueue = [];
+    this.viewportPrefetchTasksByHref = /* @__PURE__ */ new Map();
+    this.viewportPrefetchTasksByElement = /* @__PURE__ */ new Map();
+    this.activeViewportPrefetches = 0;
+    this.destroyed = false;
+    this.blockers = /* @__PURE__ */ new Set();
+    this.unloadBlockers = /* @__PURE__ */ new Map();
+    this.navigationListeners = /* @__PURE__ */ new Set();
+    this.navigationState = IDLE_NAVIGATION_STATE;
+    this.currentHistoryPath = null;
+    this.currentHistoryHash = "";
+    this.currentHistoryIndex = null;
+    this.suppressNextPopState = false;
+    this.navigationSequence = 0;
+    this.scrollElements = /* @__PURE__ */ new Map();
+    this.onPopState = (event) => {
+      void this.handlePopState(event);
+    };
+    this.onBeforeUnload = (event) => {
+      if (this.shouldBlockUnload()) {
+        event.preventDefault();
+        event.returnValue = "";
+      }
+      this.saveScrollPosition(window.location.pathname + window.location.search);
+    };
+    this.options = {
+      prefetchTimeout: options.prefetchTimeout ?? 100,
+      cacheMaxAge: options.cacheMaxAge ?? 3e4,
+      // 30 seconds
+      scrollRestoration: options.scrollRestoration ?? true,
+      shouldUseDocumentNavigation: options.shouldUseDocumentNavigation ?? (() => false),
+      deploymentId: options.deploymentId ?? readBrowserDeploymentId()
+    };
+    if (typeof window !== "undefined") {
+      window.addEventListener("popstate", this.onPopState);
+      window.addEventListener("beforeunload", this.onBeforeUnload);
+      this.currentHistoryPath = window.location.pathname + window.location.search;
+      this.currentHistoryHash = window.location.hash;
+      this.currentInterceptFrom = window.history.state?.[FARM_INTERCEPT_FROM_KEY];
+      const existingIndex = readHistoryIndex(window.history.state);
+      if (existingIndex == null) {
+        try {
+          window.history.replaceState(
+            {
+              ...window.history.state ?? {},
+              [FARM_HISTORY_INDEX_KEY]: 0
+            },
+            "",
+            window.location.href
+          );
+          this.currentHistoryIndex = 0;
+        } catch {
+          this.currentHistoryIndex = null;
+        }
+      } else {
+        this.currentHistoryIndex = existingIndex;
+      }
+    }
+  }
+  /** Remove global listeners. Intended for tests and teardown. */
+  destroy() {
+    if (typeof window === "undefined") return;
+    this.destroyed = true;
+    this.cancelActiveNavigation();
+    this.clearCache();
+    this.prefetchObserver?.disconnect();
+    this.prefetchObserver = void 0;
+    for (const timer of this.prefetchTimers.values()) clearTimeout(timer);
+    this.observedPrefetchLinks.clear();
+    this.prefetchTimers.clear();
+    for (const task of this.viewportPrefetchQueue) task.cancelled = true;
+    this.viewportPrefetchQueue.length = 0;
+    this.viewportPrefetchTasksByHref.clear();
+    this.viewportPrefetchTasksByElement.clear();
+    window.removeEventListener("popstate", this.onPopState);
+    window.removeEventListener("beforeunload", this.onBeforeUnload);
+  }
+  /**
+   * Set the navigation handler that updates React
+   */
+  setNavigationHandler(handler) {
+    this.onNavigate = handler;
+  }
+  /**
+   * Connect Farm's browser plugin lifecycle to SPA navigation.
+   */
+  setClientPluginManager(manager) {
+    this.clientPlugins = manager;
+  }
+  /**
+   * Navigate to a new URL
+   */
+  async navigate(href, options = {}) {
+    const {
+      replace = false,
+      scroll = true,
+      state,
+      viewTransition = false,
+      refresh = false
+    } = options;
+    const url = resolveFarmNavigationURL(href, window.location.href);
+    if (isFarmBlockedNavigationURL(url)) return;
+    const pathname = url.pathname;
+    const search = url.search;
+    const fullPath = pathname + search;
+    if (isFarmExternalNavigationURL(url, window.location.origin) || isFarmLocaleChangeHref(url.toString()) || this.options.shouldUseDocumentNavigation(pathname)) {
+      this.cancelActiveNavigation();
+      if (replace) window.location.replace(url.toString());
+      else window.location.assign(url.toString());
+      return;
+    }
+    if (!refresh && pathname === window.location.pathname && search === window.location.search) {
+      this.cancelActiveNavigation();
+      if (url.hash === window.location.hash) return;
+      this.writePageState(
+        replace ? "replace" : "push",
+        state === void 0 ? readPageState() : state,
+        url.toString()
+      );
+      if (scroll) {
+        if (url.hash) {
+          getHashTargetElement(url.hash)?.scrollIntoView();
+        } else {
+          window.scrollTo(0, 0);
+        }
+      }
+      return;
+    }
+    const from = window.location.pathname + window.location.search;
+    if (await this.shouldBlockNavigation({
+      from,
+      to: fullPath,
+      action: replace ? "replace" : "push"
+    })) {
+      return;
+    }
+    if (this.options.scrollRestoration) {
+      this.saveScrollPosition(window.location.pathname + window.location.search);
+    }
+    const navigation = this.startNavigation({
+      from,
+      to: createNavigationLocation(url),
+      action: replace ? "replace" : "push"
+    });
+    let clientNavigation;
+    try {
+      clientNavigation = await this.clientPlugins?.beginNavigation({
+        from,
+        to: url,
+        action: replace ? "replace" : "push"
+      });
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      const pageData = await this.fetchPageData(
+        fullPath,
+        true,
+        from,
+        refresh,
+        navigation.controller.signal
+      );
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      if (clientNavigation) {
+        await this.clientPlugins?.markNavigationLoaded(clientNavigation, pageData);
+      }
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      await this.runViewTransition(
+        viewTransition,
+        () => this.isCurrentNavigation(navigation, clientNavigation) ? this.commitNavigation({
+          fullPath,
+          pageData,
+          pathname,
+          replace,
+          scroll,
+          state,
+          url,
+          refresh
+        }) : Promise.resolve()
+      );
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      if (clientNavigation) {
+        await this.clientPlugins?.resolveNavigation(clientNavigation);
+        void this.clientPlugins?.scheduleNavigationRendered(clientNavigation);
+      }
+      this.finishNavigation(navigation);
+    } catch (error) {
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      if (clientNavigation) {
+        await this.clientPlugins?.failNavigation(clientNavigation, error);
+      }
+      this.finishNavigation(navigation);
+      console.error("[Farm.js] Navigation error:", error);
+      window.location.href = href;
+    }
+  }
+  /**
+   * Re-render the active route from the server while preserving the document,
+   * shared layouts, client runtime, and browser history entry.
+   */
+  refresh(options = {}) {
+    return this.navigate(window.location.href, {
+      ...options,
+      replace: true,
+      refresh: true,
+      scroll: options.scroll ?? false
+    });
+  }
+  /**
+   * Prefetch a URL
+   */
+  async prefetch(href) {
+    if (this.destroyed) return;
+    if (isFarmLocaleChangeHref(href)) return;
+    const url = resolveFarmNavigationURL(href, window.location.href);
+    if (isFarmExternalNavigationURL(url, window.location.origin)) return;
+    if (this.options.shouldUseDocumentNavigation(url.pathname)) return;
+    const fullPath = url.pathname + url.search;
+    const interceptFrom = window.location.pathname + window.location.search;
+    if (this.prefetchingUrls.has(fullPath)) return;
+    if (this.isCached(fullPath, interceptFrom)) return;
+    this.prefetchingUrls.add(fullPath);
+    try {
+      await this.fetchPageData(fullPath, false, interceptFrom);
+    } catch (error) {
+      console.warn("[Farm.js] Prefetch failed:", href, error);
+    } finally {
+      this.prefetchingUrls.delete(fullPath);
+    }
+  }
+  /**
+   * Observe an element for viewport intersection (prefetch when visible)
+   */
+  observeForPrefetch(element) {
+    if (this.destroyed || typeof IntersectionObserver === "undefined") return;
+    const href = element.getAttribute("href");
+    if (!href || this.isExternalUrl(href)) return;
+    this.unobserveForPrefetch(element);
+    const observer = this.getPrefetchObserver();
+    this.observedPrefetchLinks.set(element, href);
+    observer.observe(element);
+  }
+  /**
+   * Stop observing an element
+   */
+  unobserveForPrefetch(element) {
+    if (this.observedPrefetchLinks.delete(element)) {
+      this.prefetchObserver?.unobserve(element);
+    }
+    const timer = this.prefetchTimers.get(element);
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      this.prefetchTimers.delete(element);
+    }
+    this.cancelQueuedViewportPrefetch(element);
+  }
+  getPrefetchObserver() {
+    this.prefetchObserver ?? (this.prefetchObserver = new IntersectionObserver(
+      (entries) => {
+        for (const entry of entries) {
+          if (!entry.isIntersecting) continue;
+          const element = entry.target;
+          const href = this.observedPrefetchLinks.get(element);
+          if (!href) continue;
+          this.prefetchObserver?.unobserve(element);
+          this.observedPrefetchLinks.delete(element);
+          const timer = setTimeout(() => {
+            if (this.prefetchTimers.get(element) !== timer) return;
+            this.prefetchTimers.delete(element);
+            this.enqueueViewportPrefetch(element, href);
+          }, this.options.prefetchTimeout);
+          this.prefetchTimers.set(element, timer);
+        }
+      },
+      { rootMargin: "200px" }
+    ));
+    return this.prefetchObserver;
+  }
+  enqueueViewportPrefetch(element, href) {
+    if (this.destroyed) return;
+    let task = this.viewportPrefetchTasksByHref.get(href);
+    if (!task) {
+      task = { href, elements: /* @__PURE__ */ new Set(), cancelled: false, started: false };
+      this.viewportPrefetchTasksByHref.set(href, task);
+      this.viewportPrefetchQueue.push(task);
+    }
+    task.elements.add(element);
+    this.viewportPrefetchTasksByElement.set(element, task);
+    this.drainViewportPrefetchQueue();
+  }
+  cancelQueuedViewportPrefetch(element) {
+    const task = this.viewportPrefetchTasksByElement.get(element);
+    if (!task) return;
+    this.viewportPrefetchTasksByElement.delete(element);
+    task.elements.delete(element);
+    if (task.elements.size > 0) return;
+    if (task.started) return;
+    task.cancelled = true;
+    if (this.viewportPrefetchTasksByHref.get(task.href) === task) {
+      this.viewportPrefetchTasksByHref.delete(task.href);
+    }
+  }
+  drainViewportPrefetchQueue() {
+    while (!this.destroyed && this.activeViewportPrefetches < MAX_CONCURRENT_VIEWPORT_PREFETCHES && this.viewportPrefetchQueue.length > 0) {
+      const task = this.viewportPrefetchQueue.shift();
+      if (task.cancelled || task.elements.size === 0) {
+        if (this.viewportPrefetchTasksByHref.get(task.href) === task) {
+          this.viewportPrefetchTasksByHref.delete(task.href);
+        }
+        continue;
+      }
+      task.started = true;
+      this.activeViewportPrefetches += 1;
+      let prefetchResult;
+      try {
+        prefetchResult = this.prefetch(task.href);
+      } catch {
+        prefetchResult = void 0;
+      }
+      void Promise.resolve(prefetchResult).catch(() => void 0).finally(() => {
+        if (this.viewportPrefetchTasksByHref.get(task.href) === task) {
+          this.viewportPrefetchTasksByHref.delete(task.href);
+        }
+        for (const element of task.elements) {
+          if (this.viewportPrefetchTasksByElement.get(element) === task) {
+            this.viewportPrefetchTasksByElement.delete(element);
+          }
+        }
+        this.activeViewportPrefetches -= 1;
+        this.drainViewportPrefetchQueue();
+      });
+    }
+  }
+  addBlocker(blocker, shouldBlockUnload) {
+    this.blockers.add(blocker);
+    this.unloadBlockers.set(
+      blocker,
+      shouldBlockUnload ?? (() => this.evaluateBlockerForUnload(blocker))
+    );
+    return () => {
+      this.blockers.delete(blocker);
+      this.unloadBlockers.delete(blocker);
+    };
+  }
+  getNavigationState() {
+    return this.navigationState;
+  }
+  subscribeNavigation(listener) {
+    this.navigationListeners.add(listener);
+    listener(this.navigationState);
+    return () => {
+      this.navigationListeners.delete(listener);
+    };
+  }
+  registerScrollElement(key, element) {
+    this.scrollElements.set(key, element);
+    this.restoreScrollElement(window.location.pathname + window.location.search, key, element);
+    return () => {
+      if (this.scrollElements.get(key) === element) {
+        this.scrollElements.delete(key);
+      }
+    };
+  }
+  pushState(state, href) {
+    this.writePageState("push", state, href);
+  }
+  replaceState(state, href) {
+    this.writePageState("replace", state, href);
+  }
+  /** @internal Keep shallow URL-search writes inside the router's history bookkeeping. */
+  writeURLSearch(action, href) {
+    this.writePageState(action, readPageState(), href, false);
+  }
+  async commitNavigation(options) {
+    const historyUrl = resolveFarmNavigationURL(
+      options.pageData.canonicalPath || options.fullPath,
+      window.location.href
+    );
+    historyUrl.hash = options.url.hash;
+    const historyPath = historyUrl.pathname + historyUrl.search + historyUrl.hash;
+    const historyState = createHistoryState(
+      historyPath,
+      options.state,
+      options.replace ? window.history.state : void 0,
+      options.pageData.interception?.from ?? null
+    );
+    const nextHistoryIndex = this.currentHistoryIndex == null ? null : options.replace ? this.currentHistoryIndex : this.currentHistoryIndex + 1;
+    if (nextHistoryIndex != null) {
+      historyState[FARM_HISTORY_INDEX_KEY] = nextHistoryIndex;
+    }
+    if (options.replace) {
+      window.history.replaceState(historyState, "", historyPath);
+    } else {
+      window.history.pushState(historyState, "", historyPath);
+    }
+    this.currentHistoryIndex = nextHistoryIndex;
+    const resolvedHistoryUrl = resolveFarmNavigationURL(historyPath, window.location.href);
+    this.currentHistoryPath = resolvedHistoryUrl.pathname + resolvedHistoryUrl.search;
+    this.currentHistoryHash = resolvedHistoryUrl.hash;
+    this.currentInterceptFrom = historyState[FARM_INTERCEPT_FROM_KEY];
+    notifyRouterHistoryChange();
+    this.updateDocumentMetadata(options.pageData.metadata);
+    _hydrateFarmI18n(options.pageData.i18n);
+    if (this.onNavigate) {
+      await this.onNavigate(options.pageData, { refresh: options.refresh === true });
+    }
+    if (options.scroll) {
+      if (options.url.hash) {
+        const element = getHashTargetElement(options.url.hash);
+        if (element) {
+          element.scrollIntoView();
+        }
+      } else {
+        window.scrollTo(0, 0);
+      }
+    } else if (this.options.scrollRestoration) {
+      const restorePath = this.currentHistoryPath ?? options.fullPath;
+      this.restoreWindowScroll(restorePath);
+      this.restoreScrollElements(restorePath);
+    }
+  }
+  async runViewTransition(mode, callback) {
+    if (!mode || typeof document === "undefined") {
+      await callback();
+      return;
+    }
+    const startViewTransition = document.startViewTransition;
+    if (typeof startViewTransition !== "function") {
+      await callback();
+      return;
+    }
+    const transition = startViewTransition.call(document, () => callback());
+    const updateDone = transition?.updateCallbackDone || transition?.ready;
+    if (updateDone && typeof updateDone.then === "function") {
+      await updateDone;
+    }
+    transition?.finished?.catch?.(() => void 0);
+  }
+  /**
+   * Fetch page data from cache or server
+   */
+  async fetchPageData(path, recover = true, interceptFrom, fresh = false, signal) {
+    const cacheKey = getPageDataCacheKey(path, interceptFrom);
+    const cached = fresh ? void 0 : this.cache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < this.options.cacheMaxAge) {
+      return cached.data;
+    }
+    const activeLayoutChain = getActiveLayoutChainHeader();
+    const prefetchKey = JSON.stringify([path, interceptFrom, activeLayoutChain]);
+    let generation = this.cacheGeneration;
+    const pending = this.pendingPrefetches.get(prefetchKey);
+    if (pending && recover) {
+      if (fresh) {
+        pending.cacheable = false;
+        pending.resolve(void 0);
+        this.pendingPrefetches.delete(prefetchKey);
+      } else {
+        const cancellation = createClientCancellation(signal);
+        try {
+          const data = await cancellation.run(() => pending.data);
+          cancellation.check();
+          if (data && pending.cacheable && generation === this.cacheGeneration) return data;
+        } finally {
+          cancellation.dispose();
+        }
+      }
+    }
+    generation = this.cacheGeneration;
+    let prefetch2;
+    if (!recover) {
+      let resolve;
+      const data = new Promise((done) => {
+        resolve = done;
+      });
+      prefetch2 = { data, resolve, cacheable: true };
+      this.pendingPrefetches.set(prefetchKey, prefetch2);
+    }
+    const cacheData = (data) => {
+      if (!this.destroyed && generation === this.cacheGeneration && prefetch2?.cacheable !== false) {
+        this.cachePageData(cacheKey, data);
+      }
+    };
+    try {
+      return await this.requestPageData(
+        path,
+        recover,
+        interceptFrom,
+        activeLayoutChain,
+        signal,
+        cacheData,
+        prefetch2?.resolve
+      );
+    } finally {
+      prefetch2?.resolve(void 0);
+      if (prefetch2 && this.pendingPrefetches.get(prefetchKey) === prefetch2) {
+        this.pendingPrefetches.delete(prefetchKey);
+      }
+    }
+  }
+  async requestPageData(path, recover, interceptFrom, activeLayoutChain, signal, cacheData, resolvePrefetch) {
+    const response = await fetch(`/__farm/page-data?path=${encodeURIComponent(path)}`, {
+      signal,
+      headers: createFarmDeploymentRequestHeaders(this.options.deploymentId, {
+        Accept: "application/x-farm-deferred+json, application/json",
+        "X-Farm-SPA": "1",
+        ...activeLayoutChain ? { "X-Farm-Layout-Chain": activeLayoutChain } : {},
+        ...interceptFrom ? { "X-Farm-Intercept-From": interceptFrom } : {},
+        // Islands mode: the server leaves out island values this browser holds.
+        ...getFarmIslandValueHeaders()
+      })
+    });
+    if (isFarmDeploymentMismatchResponse(response, this.options.deploymentId)) {
+      const error = createFarmDeploymentMismatchError(
+        response,
+        this.options.deploymentId || "unknown"
+      );
+      dispatchDeploymentMismatch(error);
+      if (recover) {
+        window.location.assign(path);
+      }
+      throw error;
+    }
+    if (!response.ok) {
+      throw new Error(`Failed to fetch page data: ${response.status}`);
+    }
+    const isDeferredResponse = (response.headers.get("Content-Type") || "").toLowerCase().startsWith("application/x-farm-deferred+json");
+    if (!isDeferredResponse) {
+      const data2 = await readDeferredDataResponse(response);
+      cacheData(data2);
+      resolvePrefetch?.(data2);
+      return data2;
+    }
+    resolvePrefetch?.(void 0);
+    let data;
+    let streamCompleted = false;
+    const markStreamComplete = () => {
+      streamCompleted = true;
+      if (data) cacheData(data);
+    };
+    data = await readDeferredDataResponse(response, {
+      onComplete: markStreamComplete
+    });
+    if (streamCompleted) cacheData(data);
+    return data;
+  }
+  cachePageData(cacheKey, data) {
+    const now = Date.now();
+    for (const [key, entry] of this.cache) {
+      if (now - entry.timestamp >= this.options.cacheMaxAge) this.cache.delete(key);
+    }
+    this.cache.set(cacheKey, { data, timestamp: now });
+  }
+  /**
+   * Put the browser URL back on the rendered page after a blocked pop. When
+   * both entries carry a Farm history index the traversal is reversed
+   * exactly; otherwise the current path is pushed again, which restores the
+   * address bar at the cost of one extra history entry.
+   */
+  revertBlockedPopState(event, from) {
+    const eventIndex = readHistoryIndex(event.state);
+    if (eventIndex != null && this.currentHistoryIndex != null) {
+      const delta = eventIndex - this.currentHistoryIndex;
+      if (delta !== 0) {
+        this.suppressNextPopState = true;
+        window.history.go(-delta);
+        return;
+      }
+    }
+    try {
+      const restoredState = {
+        path: from
+      };
+      if (this.currentHistoryIndex != null && eventIndex != null) {
+        restoredState[FARM_HISTORY_INDEX_KEY] = eventIndex + 1;
+        this.currentHistoryIndex = eventIndex + 1;
+      }
+      window.history.pushState(restoredState, "", from);
+    } catch {
+    }
+  }
+  /**
+   * Handle browser back/forward navigation
+   */
+  async handlePopState(event) {
+    if (document.documentElement.dataset.farmDocsRuntime === "true") return;
+    if (this.suppressNextPopState) {
+      this.suppressNextPopState = false;
+      return;
+    }
+    const path = window.location.pathname + window.location.search;
+    const from = this.currentHistoryPath ?? path;
+    if (path === from && window.location.hash !== this.currentHistoryHash && event.state?.[FARM_INTERCEPT_FROM_KEY] === this.currentInterceptFrom) {
+      this.cancelActiveNavigation();
+      this.currentHistoryHash = window.location.hash;
+      this.currentHistoryIndex = readHistoryIndex(event.state);
+      return;
+    }
+    if (await this.shouldBlockNavigation({
+      from,
+      to: path,
+      action: "pop"
+    })) {
+      this.revertBlockedPopState(event, from);
+      return;
+    }
+    this.currentHistoryPath = path;
+    this.currentHistoryHash = window.location.hash;
+    this.currentInterceptFrom = event.state?.[FARM_INTERCEPT_FROM_KEY];
+    this.currentHistoryIndex = readHistoryIndex(event.state);
+    const navigation = this.startNavigation({
+      from,
+      to: createNavigationLocation(new URL(window.location.href)),
+      action: "pop"
+    });
+    let clientNavigation;
+    try {
+      clientNavigation = await this.clientPlugins?.beginNavigation({
+        from: null,
+        to: window.location.href,
+        action: "pop"
+      });
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      const interceptFrom = typeof event.state?.[FARM_INTERCEPT_FROM_KEY] === "string" ? event.state[FARM_INTERCEPT_FROM_KEY] : void 0;
+      const pageData = await this.fetchPageData(
+        path,
+        true,
+        interceptFrom,
+        false,
+        navigation.controller.signal
+      );
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      if (clientNavigation) {
+        await this.clientPlugins?.markNavigationLoaded(clientNavigation, pageData);
+      }
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      this.updateDocumentMetadata(pageData.metadata);
+      _hydrateFarmI18n(pageData.i18n);
+      if (this.onNavigate) {
+        await this.onNavigate(pageData);
+      }
+      const destinationPath = window.location.pathname + window.location.search;
+      if (window.location.hash) {
+        const target = getHashTargetElement(window.location.hash);
+        if (target) {
+          target.scrollIntoView();
+        } else if (this.options.scrollRestoration) {
+          this.restoreWindowScroll(destinationPath);
+        }
+      } else if (this.options.scrollRestoration) {
+        this.restoreWindowScroll(destinationPath);
+      }
+      if (this.options.scrollRestoration) {
+        this.restoreScrollElements(destinationPath);
+      }
+      if (clientNavigation) {
+        await this.clientPlugins?.resolveNavigation(clientNavigation);
+        void this.clientPlugins?.scheduleNavigationRendered(clientNavigation);
+      }
+      this.finishNavigation(navigation);
+    } catch (error) {
+      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
+      if (clientNavigation) {
+        await this.clientPlugins?.failNavigation(clientNavigation, error);
+      }
+      this.finishNavigation(navigation);
+      console.error("[Farm.js] Popstate navigation error:", error);
+      window.location.reload();
+    }
+  }
+  /**
+   * Check if URL is cached
+   */
+  isCached(path, interceptFrom) {
+    const cached = this.cache.get(getPageDataCacheKey(path, interceptFrom));
+    return cached !== void 0 && Date.now() - cached.timestamp < this.options.cacheMaxAge;
+  }
+  /**
+   * Check if URL is external
+   */
+  isExternalUrl(href) {
+    return href.startsWith("http://") || href.startsWith("https://") || href.startsWith("//");
+  }
+  async shouldBlockNavigation(context) {
+    for (const blocker of this.blockers) {
+      if (await blocker(context)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  evaluateBlockerForUnload(blocker) {
+    const path = window.location.pathname + window.location.search;
+    const result = blocker({ from: path, to: path, action: "replace" });
+    if (result && typeof result !== "boolean") {
+      void result.catch(() => void 0);
+      return true;
+    }
+    return result === true;
+  }
+  shouldBlockUnload() {
+    for (const blocker of this.blockers) {
+      try {
+        if (this.unloadBlockers.get(blocker)?.()) return true;
+      } catch {
+        return true;
+      }
+    }
+    return false;
+  }
+  updateDocumentMetadata(metadata) {
+    applyFarmMetadataToDocument(metadata, window.location.pathname);
+  }
+  startNavigation(options) {
+    this.activeNavigation?.controller.abort("superseded");
+    const navigation = {
+      id: ++this.navigationSequence,
+      controller: new AbortController()
+    };
+    this.activeNavigation = navigation;
+    this.setNavigationState({
+      state: "loading",
+      pending: true,
+      from: options.from,
+      to: options.to,
+      action: options.action,
+      startedAt: Date.now()
+    });
+    return navigation;
+  }
+  isCurrentNavigation(navigation, clientNavigation) {
+    return this.activeNavigation?.id === navigation.id && !navigation.controller.signal.aborted && !clientNavigation?.signal.aborted;
+  }
+  finishNavigation(navigation) {
+    if (this.activeNavigation?.id !== navigation.id) return;
+    this.activeNavigation = void 0;
+    this.setNavigationState(IDLE_NAVIGATION_STATE);
+  }
+  cancelActiveNavigation() {
+    if (!this.activeNavigation) return;
+    this.activeNavigation.controller.abort("superseded");
+    this.activeNavigation = void 0;
+    this.setNavigationState(IDLE_NAVIGATION_STATE);
+  }
+  setNavigationState(state) {
+    this.navigationState = state;
+    for (const listener of this.navigationListeners) {
+      listener(state);
+    }
+  }
+  writePageState(action, state, href, notify = true) {
+    if (typeof window === "undefined") return;
+    const url = href ? resolveFarmNavigationURL(href, window.location.href).toString() : window.location.href;
+    const parsedUrl = new URL(url);
+    const nextPath = parsedUrl.pathname + parsedUrl.search;
+    const historyPath = nextPath + parsedUrl.hash;
+    const nextState = createHistoryState(historyPath, state, window.history.state);
+    if (action === "replace") {
+      window.history.replaceState(nextState, "", url);
+    } else {
+      if (this.currentHistoryIndex != null) {
+        nextState[FARM_HISTORY_INDEX_KEY] = this.currentHistoryIndex + 1;
+      }
+      window.history.pushState(nextState, "", url);
+      this.currentHistoryIndex = this.currentHistoryIndex == null ? null : this.currentHistoryIndex + 1;
+    }
+    this.currentHistoryPath = nextPath;
+    this.currentHistoryHash = parsedUrl.hash;
+    this.currentInterceptFrom = nextState[FARM_INTERCEPT_FROM_KEY];
+    if (notify) notifyHistoryChange("page-state");
+  }
+  /**
+   * Save scroll position for a path
+   */
+  saveScrollPosition(path) {
+    try {
+      sessionStorage.setItem(
+        `farm-scroll-${path}`,
+        JSON.stringify({ x: window.scrollX, y: window.scrollY })
+      );
+      for (const [key, element] of this.scrollElements) {
+        sessionStorage.setItem(
+          getScrollElementStorageKey(path, key),
+          JSON.stringify({ x: element.scrollLeft, y: element.scrollTop })
+        );
+      }
+    } catch {
+    }
+  }
+  /**
+   * Restore the saved window scroll position for a path.
+   */
+  restoreWindowScroll(path) {
+    try {
+      const saved = sessionStorage.getItem(`farm-scroll-${path}`);
+      if (saved) {
+        const { x, y } = JSON.parse(saved);
+        setTimeout(() => window.scrollTo(x, y), 0);
+      }
+    } catch {
+    }
+  }
+  /**
+   * Restore saved scroll positions for every registered scroll element. Keys
+   * are hash-stripped (see getScrollElementStorageKey), so this runs regardless
+   * of whether the destination URL carries a fragment.
+   */
+  restoreScrollElements(path) {
+    try {
+      for (const [key, element] of this.scrollElements) {
+        this.restoreScrollElement(path, key, element);
+      }
+    } catch {
+    }
+  }
+  restoreScrollElement(path, key, element) {
+    try {
+      const saved = sessionStorage.getItem(getScrollElementStorageKey(path, key));
+      if (!saved) return;
+      const { x, y } = JSON.parse(saved);
+      setTimeout(() => {
+        element.scrollLeft = x;
+        element.scrollTop = y;
+      }, 0);
+    } catch {
+    }
+  }
+  /**
+   * Clear the page cache
+   */
+  clearCache() {
+    this.cacheGeneration += 1;
+    this.cache.clear();
+    for (const pending of this.pendingPrefetches.values()) {
+      pending.cacheable = false;
+      pending.resolve(void 0);
+    }
+    this.pendingPrefetches.clear();
+  }
+};
+function readBrowserDeploymentId() {
+  if (typeof window === "undefined") return void 0;
+  const runtimeId = window.__FARM_DEPLOYMENT_ID__;
+  if (typeof runtimeId === "string" && runtimeId) return runtimeId;
+  return document.querySelector('meta[name="farm-deployment-id"]')?.content;
+}
+function dispatchDeploymentMismatch(error) {
+  if (typeof window === "undefined" || typeof CustomEvent === "undefined") return;
+  window.dispatchEvent(new CustomEvent("farm:deployment-mismatch", { detail: error }));
+}
+function getInstalledFarmSPARouter() {
+  if (typeof window === "undefined") return void 0;
+  return window.__FARM_SPA_ROUTER__;
+}
+function getRouter() {
+  if (typeof window === "undefined") {
+    return new SPARouter();
+  }
+  const installedRouter = getInstalledFarmSPARouter();
+  if (installedRouter) {
+    routerInstance = installedRouter;
+    return installedRouter;
+  }
+  if (!routerInstance) {
+    routerInstance = new SPARouter();
+  }
+  return routerInstance;
+}
+function navigateTo(href, options) {
+  return getRouter().navigate(href, options);
+}
+function prefetch(href) {
+  return getRouter().prefetch(href);
+}
+function pushState(state, href) {
+  getRouter().pushState(state, href);
+}
+function replaceState(state, href) {
+  getRouter().replaceState(state, href);
+}
+function readPageState() {
+  if (typeof window === "undefined") return null;
+  const state = window.history.state;
+  if (!state || typeof state !== "object") return null;
+  return state[FARM_PAGE_STATE_KEY] ?? null;
+}
+function createHistoryState(path, pageState, currentState, interceptFrom) {
+  const base = currentState && typeof currentState === "object" ? { ...currentState } : {};
+  const nextState = {
+    ...base,
+    path,
+    [FARM_PAGE_STATE_KEY]: pageState
+  };
+  if (interceptFrom === null) {
+    delete nextState[FARM_INTERCEPT_FROM_KEY];
+  } else if (interceptFrom) {
+    nextState[FARM_INTERCEPT_FROM_KEY] = interceptFrom;
+  }
+  return nextState;
+}
+function getPageDataCacheKey(path, interceptFrom) {
+  return interceptFrom ? `${path}
+intercept:${interceptFrom}` : path;
+}
+function createNavigationLocation(url) {
+  return {
+    href: url.href,
+    pathname: url.pathname,
+    search: url.search,
+    hash: url.hash
+  };
+}
+function getScrollElementStorageKey(path, key) {
+  return `farm-scroll-${path}:${key}`;
+}
+
+// src/client/history-sync.ts
+var FARM_HISTORY_CHANGE_EVENT = "farm:historychange";
+function writeFarmURLSearchHistory(action, href) {
+  const router = getInstalledFarmSPARouter();
+  if (!router) return false;
+  const writeURLSearch = router.writeURLSearch;
+  if (typeof writeURLSearch !== "function") return false;
+  if (window.history.state !== null && typeof window.history.state !== "object") return false;
+  writeURLSearch.call(router, action, href);
+  return true;
+}
+function dispatchHistoryChange(kind) {
+  window.dispatchEvent(
+    new CustomEvent(FARM_HISTORY_CHANGE_EVENT, {
+      detail: { kind }
+    })
+  );
+}
+function notifyHistoryChange(kind) {
+  if (typeof window === "undefined") return;
+  setTimeout(() => {
+    if (kind === "url-search" && !getInstalledFarmSPARouter()) {
+      window.dispatchEvent(new PopStateEvent("popstate"));
+      return;
+    }
+    dispatchHistoryChange(kind);
+  }, 0);
+}
+function notifyRouterHistoryChange() {
+  if (typeof window === "undefined") return;
+  setTimeout(() => dispatchHistoryChange("url-search"), 0);
+}
+function subscribeHistoryChange(listener) {
+  if (typeof window === "undefined") return () => {
+  };
+  window.addEventListener("popstate", listener);
+  window.addEventListener(FARM_HISTORY_CHANGE_EVENT, listener);
+  return () => {
+    window.removeEventListener("popstate", listener);
+    window.removeEventListener(FARM_HISTORY_CHANGE_EVENT, listener);
+  };
+}
+
+export {
+  writeFarmURLSearchHistory,
+  notifyHistoryChange,
+  subscribeHistoryChange,
+  SPARouter,
+  getInstalledFarmSPARouter,
+  getRouter,
+  navigateTo,
+  prefetch,
+  pushState,
+  replaceState,
+  readPageState
+};