@ossido-labs/ossido-router 0.1.0

package/dist/esm/components/RouterContext.d.ts

@@ -0,0 +1,56 @@
+import type { Router } from '../router';
+import type { ServerInitialLocation } from '../types';
+/** How to reflect a committed navigation in the browser (history + scroll). */
+export interface NavigationCommitOptions {
+    history?: {
+        type: 'pushState' | 'replaceState';
+        path: string;
+    };
+    scroll?: boolean;
+    /**
+     * Override the app's `viewTransitions` config for this navigation: `true`
+     * forces a view transition, `false` skips it. Defaults to the config value.
+     */
+    viewTransition?: boolean;
+}
+export interface ParsedLocation {
+    href: string;
+    pathname: string;
+    search: Record<string, string>;
+    searchStr: string;
+    hash: string;
+}
+export interface RouterContextValue {
+    router: Router;
+    location: ParsedLocation;
+    /**
+     * Incremented on every navigation (and on error retry / a manual
+     * `refetchProps`). Combined with the
+     * pathname it forms the data-resource key, so each navigation gets a fresh
+     * resource (a refetch).
+     *
+     * Initialized to `0` identically on server and client and never changed
+     * during the initial mount — otherwise the boundary would remount and flash
+     * the loading fallback over server-rendered content (hydration mismatch).
+     */
+    navigationId: number;
+    /**
+     * Start a navigation to `loc`. Unless the destination has a `loading.tsx`,
+     * its data is prefetched first and the navigation is only committed once the
+     * data is ready — so the current page stays until then (no blank flash), even
+     * across a layout change. `options` carries the browser history/scroll update
+     * to apply at commit time.
+     */
+    updateLocation: (loc: ParsedLocation, options?: NavigationCommitOptions) => void;
+    /**
+     * Re-run the current route's data load (a refetch). Used by the error
+     * boundary `reset` and by `useRouter().refetchProps`.
+     */
+    retry: () => void;
+}
+export declare const RouterContext: import("react").Context<RouterContextValue>;
+export declare function getInitialLocation(serverPayloadLocation: ServerInitialLocation): ParsedLocation;
+/**
+ * @warning THIS SHOULD NOT BE EXPOSED TO USERLAND
+ */
+export declare function useRouterContext(): RouterContextValue;

package/dist/esm/components/RouterContext.js

@@ -0,0 +1,32 @@
+import { createContext, useContext } from "react";
+
+//#region src/components/RouterContext.tsx
+const isServerSide = typeof window === "undefined";
+const RouterContext = createContext({});
+function getInitialLocation(serverPayloadLocation) {
+	if (isServerSide) return {
+		pathname: serverPayloadLocation.pathname || "",
+		hash: "",
+		href: serverPayloadLocation.href || "",
+		searchStr: serverPayloadLocation.searchStr || "",
+		search: Object.fromEntries(new URLSearchParams(serverPayloadLocation.searchStr))
+	};
+	const { pathname, hash, href, search } = window.location;
+	return {
+		pathname,
+		hash,
+		href,
+		searchStr: search,
+		search: Object.fromEntries(new URLSearchParams(search))
+	};
+}
+/**
+* @warning THIS SHOULD NOT BE EXPOSED TO USERLAND
+*/
+function useRouterContext() {
+	return useContext(RouterContext);
+}
+
+//#endregion
+export { RouterContext, getInitialLocation, useRouterContext };
+//# sourceMappingURL=RouterContext.js.map

package/dist/esm/components/RouterContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouterContext.js","names":[],"sources":["../../../src/components/RouterContext.tsx"],"sourcesContent":["import { createContext, useContext } from 'react';\n\nimport type { Router } from '../router';\nimport type { ServerInitialLocation } from '../types';\n\n/** How to reflect a committed navigation in the browser (history + scroll). */\nexport interface NavigationCommitOptions {\n  history?: { type: 'pushState' | 'replaceState'; path: string };\n  scroll?: boolean;\n  /**\n   * Override the app's `viewTransitions` config for this navigation: `true`\n   * forces a view transition, `false` skips it. Defaults to the config value.\n   */\n  viewTransition?: boolean;\n}\n\nconst isServerSide = typeof window === 'undefined';\n\nexport interface ParsedLocation {\n  href: string;\n  pathname: string;\n  search: Record<string, string>;\n  searchStr: string;\n  hash: string;\n}\n\nexport interface RouterContextValue {\n  router: Router;\n  location: ParsedLocation;\n  /**\n   * Incremented on every navigation (and on error retry / a manual\n   * `refetchProps`). Combined with the\n   * pathname it forms the data-resource key, so each navigation gets a fresh\n   * resource (a refetch).\n   *\n   * Initialized to `0` identically on server and client and never changed\n   * during the initial mount — otherwise the boundary would remount and flash\n   * the loading fallback over server-rendered content (hydration mismatch).\n   */\n  navigationId: number;\n  /**\n   * Start a navigation to `loc`. Unless the destination has a `loading.tsx`,\n   * its data is prefetched first and the navigation is only committed once the\n   * data is ready — so the current page stays until then (no blank flash), even\n   * across a layout change. `options` carries the browser history/scroll update\n   * to apply at commit time.\n   */\n  updateLocation: (\n    loc: ParsedLocation,\n    options?: NavigationCommitOptions,\n  ) => void;\n  /**\n   * Re-run the current route's data load (a refetch). Used by the error\n   * boundary `reset` and by `useRouter().refetchProps`.\n   */\n  retry: () => void;\n}\n\nexport const RouterContext = createContext({} as RouterContextValue);\n\nexport function getInitialLocation(\n  serverPayloadLocation: ServerInitialLocation,\n): ParsedLocation {\n  if (isServerSide) {\n    return {\n      pathname: serverPayloadLocation.pathname || '',\n      hash: '',\n      href: serverPayloadLocation.href || '',\n      searchStr: serverPayloadLocation.searchStr || '',\n      search: Object.fromEntries(\n        new URLSearchParams(serverPayloadLocation.searchStr),\n      ),\n    };\n  }\n\n  const { pathname, hash, href, search } = window.location;\n  return {\n    pathname,\n    hash,\n    href,\n    searchStr: search,\n    search: Object.fromEntries(new URLSearchParams(search)),\n  };\n}\n\n/**\n * @warning THIS SHOULD NOT BE EXPOSED TO USERLAND\n */\nexport function useRouterContext(): RouterContextValue {\n  return useContext(RouterContext);\n}\n"],"mappings":";;;AAgBA,MAAM,eAAe,OAAO,WAAW;AA0CvC,MAAa,gBAAgB,cAAc,CAAC,CAAuB;AAEnE,SAAgB,mBACd,uBACgB;CAChB,IAAI,cACF,OAAO;EACL,UAAU,sBAAsB,YAAY;EAC5C,MAAM;EACN,MAAM,sBAAsB,QAAQ;EACpC,WAAW,sBAAsB,aAAa;EAC9C,QAAQ,OAAO,YACb,IAAI,gBAAgB,sBAAsB,SAAS,CACrD;CACF;CAGF,MAAM,EAAE,UAAU,MAAM,MAAM,WAAW,OAAO;CAChD,OAAO;EACL;EACA;EACA;EACA,WAAW;EACX,QAAQ,OAAO,YAAY,IAAI,gBAAgB,MAAM,CAAC;CACxD;AACF;;;;AAKA,SAAgB,mBAAuC;CACrD,OAAO,WAAW,aAAa;AACjC"}

package/dist/esm/components/RouterContextProvider.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from 'react';
+import type { Router } from '../router';
+import type { ServerInitialLocation } from '../types';
+interface RouterContextProviderProps {
+    router: Router;
+    serverInitialLocation: ServerInitialLocation;
+    children: ReactNode;
+}
+export declare function RouterContextProvider({ router, serverInitialLocation, children, }: RouterContextProviderProps): ReactNode;
+export {};

package/dist/esm/components/RouterContextProvider.js

@@ -0,0 +1,122 @@
+import { buildResourceKey, getOrCreateResource } from "../data/resourceCache.js";
+import { RouterContext, getInitialLocation } from "./RouterContext.js";
+import { fromUrlToParsedLocation } from "../utils/from-url-to-parsed-location.js";
+import { matchRoute } from "../utils/match-route.js";
+import { VIEW_TRANSITIONS_ENABLED, runCommit } from "../utils/view-transition.js";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/components/RouterContextProvider.tsx
+const isServerSide = typeof window === "undefined";
+/**
+* For a route with a `loading.tsx`, wait up to this long for the destination to
+* become ready before committing (and thereby showing the loading fallback). A
+* navigation that resolves within this window commits with its data already
+* resolved — so `use()` reads it synchronously and no fallback flashes. Only
+* genuinely slow navigations fall through and show the loading screen.
+*/
+const FALLBACK_DELAY_MS = 100;
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const CRITICAL_CSS_PATH = "/vite-server/ossido_internal__critical_css";
+const CRITICAL_CSS_LINK_SELECTOR = `link[href*="${CRITICAL_CSS_PATH.split("/").pop()}"]`;
+/**
+* Warm a route's critical CSS before navigating to it, so the
+* `<link rel="stylesheet" precedence>` that renders on arrival doesn't suspend
+* (and flash the loading fallback) while the stylesheet downloads. Resolves once
+* the resource is cached; never rejects.
+*/
+function preloadCriticalCss(componentId) {
+	const href = `${CRITICAL_CSS_PATH}?componentId=${componentId}`;
+	if (document.querySelector(`link[rel="preload"][href="${href}"]`)) return Promise.resolve();
+	return new Promise((resolve) => {
+		const link = document.createElement("link");
+		link.rel = "preload";
+		link.as = "style";
+		link.href = href;
+		link.onload = () => resolve();
+		link.onerror = () => resolve();
+		document.head.appendChild(link);
+	});
+}
+function RouterContextProvider({ router, serverInitialLocation, children }) {
+	const [location, setLocation] = useState(() => getInitialLocation(serverInitialLocation));
+	const [navigationId, setNavigationId] = useState(0);
+	const updateLocation = useCallback((newLocation, options = {}) => {
+		const useViewTransition = !(newLocation.pathname === location.pathname && newLocation.searchStr === location.searchStr) && (options.viewTransition ?? VIEW_TRANSITIONS_ENABLED);
+		const commit = () => {
+			runCommit(() => {
+				setNavigationId((id) => id + 1);
+				setLocation(newLocation);
+				if (options.history) {
+					const { type, path } = options.history;
+					window.history[type](path, "", path);
+				}
+				if (options.scroll) window.scroll(0, 0);
+			}, useViewTransition);
+		};
+		const targetRoute = matchRoute(router.routesById, newLocation.pathname);
+		if (!targetRoute || isServerSide) {
+			commit();
+			return;
+		}
+		const pending = [];
+		if (targetRoute.options.hasHandler) pending.push(getOrCreateResource(buildResourceKey(navigationId + 1, newLocation), targetRoute, newLocation));
+		const criticalCssEnabled = !!document.querySelector(CRITICAL_CSS_LINK_SELECTOR);
+		for (let node = targetRoute; node; node = node.isRoot ? void 0 : node.options.getParentRoute?.()) {
+			const preloadComponent = node.component.preload;
+			if (preloadComponent) pending.push(preloadComponent());
+			const componentId = node.filePath || node.id;
+			if (criticalCssEnabled && componentId) pending.push(preloadCriticalCss(componentId));
+		}
+		if (pending.length === 0) {
+			commit();
+			return;
+		}
+		const ready = Promise.all(pending);
+		if (targetRoute.options.loadingComponent) Promise.race([ready, wait(FALLBACK_DELAY_MS)]).then(commit, commit);
+		else ready.then(commit, commit);
+	}, [
+		router,
+		navigationId,
+		location
+	]);
+	const retry = useCallback(() => {
+		setNavigationId((id) => id + 1);
+	}, []);
+	/**
+	* Listen browser navigation events. The browser has already updated the URL,
+	* so this only mirrors it into router state (and bumps the navigation id so
+	* the route refetches — preserving back/forward data loads).
+	*/
+	useEffect(() => {
+		const updateLocationOnPopStateChange = ({ target }) => {
+			const { location: targetLocation } = target;
+			updateLocation(fromUrlToParsedLocation(targetLocation.href));
+		};
+		window.addEventListener("popstate", updateLocationOnPopStateChange);
+		return () => {
+			window.removeEventListener("popstate", updateLocationOnPopStateChange);
+		};
+	}, [updateLocation]);
+	const contextValue = useMemo(() => ({
+		router,
+		location,
+		navigationId,
+		updateLocation,
+		retry
+	}), [
+		location,
+		router,
+		navigationId,
+		updateLocation,
+		retry
+	]);
+	return /* @__PURE__ */ jsx(RouterContext.Provider, {
+		value: contextValue,
+		children
+	});
+}
+
+//#endregion
+export { RouterContextProvider };
+//# sourceMappingURL=RouterContextProvider.js.map

package/dist/esm/components/RouterContextProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouterContextProvider.js","names":[],"sources":["../../../src/components/RouterContextProvider.tsx"],"sourcesContent":["import { useState, useEffect, useCallback, useMemo } from 'react';\nimport type { ReactNode } from 'react';\n\nimport type { Router } from '../router';\nimport type { Route } from '../route';\nimport type { ServerInitialLocation } from '../types';\nimport { fromUrlToParsedLocation } from '../utils/from-url-to-parsed-location';\nimport { matchRoute } from '../utils/match-route';\nimport { runCommit, VIEW_TRANSITIONS_ENABLED } from '../utils/view-transition';\nimport { buildResourceKey, getOrCreateResource } from '../data/resourceCache';\n\nimport {\n  RouterContext,\n  getInitialLocation,\n  type ParsedLocation,\n  type NavigationCommitOptions,\n  type RouterContextValue,\n} from './RouterContext';\n\nconst isServerSide = typeof window === 'undefined';\n\n/**\n * For a route with a `loading.tsx`, wait up to this long for the destination to\n * become ready before committing (and thereby showing the loading fallback). A\n * navigation that resolves within this window commits with its data already\n * resolved — so `use()` reads it synchronously and no fallback flashes. Only\n * genuinely slow navigations fall through and show the loading screen.\n */\nconst FALLBACK_DELAY_MS = 100;\n\nconst wait = (ms: number): Promise<void> =>\n  new Promise((resolve) => setTimeout(resolve, ms));\n\n// Kept in sync with `CriticalCss`. Its `<link rel=\"stylesheet\" precedence>` is\n// dev-only, so the presence of one also tells us we're in dev.\nconst CRITICAL_CSS_PATH = '/vite-server/ossido_internal__critical_css';\nconst CRITICAL_CSS_LINK_SELECTOR = `link[href*=\"${CRITICAL_CSS_PATH.split('/').pop()}\"]`;\n\n/**\n * Warm a route's critical CSS before navigating to it, so the\n * `<link rel=\"stylesheet\" precedence>` that renders on arrival doesn't suspend\n * (and flash the loading fallback) while the stylesheet downloads. Resolves once\n * the resource is cached; never rejects.\n */\nfunction preloadCriticalCss(componentId: string): Promise<void> {\n  const href = `${CRITICAL_CSS_PATH}?componentId=${componentId}`;\n  // Already warmed (or warming) for this route — don't stack up <link>s.\n  if (document.querySelector(`link[rel=\"preload\"][href=\"${href}\"]`)) {\n    return Promise.resolve();\n  }\n  return new Promise((resolve) => {\n    const link = document.createElement('link');\n    link.rel = 'preload';\n    link.as = 'style';\n    link.href = href;\n    link.onload = (): void => resolve();\n    link.onerror = (): void => resolve();\n    document.head.appendChild(link);\n  });\n}\n\ninterface RouterContextProviderProps {\n  router: Router;\n  serverInitialLocation: ServerInitialLocation;\n  children: ReactNode;\n}\n\nexport function RouterContextProvider({\n  router,\n  serverInitialLocation,\n  children,\n}: RouterContextProviderProps): ReactNode {\n  const [location, setLocation] = useState<ParsedLocation>(() =>\n    getInitialLocation(serverInitialLocation),\n  );\n  const [navigationId, setNavigationId] = useState<number>(0);\n\n  const updateLocation = useCallback(\n    (\n      newLocation: ParsedLocation,\n      options: NavigationCommitOptions = {},\n    ): void => {\n      // Apply the navigation's state change. Wrapped by `runCommit` so — when\n      // view transitions are enabled (globally or per-navigation) and supported\n      // — it animates via `document.startViewTransition`. Every commit path\n      // (immediate, loading-race, ready.then) goes through this `commit`.\n      //\n      // A same-page anchor navigation — the pathname and search are unchanged, so\n      // only the URL hash (e.g. `#tuono`) differs — is a scroll to an id, not a\n      // page change: never run a view transition for it.\n      const isSamePageAnchor =\n        newLocation.pathname === location.pathname &&\n        newLocation.searchStr === location.searchStr;\n      const useViewTransition =\n        !isSamePageAnchor &&\n        (options.viewTransition ?? VIEW_TRANSITIONS_ENABLED);\n      const commit = (): void => {\n        runCommit(() => {\n          setNavigationId((id) => id + 1);\n          setLocation(newLocation);\n          if (options.history) {\n            const { type, path } = options.history;\n            window.history[type](path, '', path);\n          }\n          if (options.scroll) {\n            window.scroll(0, 0);\n          }\n        }, useViewTransition);\n      };\n\n      const targetRoute = matchRoute(router.routesById, newLocation.pathname);\n\n      // On the server, or for an unknown route (which renders the not-found\n      // fallback), commit immediately.\n      if (!targetRoute || isServerSide) {\n        commit();\n        return;\n      }\n\n      const pending: Array<PromiseLike<unknown>> = [];\n\n      // 1. The route's server data (the key the destination render will read —\n      //    navigationId is bumped by one on commit — so it reads it synchronously).\n      if (targetRoute.options.hasHandler) {\n        pending.push(\n          getOrCreateResource(\n            buildResourceKey(navigationId + 1, newLocation),\n            targetRoute,\n            newLocation,\n          ),\n        );\n      }\n\n      // In dev the route's critical CSS is a `<link rel=\"stylesheet\" precedence>`\n      // (see `CriticalCss`), which React suspends on until it loads. Detect dev by\n      // the presence of one for the current page.\n      const criticalCssEnabled = !!document.querySelector(\n        CRITICAL_CSS_LINK_SELECTOR,\n      );\n\n      // Everything else the destination needs to render without suspending:\n      //  - the code chunk of the matched route and its lazy ancestor layouts\n      //    (otherwise it suspends on the lazy `import()` after commit), and\n      //  - the critical CSS of each (otherwise React suspends on the stylesheet).\n      for (\n        let node: Route | undefined = targetRoute;\n        node;\n        node = node.isRoot ? undefined : node.options.getParentRoute?.()\n      ) {\n        const preloadComponent = node.component.preload;\n        if (preloadComponent) pending.push(preloadComponent());\n\n        const componentId = node.filePath || node.id;\n        if (criticalCssEnabled && componentId) {\n          pending.push(preloadCriticalCss(componentId));\n        }\n      }\n\n      if (pending.length === 0) {\n        commit();\n        return;\n      }\n\n      // A rejected resource still navigates so the error boundary can surface it.\n      const ready = Promise.all(pending);\n\n      if (targetRoute.options.loadingComponent) {\n        // The route has a loading fallback: commit as soon as the destination is\n        // ready, or after a short grace period — whichever comes first. Fast\n        // navigations commit with data resolved (no fallback flash); slow ones\n        // commit early and the loading component shows while data finishes.\n        Promise.race([ready, wait(FALLBACK_DELAY_MS)]).then(commit, commit);\n      } else {\n        // No loading fallback: wait for everything so the destination appears\n        // fully (the current page stays visible until then, never a blank).\n        ready.then(commit, commit);\n      }\n    },\n    [router, navigationId, location],\n  );\n\n  const retry = useCallback((): void => {\n    setNavigationId((id) => id + 1);\n  }, []);\n\n  /**\n   * Listen browser navigation events. The browser has already updated the URL,\n   * so this only mirrors it into router state (and bumps the navigation id so\n   * the route refetches — preserving back/forward data loads).\n   */\n  useEffect(() => {\n    const updateLocationOnPopStateChange = ({\n      target,\n    }: PopStateEvent): void => {\n      const { location: targetLocation } = target as typeof window;\n      updateLocation(fromUrlToParsedLocation(targetLocation.href));\n    };\n\n    window.addEventListener('popstate', updateLocationOnPopStateChange);\n\n    return (): void => {\n      window.removeEventListener('popstate', updateLocationOnPopStateChange);\n    };\n  }, [updateLocation]);\n\n  const contextValue: RouterContextValue = useMemo(\n    () => ({\n      router,\n      location,\n      navigationId,\n      updateLocation,\n      retry,\n    }),\n    [location, router, navigationId, updateLocation, retry],\n  );\n\n  return (\n    <RouterContext.Provider value={contextValue}>\n      {children}\n    </RouterContext.Provider>\n  );\n}\n"],"mappings":"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"}

package/dist/esm/components/RouterProvider.d.ts

@@ -0,0 +1,15 @@
+import type { JSX } from 'react';
+import type { ServerInitialLocation, Mode, ServerErrorPayload } from '../types';
+import type { Router } from '../router';
+interface RouterProviderProps {
+    router: Router;
+    serverInitialLocation: ServerInitialLocation;
+    serverInitialData: unknown;
+    /** Wrapping layouts' server data, keyed by each layout's `dataKey`. */
+    serverInitialLayoutData?: Record<string, unknown>;
+    /** Set when the initial route's Rust handler panicked (dev mode). */
+    serverInitialError?: ServerErrorPayload;
+    mode?: Mode;
+}
+export declare function RouterProvider({ router, serverInitialLocation, serverInitialData, serverInitialLayoutData, serverInitialError, mode, }: RouterProviderProps): JSX.Element;
+export {};

package/dist/esm/components/RouterProvider.js

@@ -0,0 +1,28 @@
+import { buildResourceKey, seedErrorResource, seedLayoutData, seedResource, toDataResult } from "../data/resourceCache.js";
+import { getInitialLocation } from "./RouterContext.js";
+import { RouterContextProvider } from "./RouterContextProvider.js";
+import { Matches } from "./Matches.js";
+import { useState } from "react";
+import { DevErrorOverlayHost } from "@ossido-labs/ossido-ui";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/components/RouterProvider.tsx
+function RouterProvider({ router, serverInitialLocation, serverInitialData, serverInitialLayoutData, serverInitialError, mode }) {
+	useState(() => {
+		const initialLocation = getInitialLocation(serverInitialLocation);
+		const resourceKey = buildResourceKey(0, initialLocation);
+		if (serverInitialError) seedErrorResource(resourceKey, serverInitialError);
+		else seedResource(resourceKey, toDataResult(serverInitialData));
+		if (serverInitialLayoutData) seedLayoutData(serverInitialLayoutData);
+		return null;
+	});
+	return /* @__PURE__ */ jsxs(RouterContextProvider, {
+		router,
+		serverInitialLocation,
+		children: [/* @__PURE__ */ jsx(Matches, { mode }), import.meta.env.DEV && mode === "Dev" && /* @__PURE__ */ jsx(DevErrorOverlayHost, {})]
+	});
+}
+
+//#endregion
+export { RouterProvider };
+//# sourceMappingURL=RouterProvider.js.map

package/dist/esm/components/RouterProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouterProvider.js","names":[],"sources":["../../../src/components/RouterProvider.tsx"],"sourcesContent":["import { useState } from 'react';\nimport type { JSX } from 'react';\nimport { DevErrorOverlayHost } from '@ossido-labs/ossido-ui';\n\nimport type { ServerInitialLocation, Mode, ServerErrorPayload } from '../types';\nimport type { Router } from '../router';\nimport {\n  buildResourceKey,\n  seedResource,\n  seedErrorResource,\n  seedLayoutData,\n  toDataResult,\n} from '../data/resourceCache';\n\nimport { getInitialLocation } from './RouterContext';\nimport { RouterContextProvider } from './RouterContextProvider';\nimport { Matches } from './Matches';\n\ninterface RouterProviderProps {\n  router: Router;\n  serverInitialLocation: ServerInitialLocation;\n  serverInitialData: unknown;\n  /** Wrapping layouts' server data, keyed by each layout's `dataKey`. */\n  serverInitialLayoutData?: Record<string, unknown>;\n  /** Set when the initial route's Rust handler panicked (dev mode). */\n  serverInitialError?: ServerErrorPayload;\n  mode?: Mode;\n}\n\nexport function RouterProvider({\n  router,\n  serverInitialLocation,\n  serverInitialData,\n  serverInitialLayoutData,\n  serverInitialError,\n  mode,\n}: RouterProviderProps): JSX.Element {\n  // Seed the initial route's data resource synchronously, during render, once,\n  // on server AND client (a `useState` lazy initializer — not an effect, which\n  // would run too late and make the first render suspend → hydration mismatch).\n  // navigationId starts at 0, matching the key RouteMatch builds on first render.\n  useState(() => {\n    const initialLocation = getInitialLocation(serverInitialLocation);\n    const resourceKey = buildResourceKey(0, initialLocation);\n    // A handler panic seeds a rejected resource so the boundary/overlay render;\n    // otherwise seed the fulfilled server data.\n    if (serverInitialError) {\n      seedErrorResource(resourceKey, serverInitialError);\n    } else {\n      seedResource(resourceKey, toDataResult(serverInitialData));\n    }\n    // Seed the wrapping layouts' data so they render synchronously (SSR + first\n    // client render) without a fetch.\n    if (serverInitialLayoutData) {\n      seedLayoutData(serverInitialLayoutData);\n    }\n    return null;\n  });\n\n  return (\n    <RouterContextProvider\n      router={router}\n      serverInitialLocation={serverInitialLocation}\n    >\n      <Matches mode={mode} />\n      {/* Dev-only: the floating overlay host that surfaces every kind of dev\n          error (render/SSR panics, uncaught errors, rejections, Vite build\n          errors). Renders null until something is reported.\n\n          `import.meta.env.DEV` is a build-time constant (true only in the dev\n          bundle), so the prod build eliminates this branch — the overlay host is\n          never rendered in prod. The heavy Shiki syntax-highlighter it uses is\n          reached lazily (via the dev error reporter), so the prod build\n          code-splits it into chunks that a real prod visitor never fetches (the\n          runtime `mode` check gates them). The `mode` check is also what keeps\n          the overlay working in the dev bundle. */}\n      {import.meta.env.DEV && mode === 'Dev' && <DevErrorOverlayHost />}\n    </RouterContextProvider>\n  );\n}\n"],"mappings":";;;;;;;;;AA6BA,SAAgB,eAAe,EAC7B,QACA,uBACA,mBACA,yBACA,oBACA,QACmC;CAKnC,eAAe;EACb,MAAM,kBAAkB,mBAAmB,qBAAqB;EAChE,MAAM,cAAc,iBAAiB,GAAG,eAAe;EAGvD,IAAI,oBACF,kBAAkB,aAAa,kBAAkB;OAEjD,aAAa,aAAa,aAAa,iBAAiB,CAAC;EAI3D,IAAI,yBACF,eAAe,uBAAuB;EAExC,OAAO;CACT,CAAC;CAED,OACE,qBAAC,uBAAD;EACU;EACe;YAFzB,CAIE,oBAAC,SAAD,EAAe,KAAO,IAYrB,YAAY,IAAI,OAAO,SAAS,SAAS,oBAAC,qBAAD,CAAsB,EAC3C;;AAE3B"}

package/dist/esm/data/resourceCache.d.ts

@@ -0,0 +1,75 @@
+import type { Route } from '../route';
+import type { ServerErrorPayload } from '../types';
+/**
+ * Fulfilled value of a data resource. A redirect is a normal (non-error)
+ * outcome so it must NOT reject — rejecting would trigger the error boundary.
+ */
+export type RouteDataResult = {
+    kind: 'data';
+    props: Record<string, unknown>;
+} | {
+    kind: 'redirect';
+    destination: string;
+};
+/**
+ * A promise annotated with `status`/`value`/`reason` so React's `use()` reads
+ * settled resources synchronously (no suspend). This is what lets the SSR and
+ * hydration first render resolve pre-seeded data without suspending.
+ */
+export interface DataResource extends Promise<RouteDataResult> {
+    status: 'pending' | 'fulfilled' | 'rejected';
+    value?: RouteDataResult;
+    reason?: unknown;
+}
+interface LocationKeyParts {
+    pathname: string;
+    searchStr: string;
+}
+/**
+ * Rebuild a `ServerErrorPayload` (from the Rust server) into a real `Error` so
+ * the error boundary / dev overlay treats a backend panic exactly like a JS
+ * error, preserving the panic message and backtrace.
+ */
+export declare function serverErrorToError(payload: ServerErrorPayload): Error;
+/**
+ * Single source of truth for a resource key — used by both the seeder and the
+ * loader. Includes `searchStr` so search-param-only navigations create a
+ * distinct resource (and therefore refetch).
+ */
+export declare function buildResourceKey(navigationId: number, { pathname, searchStr }: LocationKeyParts): string;
+/** Normalize user server data into a `data` result for seeding. */
+export declare function toDataResult(props: unknown): RouteDataResult;
+/**
+ * Seed the wrapping layouts' server data (from a page's SSR payload or data
+ * fetch), keyed by each layout's `dataKey`.
+ */
+export declare function seedLayoutData(layoutData: Record<string, unknown>): void;
+/**
+ * Read a layout's seeded server data synchronously (no fetch, no suspend): a
+ * layout's data always arrives via the page it wraps. Returns empty props when
+ * nothing is seeded yet (e.g. a loading-fallback navigation's first frame).
+ */
+export declare function readLayoutData(dataKey: string): Record<string, unknown>;
+/**
+ * Insert a pre-fulfilled resource — used to seed the SSR initial data so the
+ * first render (server and client) reads it synchronously.
+ */
+export declare function seedResource(key: string, value: RouteDataResult): DataResource;
+/**
+ * Insert a pre-rejected resource carrying a server error — used to seed a
+ * handler panic (dev) so `use()` re-throws it into the error boundary on the
+ * first render (server and client), rendering the error overlay.
+ */
+export declare function seedErrorResource(key: string, payload: ServerErrorPayload): DataResource;
+/**
+ * Return the cached resource for `key`, creating one on demand. Idempotent
+ * (StrictMode-safe): at most one fetch is started per key.
+ *
+ * The server never fetches (the ossido_ssr V8 runtime has no `fetch`); every
+ * server-rendered route is pre-seeded, and any un-seeded server lookup resolves
+ * to empty props rather than suspending.
+ */
+export declare function getOrCreateResource(key: string, route: Route, location: LocationKeyParts): DataResource;
+/** Drop a resource so the next lookup refetches (used by error `reset`). */
+export declare function invalidateResource(key: string): void;
+export {};

package/dist/esm/data/resourceCache.js

@@ -0,0 +1,148 @@
+//#region src/data/resourceCache.ts
+const isServerSide = typeof window === "undefined";
+const IS_STATIC_EXPORT = typeof __OSSIDO_STATIC__ !== "undefined" && __OSSIDO_STATIC__;
+/**
+* The data endpoint URL for a location. In a static export it targets the
+* pre-rendered `.json` file matching what `ossido build --static` writes (root is
+* `/__ossido/data.json` to avoid a `data/.json` dotfile); otherwise the live
+* server's extensionless route, including search params.
+*/
+function dataEndpointUrl({ pathname, searchStr }) {
+	if (IS_STATIC_EXPORT) return pathname === "/" ? "/__ossido/data.json" : `/__ossido/data${pathname}.json`;
+	return `/__ossido/data${pathname}${searchStr}`;
+}
+/**
+* Rebuild a `ServerErrorPayload` (from the Rust server) into a real `Error` so
+* the error boundary / dev overlay treats a backend panic exactly like a JS
+* error, preserving the panic message and backtrace.
+*/
+function serverErrorToError(payload) {
+	const error = new Error(payload.message);
+	error.name = payload.name;
+	if (payload.stack) error.stack = payload.stack;
+	if (payload.source) error.ossidoServerSource = payload.source;
+	return error;
+}
+const CACHE_LIMIT = 50;
+const cache = /* @__PURE__ */ new Map();
+/**
+* Single source of truth for a resource key — used by both the seeder and the
+* loader. Includes `searchStr` so search-param-only navigations create a
+* distinct resource (and therefore refetch).
+*/
+function buildResourceKey(navigationId, { pathname, searchStr }) {
+	return `${navigationId}::${pathname}${searchStr}`;
+}
+/** Normalize user server data into a `data` result for seeding. */
+function toDataResult(props) {
+	return {
+		kind: "data",
+		props: props ?? {}
+	};
+}
+/**
+* Resource key for a `layout.rs` handler's data. Keyed by the layout's `dataKey`
+* alone (not the navigation) so its data persists across navigations under the
+* same layout and is simply overwritten by each page's data fetch — matching how
+* layouts persist in the tree.
+*/
+function buildLayoutResourceKey(dataKey) {
+	return `layout::${dataKey}`;
+}
+/**
+* Seed the wrapping layouts' server data (from a page's SSR payload or data
+* fetch), keyed by each layout's `dataKey`.
+*/
+function seedLayoutData(layoutData) {
+	for (const [dataKey, props] of Object.entries(layoutData)) seedResource(buildLayoutResourceKey(dataKey), toDataResult(props));
+}
+/**
+* Read a layout's seeded server data synchronously (no fetch, no suspend): a
+* layout's data always arrives via the page it wraps. Returns empty props when
+* nothing is seeded yet (e.g. a loading-fallback navigation's first frame).
+*/
+function readLayoutData(dataKey) {
+	const resource = cache.get(buildLayoutResourceKey(dataKey));
+	if (resource?.status === "fulfilled" && resource.value?.kind === "data") return resource.value.props;
+	return {};
+}
+function annotate(promise) {
+	const resource = promise;
+	resource.status = "pending";
+	resource.then((value) => {
+		resource.status = "fulfilled";
+		resource.value = value;
+	}, (reason) => {
+		resource.status = "rejected";
+		resource.reason = reason;
+	});
+	return resource;
+}
+async function fetchRouteData(location) {
+	const res = await fetch(dataEndpointUrl(location));
+	const body = await res.json().catch(() => null);
+	if (body?.info.serverError) throw serverErrorToError(body.info.serverError);
+	if (body?.info.redirect_destination) return {
+		kind: "redirect",
+		destination: body.info.redirect_destination
+	};
+	if (!res.ok || !body) throw new Error(`Failed to load server data for "${location.pathname}" (status ${res.status})`);
+	if (body.layoutData) seedLayoutData(body.layoutData);
+	return toDataResult(body.data);
+}
+/**
+* Insert a pre-fulfilled resource — used to seed the SSR initial data so the
+* first render (server and client) reads it synchronously.
+*/
+function seedResource(key, value) {
+	const resource = Promise.resolve(value);
+	resource.status = "fulfilled";
+	resource.value = value;
+	cache.set(key, resource);
+	return resource;
+}
+/**
+* Insert a pre-rejected resource carrying a server error — used to seed a
+* handler panic (dev) so `use()` re-throws it into the error boundary on the
+* first render (server and client), rendering the error overlay.
+*/
+function seedErrorResource(key, payload) {
+	const reason = serverErrorToError(payload);
+	const resource = Promise.reject(reason);
+	resource.catch(() => void 0);
+	resource.status = "rejected";
+	resource.reason = reason;
+	cache.set(key, resource);
+	return resource;
+}
+/**
+* Return the cached resource for `key`, creating one on demand. Idempotent
+* (StrictMode-safe): at most one fetch is started per key.
+*
+* The server never fetches (the ossido_ssr V8 runtime has no `fetch`); every
+* server-rendered route is pre-seeded, and any un-seeded server lookup resolves
+* to empty props rather than suspending.
+*/
+function getOrCreateResource(key, route, location) {
+	const existing = cache.get(key);
+	if (existing) return existing;
+	if (isServerSide || !route.options.hasHandler) return seedResource(key, {
+		kind: "data",
+		props: {}
+	});
+	const resource = annotate(fetchRouteData(location));
+	cache.set(key, resource);
+	evictStaleEntries(key);
+	return resource;
+}
+function evictStaleEntries(currentKey) {
+	if (cache.size <= CACHE_LIMIT) return;
+	for (const key of cache.keys()) {
+		if (cache.size <= CACHE_LIMIT) break;
+		if (key !== currentKey) cache.delete(key);
+	}
+}
+
+//#endregion
+export { buildResourceKey, getOrCreateResource, readLayoutData, seedErrorResource, seedLayoutData, seedResource, serverErrorToError, toDataResult };
+//# sourceMappingURL=resourceCache.js.map

package/dist/esm/data/resourceCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resourceCache.js","names":[],"sources":["../../../src/data/resourceCache.ts"],"sourcesContent":["import type { Route } from '../route';\nimport type { ServerErrorPayload, OssidoErrorWithSource } from '../types';\n\nconst isServerSide = typeof window === 'undefined';\n\n/**\n * Baked to `true` by `ossido build --static` (via the vite `define`); the\n * `typeof` guard keeps this safe under vitest/SSR where the define isn't\n * applied. In a static export there is no server to resolve the extensionless\n * `/__ossido/data{path}` route, so data is pre-rendered to `.json` files, keyed\n * by path only (no query variants).\n */\ndeclare const __OSSIDO_STATIC__: boolean;\nconst IS_STATIC_EXPORT =\n  typeof __OSSIDO_STATIC__ !== 'undefined' && __OSSIDO_STATIC__;\n\n/**\n * The data endpoint URL for a location. In a static export it targets the\n * pre-rendered `.json` file matching what `ossido build --static` writes (root is\n * `/__ossido/data.json` to avoid a `data/.json` dotfile); otherwise the live\n * server's extensionless route, including search params.\n */\nfunction dataEndpointUrl({ pathname, searchStr }: LocationKeyParts): string {\n  if (IS_STATIC_EXPORT) {\n    return pathname === '/'\n      ? '/__ossido/data.json'\n      : `/__ossido/data${pathname}.json`;\n  }\n  return `/__ossido/data${pathname}${searchStr}`;\n}\n\n/**\n * Fulfilled value of a data resource. A redirect is a normal (non-error)\n * outcome so it must NOT reject — rejecting would trigger the error boundary.\n */\nexport type RouteDataResult =\n  | { kind: 'data'; props: Record<string, unknown> }\n  | { kind: 'redirect'; destination: string };\n\n/**\n * A promise annotated with `status`/`value`/`reason` so React's `use()` reads\n * settled resources synchronously (no suspend). This is what lets the SSR and\n * hydration first render resolve pre-seeded data without suspending.\n */\nexport interface DataResource extends Promise<RouteDataResult> {\n  status: 'pending' | 'fulfilled' | 'rejected';\n  value?: RouteDataResult;\n  reason?: unknown;\n}\n\ninterface LocationKeyParts {\n  pathname: string;\n  searchStr: string;\n}\n\ninterface OssidoApiResponse {\n  data?: unknown;\n  // Server data for the `layout.rs` handlers wrapping this page, keyed by each\n  // layout's `dataKey`. Present only when a wrapping layout has a data handler.\n  layoutData?: Record<string, unknown>;\n  info: {\n    redirect_destination?: string;\n    // Present (dev only) when the Rust handler panicked — see `error_json` in\n    // crates/ossido/src/response.rs.\n    serverError?: ServerErrorPayload;\n  };\n}\n\n/**\n * Rebuild a `ServerErrorPayload` (from the Rust server) into a real `Error` so\n * the error boundary / dev overlay treats a backend panic exactly like a JS\n * error, preserving the panic message and backtrace.\n */\nexport function serverErrorToError(payload: ServerErrorPayload): Error {\n  const error: OssidoErrorWithSource = new Error(payload.message);\n  error.name = payload.name;\n  if (payload.stack) error.stack = payload.stack;\n  // Carry the panic-site source through to the overlay for a highlighted\n  // excerpt (Rust has no sourcemap the client could resolve one from).\n  if (payload.source) error.ossidoServerSource = payload.source;\n  return error;\n}\n\nconst CACHE_LIMIT = 50;\nconst cache = new Map<string, DataResource>();\n\n/**\n * Single source of truth for a resource key — used by both the seeder and the\n * loader. Includes `searchStr` so search-param-only navigations create a\n * distinct resource (and therefore refetch).\n */\nexport function buildResourceKey(\n  navigationId: number,\n  { pathname, searchStr }: LocationKeyParts,\n): string {\n  return `${navigationId}::${pathname}${searchStr}`;\n}\n\n/** Normalize user server data into a `data` result for seeding. */\nexport function toDataResult(props: unknown): RouteDataResult {\n  return { kind: 'data', props: (props ?? {}) as Record<string, unknown> };\n}\n\n/**\n * Resource key for a `layout.rs` handler's data. Keyed by the layout's `dataKey`\n * alone (not the navigation) so its data persists across navigations under the\n * same layout and is simply overwritten by each page's data fetch — matching how\n * layouts persist in the tree.\n */\nfunction buildLayoutResourceKey(dataKey: string): string {\n  return `layout::${dataKey}`;\n}\n\n/**\n * Seed the wrapping layouts' server data (from a page's SSR payload or data\n * fetch), keyed by each layout's `dataKey`.\n */\nexport function seedLayoutData(layoutData: Record<string, unknown>): void {\n  for (const [dataKey, props] of Object.entries(layoutData)) {\n    seedResource(buildLayoutResourceKey(dataKey), toDataResult(props));\n  }\n}\n\n/**\n * Read a layout's seeded server data synchronously (no fetch, no suspend): a\n * layout's data always arrives via the page it wraps. Returns empty props when\n * nothing is seeded yet (e.g. a loading-fallback navigation's first frame).\n */\nexport function readLayoutData(dataKey: string): Record<string, unknown> {\n  const resource = cache.get(buildLayoutResourceKey(dataKey));\n  if (resource?.status === 'fulfilled' && resource.value?.kind === 'data') {\n    return resource.value.props;\n  }\n  return {};\n}\n\nfunction annotate(promise: Promise<RouteDataResult>): DataResource {\n  const resource = promise as DataResource;\n  resource.status = 'pending';\n  resource.then(\n    (value) => {\n      resource.status = 'fulfilled';\n      resource.value = value;\n    },\n    (reason) => {\n      resource.status = 'rejected';\n      resource.reason = reason;\n    },\n  );\n  return resource;\n}\n\nasync function fetchRouteData(\n  location: LocationKeyParts,\n): Promise<RouteDataResult> {\n  const res = await fetch(dataEndpointUrl(location));\n  // Read the body before the `res.ok` check: a panicked handler responds with a\n  // 500 that still carries the structured error under `info.serverError` (dev).\n  const body = (await res.json().catch(() => null)) as OssidoApiResponse | null;\n\n  if (body?.info.serverError) {\n    throw serverErrorToError(body.info.serverError);\n  }\n  // A redirecting handler responds with a 308 whose destination lives in the\n  // body (there is no `Location` header — this is a data envelope, not an HTTP\n  // redirect the browser should follow). Handle it before the ok-status check,\n  // since 308 is not an \"ok\" status.\n  if (body?.info.redirect_destination) {\n    return { kind: 'redirect', destination: body.info.redirect_destination };\n  }\n\n  if (!res.ok || !body) {\n    throw new Error(\n      `Failed to load server data for \"${location.pathname}\" (status ${res.status})`,\n    );\n  }\n\n  // A page's data fetch also carries its wrapping layouts' data — seed those so\n  // the layout components read them synchronously.\n  if (body.layoutData) seedLayoutData(body.layoutData);\n\n  return toDataResult(body.data);\n}\n\n/**\n * Insert a pre-fulfilled resource — used to seed the SSR initial data so the\n * first render (server and client) reads it synchronously.\n */\nexport function seedResource(\n  key: string,\n  value: RouteDataResult,\n): DataResource {\n  const resource = Promise.resolve(value) as DataResource;\n  resource.status = 'fulfilled';\n  resource.value = value;\n  cache.set(key, resource);\n  return resource;\n}\n\n/**\n * Insert a pre-rejected resource carrying a server error — used to seed a\n * handler panic (dev) so `use()` re-throws it into the error boundary on the\n * first render (server and client), rendering the error overlay.\n */\nexport function seedErrorResource(\n  key: string,\n  payload: ServerErrorPayload,\n): DataResource {\n  const reason = serverErrorToError(payload);\n  const resource = Promise.reject(reason) as DataResource;\n  // The rejection is consumed synchronously by `use()`, but attach a no-op\n  // catch so it is never reported as an unhandled rejection.\n  resource.catch(() => undefined);\n  resource.status = 'rejected';\n  resource.reason = reason;\n  cache.set(key, resource);\n  return resource;\n}\n\n/**\n * Return the cached resource for `key`, creating one on demand. Idempotent\n * (StrictMode-safe): at most one fetch is started per key.\n *\n * The server never fetches (the ossido_ssr V8 runtime has no `fetch`); every\n * server-rendered route is pre-seeded, and any un-seeded server lookup resolves\n * to empty props rather than suspending.\n */\nexport function getOrCreateResource(\n  key: string,\n  route: Route,\n  location: LocationKeyParts,\n): DataResource {\n  const existing = cache.get(key);\n  if (existing) return existing;\n\n  if (isServerSide || !route.options.hasHandler) {\n    return seedResource(key, { kind: 'data', props: {} });\n  }\n\n  const resource = annotate(fetchRouteData(location));\n  cache.set(key, resource);\n  evictStaleEntries(key);\n  return resource;\n}\n\n/** Drop a resource so the next lookup refetches (used by error `reset`). */\nexport function invalidateResource(key: string): void {\n  cache.delete(key);\n}\n\nfunction evictStaleEntries(currentKey: string): void {\n  if (cache.size <= CACHE_LIMIT) return;\n  // Map preserves insertion order, so this drops the oldest entries first and\n  // never evicts the entry currently being rendered.\n  for (const key of cache.keys()) {\n    if (cache.size <= CACHE_LIMIT) break;\n    if (key !== currentKey) cache.delete(key);\n  }\n}\n"],"mappings":"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"}

package/dist/esm/hooks/useRoute.d.ts

@@ -0,0 +1,14 @@
+import type { Route } from '../route';
+import { sanitizePathname } from '../utils/match-route';
+export { sanitizePathname };
+/**
+ * Returns the route that matches the given pathname.
+ *
+ * This hook is also implemented on server side to match the bundle
+ * file to load at the first rendering.
+ *
+ * File: crates/ossido/src/payload.rs
+ *
+ * Optimizations should occur on both
+ */
+export declare function useRoute(pathname?: string): Route | undefined;

package/dist/esm/hooks/useRoute.js

@@ -0,0 +1,22 @@
+import { useRouterContext } from "../components/RouterContext.js";
+import { matchRoute, sanitizePathname } from "../utils/match-route.js";
+
+//#region src/hooks/useRoute.ts
+/**
+* Returns the route that matches the given pathname.
+*
+* This hook is also implemented on server side to match the bundle
+* file to load at the first rendering.
+*
+* File: crates/ossido/src/payload.rs
+*
+* Optimizations should occur on both
+*/
+function useRoute(pathname) {
+	const { router: { routesById } } = useRouterContext();
+	return matchRoute(routesById, pathname);
+}
+
+//#endregion
+export { useRoute };
+//# sourceMappingURL=useRoute.js.map

package/dist/esm/hooks/useRoute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRoute.js","names":[],"sources":["../../../src/hooks/useRoute.ts"],"sourcesContent":["import type { Route } from '../route';\n\nimport { useRouterContext } from '../components/RouterContext';\nimport { matchRoute, sanitizePathname } from '../utils/match-route';\n\nexport { sanitizePathname };\n\n/**\n * Returns the route that matches the given pathname.\n *\n * This hook is also implemented on server side to match the bundle\n * file to load at the first rendering.\n *\n * File: crates/ossido/src/payload.rs\n *\n * Optimizations should occur on both\n */\nexport function useRoute(pathname?: string): Route | undefined {\n  const {\n    router: { routesById },\n  } = useRouterContext();\n\n  return matchRoute(routesById, pathname);\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,SAAS,UAAsC;CAC7D,MAAM,EACJ,QAAQ,EAAE,iBACR,iBAAiB;CAErB,OAAO,WAAW,YAAY,QAAQ;AACxC"}