@ecopages/react-router 0.2.0-alpha.9 → 0.2.1-beta.0

package/src/router.js

@@ -1,5 +1,6 @@
 import {
   useEffect,
+  useEffectEvent,
   useState,
   useCallback,
   useMemo,
@@ -14,6 +15,7 @@ import { RouterContext } from "./context.js";
 import {
   fetchPageDocument,
   getInterceptDecision,
+  isSamePageHashNavigationHref,
   loadPageModuleFromDocument,
   shouldInterceptClick
 } from "./navigation.js";
@@ -21,7 +23,9 @@ import { morphHead } from "./head-morpher.js";
 import { applyViewTransitionNames } from "./view-transition-utils.js";
 import { manageScroll } from "./manage-scroll.js";
 import { saveScrollPositions, restoreScrollPositions } from "./scroll-persist.js";
-import { getEcoNavigationRuntime } from "@ecopages/core/router/navigation-coordinator";
+import {
+  getEcoNavigationRuntime
+} from "@ecopages/core/router/navigation-coordinator";
 import {
   getAnchorFromNavigationEvent,
   recoverPendingNavigationHref
@@ -52,6 +56,27 @@ function normalizeLayoutKey(value) {
     return trimmed.split("#")[0]?.split("?")[0]?.replace(/\/$/, "") || "layout";
   }
 }
+function hashString(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+function getLayoutSourceSignature(Layout) {
+  const source = Function.prototype.toString.call(Layout).replace(/\s+/g, " ").trim();
+  return hashString(source);
+}
+function getLayoutCacheKey(Layout) {
+  const layoutConfig = Layout.config;
+  const layoutMetaKey = layoutConfig?.__eco?.file || layoutConfig?.__eco?.id;
+  if (layoutMetaKey) {
+    return normalizeLayoutKey(layoutMetaKey);
+  }
+  const layoutNameKey = Layout.displayName || Layout.name || "layout";
+  return `${normalizeLayoutKey(layoutNameKey)}:${getLayoutSourceSignature(Layout)}`;
+}
 function clearLayoutCache() {
   getLayoutCache().clear();
 }
@@ -64,7 +89,7 @@ const PageContent = () => {
     }
     return null;
   }
-  const { Component: Page, props } = pageContext;
+  const { Component: Page, props, refreshPersistedLayout } = pageContext;
   const Layout = getLayoutFromPage(Page);
   const pageElement = createElement(Page, props);
   const layoutProps = props?.locals ? { locals: props.locals } : null;
@@ -73,10 +98,8 @@ const PageContent = () => {
   }
   if (persistLayouts) {
     const layoutCache = getLayoutCache();
-    const layoutConfig = Layout.config;
-    const layoutKeyRaw = layoutConfig?.__eco?.id || Layout.displayName || Layout.name || "layout";
-    const layoutKey = normalizeLayoutKey(layoutKeyRaw);
-    if (!layoutCache.has(layoutKey)) {
+    const layoutKey = getLayoutCacheKey(Layout);
+    if (!layoutCache.has(layoutKey) || refreshPersistedLayout && layoutCache.get(layoutKey) !== Layout) {
       layoutCache.set(layoutKey, Layout);
     }
     const CachedLayout = layoutCache.get(layoutKey);
@@ -92,35 +115,39 @@ function createDeferred() {
   return { promise, resolve };
 }
 function useNavigationCoordinator(navigate, activeNavigationRef, isNavigatingRef, runtimeActiveRef) {
+  const handleCoordinatorNavigate = useEffectEvent(async (request) => {
+    await navigate(request.href, {
+      isPopState: request.direction === "back",
+      pushHistory: request.direction === "forward",
+      skipViewTransition: request.source === "browser-router"
+    });
+    return true;
+  });
+  const handleCoordinatorReload = useEffectEvent(async (request) => {
+    if (activeNavigationRef.current || isNavigatingRef.current) {
+      return;
+    }
+    if (request?.clearCache) {
+      clearLayoutCache();
+    }
+    const currentUrl = window.location.pathname + window.location.search;
+    await navigate(currentUrl, { moduleUrlOverride: request?.moduleUrl });
+  });
+  const handleCleanupBeforeHandoff = useEffectEvent(async () => {
+    runtimeActiveRef.current = false;
+    window.__ECO_PAGES__?.react?.cleanupPageRoot?.();
+  });
   useEffect(() => {
-    if (typeof window === "undefined") return;
     const navigationRuntime = getEcoNavigationRuntime(window);
     let unregisterRuntime = null;
     const unregister = navigationRuntime.register({
       owner: "react-router",
-      navigate: async (request) => {
-        await navigate(request.href, {
-          isPopState: request.direction === "back",
-          pushHistory: request.direction === "forward",
-          skipViewTransition: request.source === "browser-router"
-        });
-        return true;
-      },
-      reloadCurrentPage: async (request) => {
-        if (activeNavigationRef.current || isNavigatingRef.current) {
-          return;
-        }
-        if (request?.clearCache) {
-          clearLayoutCache();
-        }
-        const currentUrl = window.location.pathname + window.location.search;
-        await navigate(currentUrl);
-      },
+      navigate: handleCoordinatorNavigate,
+      reloadCurrentPage: handleCoordinatorReload,
       cleanupBeforeHandoff: async () => {
-        runtimeActiveRef.current = false;
         unregisterRuntime?.();
         unregisterRuntime = null;
-        window.__ECO_PAGES__?.react?.cleanupPageRoot?.();
+        await handleCleanupBeforeHandoff();
       }
     });
     unregisterRuntime = unregister;
@@ -132,11 +159,15 @@ function useNavigationCoordinator(navigate, activeNavigationRef, isNavigatingRef
       unregisterRuntime?.();
       unregisterRuntime = null;
     };
-  }, [activeNavigationRef, isNavigatingRef, navigate, runtimeActiveRef]);
+  }, [runtimeActiveRef]);
 }
 const EcoRouter = ({ page, pageProps, options: userOptions, children }) => {
   const options = useMemo(() => ({ ...DEFAULT_OPTIONS, ...userOptions }), [userOptions]);
-  const [currentPage, setCurrentPage] = useState({ Component: page, props: pageProps });
+  const [currentPage, setCurrentPage] = useState({
+    Component: page,
+    props: pageProps,
+    refreshPersistedLayout: false
+  });
   const [isNavigating, setIsNavigating] = useState(false);
   const pendingRenderRef = useRef(null);
   const activeNavigationRef = useRef(null);
@@ -145,34 +176,24 @@ const EcoRouter = ({ page, pageProps, options: userOptions, children }) => {
   const pendingPointerNavigationRef = useRef(null);
   const pendingHoverNavigationRef = useRef(null);
   const queuedNavigationHrefRef = useRef(null);
-  const pendingScrollRestoreRef = useRef(null);
+  const committedPathRef = useRef(
+    typeof window !== "undefined" ? window.location.pathname + window.location.search : ""
+  );
   const previousUrlRef = useRef(typeof window !== "undefined" ? window.location.href : "");
   useEffect(() => {
     isNavigatingRef.current = isNavigating;
   }, [isNavigating]);
   useEffect(() => {
-    setCurrentPage({ Component: page, props: pageProps });
+    setCurrentPage({ Component: page, props: pageProps, refreshPersistedLayout: true });
   }, [page, pageProps]);
   useEffect(() => {
+    committedPathRef.current = window.location.pathname + window.location.search;
     applyViewTransitionNames();
-  }, [currentPage]);
-  useEffect(() => {
     const pendingRender = pendingRenderRef.current;
     if (pendingRender && currentPage.Component === pendingRender.page.Component && currentPage.props === pendingRender.page.props) {
       pendingRender.resolve();
       pendingRenderRef.current = null;
     }
-  }, [currentPage]);
-  useEffect(() => {
-    return () => {
-      activeNavigationRef.current?.cancel();
-      pendingRenderRef.current?.resolve();
-      pendingRenderRef.current = null;
-      queuedNavigationHrefRef.current = null;
-    };
-  }, []);
-  useEffect(() => {
-    if (typeof window === "undefined") return;
     const url = new URL(window.location.href);
     const previousUrl = new URL(previousUrlRef.current);
     if (url.href !== previousUrl.href) {
@@ -182,15 +203,23 @@ const EcoRouter = ({ page, pageProps, options: userOptions, children }) => {
       });
       previousUrlRef.current = url.href;
     }
-    if (pendingScrollRestoreRef.current) {
-      const { url: targetUrl, isPopState } = pendingScrollRestoreRef.current;
-      restoreScrollPositions(targetUrl, isPopState);
-      pendingScrollRestoreRef.current = null;
-    }
   }, [currentPage, options.scrollBehavior, options.smoothScroll]);
+  useEffect(() => {
+    return () => {
+      activeNavigationRef.current?.cancel();
+      pendingRenderRef.current?.resolve();
+      pendingRenderRef.current = null;
+      queuedNavigationHrefRef.current = null;
+    };
+  }, []);
   const navigate = useCallback(
     async (url, navigationOptions = {}) => {
-      const { isPopState = false, pushHistory = false, skipViewTransition = false } = navigationOptions;
+      const {
+        isPopState = false,
+        pushHistory = false,
+        skipViewTransition = false,
+        moduleUrlOverride
+      } = navigationOptions;
       const navigationRuntime = getEcoNavigationRuntime(window);
       const navigation = navigationRuntime.beginNavigationTransaction();
       activeNavigationRef.current = navigation;
@@ -203,6 +232,16 @@ const EcoRouter = ({ page, pageProps, options: userOptions, children }) => {
           props
         };
       };
+      const preparePendingRender = (nextPage) => {
+        pendingRenderRef.current?.resolve();
+        const renderDfd = createDeferred();
+        pendingRenderRef.current = {
+          navigationId,
+          page: nextPage,
+          resolve: renderDfd.resolve
+        };
+        return renderDfd.promise;
+      };
       let navigationCommitPromise = null;
       try {
         setIsNavigating(true);
@@ -212,32 +251,38 @@ const EcoRouter = ({ page, pageProps, options: userOptions, children }) => {
           window.location.href = url;
           return;
         }
-        const result = await loadPageModuleFromDocument(fetchedPage.doc, fetchedPage.finalPath);
+        const result = await loadPageModuleFromDocument(fetchedPage.doc, fetchedPage.finalPath, {
+          moduleUrlOverride
+        });
         if (isStale()) return;
         if (result) {
           const { Component, props, doc, finalPath, moduleUrl } = result;
-          const nextPage = { Component, props };
-          const cleanupHead = await morphHead(doc);
+          const nextPage = { Component, props, refreshPersistedLayout: Boolean(moduleUrlOverride) };
+          const { cleanup: cleanupHead, flushRerunScripts } = await morphHead(doc);
+          const finalizeCommittedNavigation = () => {
+            committedPathRef.current = finalPath;
+            flushRerunScripts();
+            cleanupHead();
+            applyViewTransitionNames();
+            restoreScrollPositions(finalPath, isPopState);
+          };
+          const commitNextPage = () => {
+            commitPageData(moduleUrl, props);
+            setCurrentPage(nextPage);
+          };
           if (isStale()) {
             cleanupHead();
             return;
           }
           applyViewTransitionNames();
+          saveScrollPositions();
           if (pushHistory) {
             window.history.pushState(null, "", finalPath);
           } else if (finalPath !== url) {
             window.history.replaceState(null, "", finalPath);
           }
-          saveScrollPositions();
-          pendingScrollRestoreRef.current = { url, isPopState };
           if (!skipViewTransition && options.viewTransitions && document.startViewTransition) {
-            pendingRenderRef.current?.resolve();
-            const renderDfd = createDeferred();
-            pendingRenderRef.current = {
-              navigationId,
-              page: nextPage,
-              resolve: renderDfd.resolve
-            };
+            const renderPromise = preparePendingRender(nextPage);
             navigationCommitPromise = new Promise((resolve) => {
               document.startViewTransition(async () => {
                 try {
@@ -250,15 +295,13 @@ const EcoRouter = ({ page, pageProps, options: userOptions, children }) => {
                     return;
                   }
                   startTransition(() => {
-                    commitPageData(moduleUrl, props);
-                    setCurrentPage(nextPage);
+                    commitNextPage();
                   });
-                  await renderDfd.promise;
+                  await renderPromise;
                   if (isStale()) {
                     return;
                   }
-                  cleanupHead();
-                  applyViewTransitionNames();
+                  finalizeCommittedNavigation();
                 } finally {
                   resolve();
                 }
@@ -266,10 +309,14 @@ const EcoRouter = ({ page, pageProps, options: userOptions, children }) => {
             });
             await navigationCommitPromise;
           } else {
-            commitPageData(moduleUrl, props);
-            setCurrentPage(nextPage);
-            cleanupHead();
-            applyViewTransitionNames();
+            const renderPromise = preparePendingRender(nextPage);
+            commitNextPage();
+            await renderPromise;
+            if (isStale()) {
+              cleanupHead();
+              return;
+            }
+            finalizeCommittedNavigation();
           }
         } else {
           if (isStale()) return;
@@ -293,11 +340,12 @@ const EcoRouter = ({ page, pageProps, options: userOptions, children }) => {
       } finally {
         const shouldReplayQueuedNavigation = activeNavigationRef.current?.id === navigationId;
         const queuedNavigationHref = shouldReplayQueuedNavigation ? queuedNavigationHrefRef.current : null;
+        const queuedNavigationPath = queuedNavigationHref ? new URL(queuedNavigationHref, window.location.origin).pathname + new URL(queuedNavigationHref, window.location.origin).search : null;
         navigation.complete();
         if (activeNavigationRef.current?.id === navigationId) {
           activeNavigationRef.current = null;
         }
-        if (queuedNavigationHref && queuedNavigationHref !== window.location.pathname + window.location.search) {
+        if (queuedNavigationHref && queuedNavigationPath !== committedPathRef.current) {
           queuedNavigationHrefRef.current = null;
           if (runtimeActiveRef.current) {
             void navigate(queuedNavigationHref, { pushHistory: true });
@@ -317,132 +365,150 @@ const EcoRouter = ({ page, pageProps, options: userOptions, children }) => {
     },
     [options.viewTransitions]
   );
-  useEffect(() => {
-    const getLinkFromEvent = (event) => getAnchorFromNavigationEvent(event, options.linkSelector);
-    const getRecoveredPointerHref = () => {
-      const href = recoverPendingNavigationHref(
-        pendingPointerNavigationRef.current,
-        !!activeNavigationRef.current || isNavigatingRef.current,
-        performance.now()
-      );
-      if (!href) {
-        pendingPointerNavigationRef.current = null;
-      }
-      return href;
-    };
-    const getRecoveredHoverHref = () => {
-      const href = recoverPendingNavigationHref(
-        pendingHoverNavigationRef.current,
-        !!activeNavigationRef.current || isNavigatingRef.current,
-        performance.now()
-      );
-      if (!href) {
-        pendingHoverNavigationRef.current = null;
-      }
-      return href;
+  const getLinkFromEvent = useEffectEvent(
+    (event) => getAnchorFromNavigationEvent(event, options.linkSelector)
+  );
+  const getRecoveredPointerHref = useEffectEvent(() => {
+    const href = recoverPendingNavigationHref(
+      pendingPointerNavigationRef.current,
+      !!activeNavigationRef.current || isNavigatingRef.current,
+      performance.now()
+    );
+    if (!href) {
+      pendingPointerNavigationRef.current = null;
+    }
+    return href;
+  });
+  const getRecoveredHoverHref = useEffectEvent(() => {
+    const href = recoverPendingNavigationHref(
+      pendingHoverNavigationRef.current,
+      !!activeNavigationRef.current || isNavigatingRef.current,
+      performance.now()
+    );
+    if (!href) {
+      pendingHoverNavigationRef.current = null;
+    }
+    return href;
+  });
+  const handleHoverIntent = useEffectEvent((event) => {
+    if (!runtimeActiveRef.current) {
+      return;
+    }
+    const link = getLinkFromEvent(event);
+    if (!link) {
+      return;
+    }
+    const decision = getInterceptDecision(event, link, options);
+    if (!decision.shouldIntercept) {
+      return;
+    }
+    pendingHoverNavigationRef.current = {
+      href: link.getAttribute("href"),
+      timestamp: performance.now()
     };
-    const handleHoverIntent = (event) => {
-      if (!runtimeActiveRef.current) {
-        return;
-      }
-      const link = getLinkFromEvent(event);
-      if (!link) {
-        return;
-      }
-      const decision = getInterceptDecision(event, link, options);
-      if (!decision.shouldIntercept) {
-        return;
-      }
-      pendingHoverNavigationRef.current = {
-        href: link.getAttribute("href"),
-        timestamp: performance.now()
-      };
+    queuedNavigationHrefRef.current = link.getAttribute("href");
+  });
+  const handlePointerDown = useEffectEvent((event) => {
+    if (!runtimeActiveRef.current) {
+      pendingPointerNavigationRef.current = null;
+      return;
+    }
+    const link = getLinkFromEvent(event);
+    if (!link) {
+      pendingPointerNavigationRef.current = null;
+      return;
+    }
+    const decision = getInterceptDecision(event, link, options);
+    pendingPointerNavigationRef.current = decision.shouldIntercept ? {
+      href: link.getAttribute("href"),
+      timestamp: performance.now()
+    } : null;
+    if (decision.shouldIntercept && (activeNavigationRef.current || isNavigatingRef.current)) {
       queuedNavigationHrefRef.current = link.getAttribute("href");
-    };
-    const handlePointerDown = (event) => {
-      if (!runtimeActiveRef.current) {
-        pendingPointerNavigationRef.current = null;
-        return;
-      }
-      const link = getLinkFromEvent(event);
-      if (!link) {
-        pendingPointerNavigationRef.current = null;
-        return;
-      }
-      const decision = getInterceptDecision(event, link, options);
-      pendingPointerNavigationRef.current = decision.shouldIntercept ? {
-        href: link.getAttribute("href"),
-        timestamp: performance.now()
-      } : null;
-      if (decision.shouldIntercept && (activeNavigationRef.current || isNavigatingRef.current)) {
-        queuedNavigationHrefRef.current = link.getAttribute("href");
-      }
-    };
-    const handleClick = (event) => {
-      if (!runtimeActiveRef.current) {
-        pendingPointerNavigationRef.current = null;
-        pendingHoverNavigationRef.current = null;
+    }
+  });
+  const handleClick = useEffectEvent((event) => {
+    if (!runtimeActiveRef.current) {
+      pendingPointerNavigationRef.current = null;
+      pendingHoverNavigationRef.current = null;
+      return;
+    }
+    const link = getLinkFromEvent(event);
+    if (!link) {
+      const recoveredHref = getRecoveredPointerHref() ?? getRecoveredHoverHref();
+      pendingPointerNavigationRef.current = null;
+      pendingHoverNavigationRef.current = null;
+      if (!recoveredHref) {
         return;
       }
-      const link = getLinkFromEvent(event);
-      if (!link) {
-        const recoveredHref = getRecoveredPointerHref() ?? getRecoveredHoverHref();
-        pendingPointerNavigationRef.current = null;
-        pendingHoverNavigationRef.current = null;
-        if (!recoveredHref) {
-          return;
-        }
-        event.preventDefault();
+      if (isSamePageHashNavigationHref(recoveredHref)) {
         queuedNavigationHrefRef.current = null;
-        const recoveredUrl = new URL(recoveredHref, window.location.origin);
-        navigate(recoveredUrl.pathname + recoveredUrl.search, { pushHistory: true });
         return;
       }
-      if (!shouldInterceptClick(event, link, options)) {
-        if (options.debug) {
-          const decision = getInterceptDecision(event, link, options);
-          if (!decision.shouldIntercept) {
-            console.debug("[EcoRouter] Not intercepting link click:", decision.reason, link.href);
-          }
-        }
-        pendingPointerNavigationRef.current = null;
-        pendingHoverNavigationRef.current = null;
-        return;
-      }
-      pendingPointerNavigationRef.current = null;
-      pendingHoverNavigationRef.current = null;
       event.preventDefault();
       queuedNavigationHrefRef.current = null;
-      const href = link.getAttribute("href");
-      const url = new URL(href, window.location.origin);
+      const recoveredUrl = new URL(recoveredHref, window.location.href);
+      navigate(recoveredUrl.pathname + recoveredUrl.search, { pushHistory: true });
+      return;
+    }
+    if (!shouldInterceptClick(event, link, options)) {
       if (options.debug) {
-        console.debug("[EcoRouter] Intercepting navigation:", url.pathname + url.search);
+        const decision = getInterceptDecision(event, link, options);
+        if (!decision.shouldIntercept) {
+          console.debug("[EcoRouter] Not intercepting link click:", decision.reason, link.href);
+        }
       }
-      navigate(url.pathname + url.search, { pushHistory: true });
+      pendingPointerNavigationRef.current = null;
+      pendingHoverNavigationRef.current = null;
+      return;
+    }
+    pendingPointerNavigationRef.current = null;
+    pendingHoverNavigationRef.current = null;
+    event.preventDefault();
+    queuedNavigationHrefRef.current = null;
+    const href = link.getAttribute("href");
+    const url = new URL(href, window.location.origin);
+    if (options.debug) {
+      console.debug("[EcoRouter] Intercepting navigation:", url.pathname + url.search);
+    }
+    navigate(url.pathname + url.search, { pushHistory: true });
+  });
+  const handlePopState = useEffectEvent(() => {
+    if (!runtimeActiveRef.current) {
+      return;
+    }
+    navigate(window.location.pathname + window.location.search, { isPopState: true });
+  });
+  useEffect(() => {
+    const onHoverIntent = (event) => {
+      handleHoverIntent(event);
     };
-    const handlePopState = () => {
-      if (!runtimeActiveRef.current) {
-        return;
-      }
-      navigate(window.location.pathname + window.location.search, { isPopState: true });
+    const onPointerDown = (event) => {
+      handlePointerDown(event);
     };
-    document.addEventListener("mouseover", handleHoverIntent, true);
-    document.addEventListener("pointerover", handleHoverIntent, true);
-    document.addEventListener("mousemove", handleHoverIntent, true);
-    document.addEventListener("pointermove", handleHoverIntent, true);
-    document.addEventListener("pointerdown", handlePointerDown, true);
-    document.addEventListener("click", handleClick, true);
-    window.addEventListener("popstate", handlePopState);
+    const onClick = (event) => {
+      handleClick(event);
+    };
+    const onPopState = () => {
+      handlePopState();
+    };
+    document.addEventListener("mouseover", onHoverIntent, true);
+    document.addEventListener("pointerover", onHoverIntent, true);
+    document.addEventListener("mousemove", onHoverIntent, true);
+    document.addEventListener("pointermove", onHoverIntent, true);
+    document.addEventListener("pointerdown", onPointerDown, true);
+    document.addEventListener("click", onClick, true);
+    window.addEventListener("popstate", onPopState);
     return () => {
-      document.removeEventListener("mouseover", handleHoverIntent, true);
-      document.removeEventListener("pointerover", handleHoverIntent, true);
-      document.removeEventListener("mousemove", handleHoverIntent, true);
-      document.removeEventListener("pointermove", handleHoverIntent, true);
-      document.removeEventListener("pointerdown", handlePointerDown, true);
-      document.removeEventListener("click", handleClick, true);
-      window.removeEventListener("popstate", handlePopState);
+      document.removeEventListener("mouseover", onHoverIntent, true);
+      document.removeEventListener("pointerover", onHoverIntent, true);
+      document.removeEventListener("mousemove", onHoverIntent, true);
+      document.removeEventListener("pointermove", onHoverIntent, true);
+      document.removeEventListener("pointerdown", onPointerDown, true);
+      document.removeEventListener("click", onClick, true);
+      window.removeEventListener("popstate", onPopState);
     };
-  }, [navigate, options, runtimeActiveRef]);
+  }, []);
   useNavigationCoordinator(navigate, activeNavigationRef, isNavigatingRef, runtimeActiveRef);
   return createElement(
     RouterContext.Provider,

package/src/scroll-persist.js

@@ -28,19 +28,27 @@ function restoreScrollPositions(targetUrl, isPopState) {
     currentScrollSnapshot = null;
     return;
   }
-  requestAnimationFrame(() => {
+  const restore = (remainingAttempts) => {
     requestAnimationFrame(() => {
+      const restoredKeys = /* @__PURE__ */ new Set();
       document.querySelectorAll(PERSIST_SELECTOR).forEach((el) => {
         const key = getElementKey(el);
-        if (key && positions.has(key)) {
-          const pos = positions.get(key);
-          el.scrollTop = pos.top;
-          el.scrollLeft = pos.left;
+        if (!key || !positions.has(key)) {
+          return;
         }
+        const pos = positions.get(key);
+        el.scrollTop = pos.top;
+        el.scrollLeft = pos.left;
+        restoredKeys.add(key);
       });
-      currentScrollSnapshot = null;
+      if (restoredKeys.size === positions.size || remainingAttempts <= 1) {
+        currentScrollSnapshot = null;
+        return;
+      }
+      setTimeout(() => restore(remainingAttempts - 1), 50);
     });
-  });
+  };
+  restore(20);
 }
 function getScrollPositions(url) {
   return urlScrollStore.get(url);

package/CHANGELOG.md

@@ -1,19 +0,0 @@
-# Changelog
-
-All notable changes to `@ecopages/react-router` are documented here.
-
-> **Note:** Changelog tracking begins at version `0.2.0`. Changes prior to this release are not recorded here but are available in the git history.
-
-## [UNRELEASED] — TBD
-
-### Bug Fixes
-
-- Fixed React-to-non-React handoffs to replay queued clicks through the next active runtime and reuse prefetched HTML documents instead of forcing a second fetch.
-- Fixed stale handoff cleanup and fallback races so older React-router or browser-router navigations cannot overwrite a newer navigation.
-- Standardized React route payload reads on `window.__ECO_PAGES__.page` and explicit document owner markers so mixed-router page ownership stays stable.
-- Restored current-page HMR refreshes with persist layouts enabled by targeting the active React-router owner.
-
-### Refactoring
-
-- Routed browser handoff and current-page reloads through the shared navigation coordinator.
-- Updated package metadata for the current core, esbuild adapter, and React peer dependency surface.

package/browser.ts

@@ -1,17 +0,0 @@
-/**
- * Browser entry point for @ecopages/react-router.
- * This file exports only the client-side components needed for hydration.
- * @module
- */
-
-export { EcoRouter, PageContent } from './src/router.ts';
-export type { EcoRouterProps } from './src/router.ts';
-
-export { useRouter } from './src/context.ts';
-export type { RouterContextValue } from './src/context.ts';
-export { EcoPropsScript } from './src/props-script.ts';
-export type { EcoPropsScriptProps } from './src/props-script.ts';
-
-export { morphHead } from './src/head-morpher.ts';
-
-export type { PageState } from './src/navigation.ts';