@octanejs/tanstack-router 0.1.2

package/src/Navigate.tsrx

@@ -0,0 +1,14 @@
+// Imperative navigation as a component: navigates once on mount, renders nothing.
+import { useLayoutEffect, useRef } from 'octane';
+import { useNavigate } from './hooks.ts';
+
+export function Navigate(props) @{
+	const navigate = useNavigate();
+	const done = useRef(false);
+
+	useLayoutEffect(() => {
+		if (done.current) return;
+		done.current = true;
+		navigate(props);
+	}, []);
+}

package/src/Navigate.tsrx.d.ts

@@ -0,0 +1,2 @@
+// Type declaration for the .tsrx component (resolved by relative path).
+export declare const Navigate: (props: Record<string, unknown>) => unknown;

package/src/Outlet.tsrx

@@ -0,0 +1,49 @@
+// Renders the child match below the current one. Reads the current match id from
+// `matchContext`, finds the NEXT id in the match-id chain, and renders its `<Match/>`
+// — the pull-based descent that replaces a top-down state diff. Renders nothing at
+// a leaf.
+//
+// Not-found (react-router's Outlet, same order): when the URL matched no route,
+// router-core flags ONE match `globalNotFound` — with the default
+// `notFoundMode: 'fuzzy'` the deepest fuzzy-matched route that has children, with
+// `notFoundMode: 'root'` the root. That match still renders its own component
+// (the layout), and its `<Outlet/>` renders the not-found UI INSTEAD of a child
+// match — so the 404 lands inside the layout chrome.
+import { useContext, createElement, Suspense } from 'octane';
+import { rootRouteId } from '@tanstack/router-core';
+import { useStore } from './useStore.ts';
+import { useRouter, matchContext } from './context.ts';
+import { Match } from './Match.tsrx';
+import { RouteNotFound } from './RouteNotFound.tsrx';
+import { SafeFragment } from './SafeFragment.tsrx';
+
+export function Outlet() @{
+	const router = useRouter();
+	const parentId = useContext(matchContext);
+	const parentStore = router.stores.matchStores.get(parentId);
+	const parentRouteId = useStore(parentStore, (m) => m?.routeId);
+	const globalNotFound = useStore(parentStore, (m) => m?.globalNotFound ?? false);
+	const childId = useStore(router.stores.matchesId, (ids) => {
+		const i = ids.indexOf(parentId);
+		return i >= 0 ? ids[i + 1] : undefined;
+	});
+
+	// The root route's outlet wraps the first real match in a Suspense boundary
+	// whose fallback is the router's defaultPendingComponent (react-router's
+	// Outlet does the same) — the outermost pending UI for the initial load.
+	const DefaultPending = router.options.defaultPendingComponent;
+	const RootSuspense =
+		parentRouteId === rootRouteId ? Suspense : SafeFragment;
+	const pendingElement =
+		DefaultPending ? createElement(DefaultPending, {}) : null;
+
+	@if (globalNotFound) {
+		<RouteNotFound routeId={parentRouteId} />
+	} @else {
+		@if (childId) {
+			<RootSuspense fallback={pendingElement}>
+				<Match matchId={childId} />
+			</RootSuspense>
+		}
+	}
+}

package/src/Outlet.tsrx.d.ts

@@ -0,0 +1,2 @@
+// Type declaration for the .tsrx component (resolved by relative path).
+export declare const Outlet: () => unknown;

package/src/RouteNotFound.tsrx

@@ -0,0 +1,23 @@
+// Renders a route's not-found UI — the port of react-router's
+// `renderRouteNotFound` (+ its `DefaultGlobalNotFound`). Resolution order matches
+// upstream: the route's own `notFoundComponent`, else the router-level
+// `defaultNotFoundComponent`, else TanStack's generic `<p>Not Found</p>` (the
+// upstream dev-only console.warn is not ported — repo policy: functional outcomes
+// only). Rendered from two places, mirroring react-router: `<Outlet/>` when its
+// match is flagged `globalNotFound` (the URL matched no route), and `<Match/>`
+// when the match resolved with `status === 'notFound'` (a loader threw
+// `notFound()`). Upstream spreads the NotFoundError onto the component, so a
+// `notFound({ data })` payload arrives as the `data` prop.
+import { useRouter } from './context.ts';
+
+export function RouteNotFound(props) @{
+	const router = useRouter();
+	const route = router.routesById[props.routeId];
+	const NotFound = route.options.notFoundComponent ?? router.options.defaultNotFoundComponent;
+
+	@if (NotFound) {
+		<NotFound {...props.error ?? {}} />
+	} @else {
+		<p>Not Found</p>
+	}
+}

package/src/RouterProvider.tsrx

@@ -0,0 +1,37 @@
+// Places the router into context and renders the active match tree. Mirrors
+// react-router's RouterProvider.tsx: `RouterContextProvider` is the low-level
+// provider — it forwards any extra props into `router.update()` (so
+// `<RouterProvider router={r} defaultPreload="intent">` reconfigures the
+// instance), wraps in `router.options.Wrap` when configured, and provides the
+// router; `RouterProvider` renders `<Matches/>` inside it.
+import { hasKeys } from '@tanstack/router-core';
+import { routerContext } from './context.ts';
+import { Matches } from './Matches.tsrx';
+import { SafeFragment } from './SafeFragment.tsrx';
+
+export function RouterContextProvider(props) @{
+	const { router, children, ...rest } = props;
+	if (hasKeys(rest)) {
+		router.update({
+			...router.options,
+			...rest,
+			context: {
+				...router.options.context,
+				...rest.context,
+			},
+		});
+	}
+	const Wrap = router.options.Wrap ?? SafeFragment;
+
+	<Wrap>
+		<routerContext.Provider value={router}>{children}</routerContext.Provider>
+	</Wrap>
+}
+
+export function RouterProvider(props) @{
+	const { router, ...rest } = props;
+
+	<RouterContextProvider router={router} {...rest}>
+		<Matches />
+	</RouterContextProvider>
+}

package/src/RouterProvider.tsrx.d.ts

@@ -0,0 +1,8 @@
+// Type declaration for the .tsrx component (resolved by relative path).
+import type { AnyRouter } from '@tanstack/router-core';
+
+export declare const RouterProvider: (props: { router: AnyRouter; children?: unknown }) => unknown;
+export declare const RouterContextProvider: (props: {
+	router: import('@tanstack/router-core').AnyRouter;
+	children?: unknown;
+}) => unknown;

package/src/SafeFragment.tsrx

@@ -0,0 +1,12 @@
+// Pass-through wrapper used wherever react-router conditionally omits a boundary
+// (Suspense / CatchBoundary / CatchNotFound / shellComponent). Rendering through
+// SafeFragment instead of conditionally nesting the template keeps the boundary
+// slot's component identity dynamic (`<Wrap>` where Wrap is Suspense or this) and
+// — crucially — means a route WITHOUT a pendingComponent/errorComponent does not
+// create a boundary at all, so suspensions and errors bubble to the nearest
+// ancestor that has one (react-router parity).
+export function SafeFragment(props) @{
+	<>
+		{props.children}
+	</>
+}

package/src/SafeFragment.tsrx.d.ts

@@ -0,0 +1,2 @@
+// Type declaration for the .tsrx component (resolved by relative path).
+export declare const SafeFragment: (props: { children?: unknown }) => unknown;

package/src/ScrollRestoration.tsrx

@@ -0,0 +1,16 @@
+// Restores scroll position across navigations. router-core's
+// `setupScrollRestoration` does all the work (save on scroll keyed by location,
+// restore on navigation) — the component just wires it on mount and renders nothing.
+// You can also enable it via `createRouter({ scrollRestoration: true })` (handled in
+// Matches); use one or the other.
+import { useLayoutEffect } from 'octane';
+import { setupScrollRestoration } from '@tanstack/router-core';
+import { useRouter } from './context.ts';
+
+export function ScrollRestoration() @{
+	const router = useRouter();
+	useLayoutEffect(() => {
+		setupScrollRestoration(router, true);
+	}, [router]);
+	<></>
+}

package/src/ScrollRestoration.tsrx.d.ts

@@ -0,0 +1,2 @@
+// Type declaration for the .tsrx component (resolved by relative path).
+export declare const ScrollRestoration: () => unknown;

package/src/Transitioner.tsrx

@@ -0,0 +1,126 @@
+// The navigation engine (renders nothing) — port of react-router's Transitioner.
+// It (1) supplies `router.startTransition` so every navigation state update rides
+// an octane transition (concurrent navigation: the current page holds while the
+// next route suspends), (2) subscribes to history so back/forward and `Link`
+// clicks reload the matches, (3) kicks off the initial `router.load()` (skipped
+// when hydrating SSR — ssr-client triggers it) and commits a canonical-URL
+// replace when the mounted URL isn't in canonical form, and (4) drives the router
+// EVENT LIFECYCLE: `onLoad` when a load settles, `onBeforeRouteMount` /
+// `onResolved` when all pending work (load + transition + pending matches)
+// drains, then commits `status: 'idle'` + `resolvedLocation`. router-core's
+// scroll restoration, devtools, and `router.subscribe` consumers all key off
+// these events, and `useRouterState` selectors on `resolvedLocation` depend on
+// the commit.
+import { useEffect, useLayoutEffect, useRef, useState, startTransition } from 'octane';
+import { batch } from '@tanstack/store';
+import { getLocationChangeInfo, trimPathRight } from '@tanstack/router-core';
+import { useRouter } from './context.ts';
+import { useStore } from './useStore.ts';
+import { usePrevious } from './utils.ts';
+
+export function Transitioner() @{
+	const router = useRouter();
+	const mountLoadForRouter = useRef({ router, mounted: false });
+	const [isTransitioning, setIsTransitioning] = useState(false);
+
+	const isLoading = useStore(router.stores.isLoading, (v) => v);
+	const hasPending = useStore(router.stores.hasPending, (v) => v);
+
+	const previousIsLoading = usePrevious(isLoading);
+	const isAnyPending = isLoading || isTransitioning || hasPending;
+	const previousIsAnyPending = usePrevious(isAnyPending);
+	const isPagePending = isLoading || hasPending;
+	const previousIsPagePending = usePrevious(isPagePending);
+
+	router.startTransition = (fn) => {
+		setIsTransitioning(true);
+		startTransition(() => {
+			fn();
+			setIsTransitioning(false);
+		});
+	};
+
+	// Subscribe to location changes and load the new location. On mount, also
+	// verify the current URL is in canonical form (search serialization,
+	// trailing slash) and replace it if not — mirroring the server-side redirect
+	// check in router.beforeLoad.
+	useEffect(() => {
+		const unsub = router.history.subscribe(() => router.load());
+
+		const nextLocation = router.buildLocation({
+			to: router.latestLocation.pathname,
+			search: true,
+			params: true,
+			hash: true,
+			state: true,
+			_includeValidateSearch: true,
+		});
+		if (
+			trimPathRight(router.latestLocation.publicHref) !== trimPathRight(nextLocation.publicHref)
+		) {
+			router.commitLocation({ ...nextLocation, replace: true });
+		}
+
+		return () => unsub();
+	}, [router, router.history]);
+
+	// Initial load. Skipped when hydrating from SSR (ssr-client triggers it) and
+	// on re-runs for the same router instance.
+	useLayoutEffect(() => {
+		if (
+			typeof window !== 'undefined' && router.ssr ||
+				mountLoadForRouter.current.router === router && mountLoadForRouter.current.mounted
+		) {
+			return;
+		}
+		mountLoadForRouter.current = { router, mounted: true };
+		router.load().catch((err: unknown) => {
+			console.error(err);
+		});
+	}, [router]);
+
+	// The router was loading and now it's not — the new matches are in state.
+	useLayoutEffect(() => {
+		if (previousIsLoading && !isLoading) {
+			router.emit({
+				type: 'onLoad',
+				...getLocationChangeInfo(
+					router.stores.location.get(),
+					router.stores.resolvedLocation.get(),
+				),
+			});
+		}
+	}, [previousIsLoading, router, isLoading]);
+
+	useLayoutEffect(() => {
+		if (previousIsPagePending && !isPagePending) {
+			router.emit({
+				type: 'onBeforeRouteMount',
+				...getLocationChangeInfo(
+					router.stores.location.get(),
+					router.stores.resolvedLocation.get(),
+				),
+			});
+		}
+	}, [isPagePending, previousIsPagePending, router]);
+
+	// Everything pending has drained — resolve the navigation: emit onResolved and
+	// commit status idle + resolvedLocation (what `onRendered` and scroll
+	// restoration key off).
+	useLayoutEffect(() => {
+		if (previousIsAnyPending && !isAnyPending) {
+			const changeInfo = getLocationChangeInfo(
+				router.stores.location.get(),
+				router.stores.resolvedLocation.get(),
+			);
+			router.emit({ type: 'onResolved', ...changeInfo });
+
+			batch(() => {
+				router.stores.status.set('idle');
+				router.stores.resolvedLocation.set(router.stores.location.get());
+			});
+		}
+	}, [isAnyPending, previousIsAnyPending, router]);
+
+	<></>
+}

package/src/context.ts

@@ -0,0 +1,27 @@
+// Router + match contexts. `routerContext` carries the Router instance (provided
+// by RouterProvider, read by every hook). `matchContext` carries the current
+// match id down the render tree so `Outlet` can find the NEXT match to render —
+// the pull-based chaining that replaces a top-down state diff.
+import { createContext, useContext } from 'octane';
+import type { AnyRouter } from '@tanstack/router-core';
+
+export const routerContext = createContext<AnyRouter | undefined>(undefined);
+export const getRouterContext = (): typeof routerContext => routerContext;
+
+// The id of the nearest rendered match (undefined above the first match).
+export const matchContext = createContext<string | undefined>(undefined);
+
+// Resolve the active router: an explicitly-passed one wins, else the context.
+// `useContext` is keyed by context identity (not a per-call-site slot), so it's
+// safe to call from this binding code without a slot.
+export function useRouter(...args: unknown[]): AnyRouter {
+	const opts = (args.length && typeof args[0] !== 'symbol' ? args[0] : undefined) as
+		| { router?: AnyRouter; warn?: boolean }
+		| undefined;
+	const ctx = useContext(routerContext);
+	const router = opts?.router ?? ctx;
+	if (!router && opts?.warn !== false) {
+		throw new Error('useRouter must be used inside a <RouterProvider> component!');
+	}
+	return router as AnyRouter;
+}

package/src/history.ts

@@ -0,0 +1,10 @@
+// `@tanstack/history` is a separate framework-agnostic dependency (the browser/
+// hash/memory history abstractions). react-router re-exports it from `./history`;
+// we mirror that so `@octanejs/tanstack-router/history` and the bare entry both resolve it.
+export {
+	createHistory,
+	createBrowserHistory,
+	createHashHistory,
+	createMemoryHistory,
+} from '@tanstack/history';
+export type * from '@tanstack/history';

package/src/hooks.ts

@@ -0,0 +1,225 @@
+// The read hooks — ports of react-router's useMatch.tsx / useParams / useSearch /
+// useLoaderData / useLoaderDeps / useRouteContext / useNavigate / useCanGoBack /
+// Matches.tsx (useMatches / useParentMatches / useChildMatches). Everything match-
+// shaped funnels through `useMatch`, which subscribes to ONE match store:
+//   - `from` given → `router.stores.getRouteMatchStore(from)` (a cached computed
+//     that resolves a routeId to its current match);
+//   - no `from` → the NEAREST match via `matchContext` (the match id the enclosing
+//     `<Match>` provided) — NOT the leaf match.
+// A missing match throws unless `shouldThrow: false` (upstream invariant).
+// Selectors run through `useStructuralSharing` (replaceEqualDeep against the
+// previous selection when `structuralSharing ?? defaultStructuralSharing`).
+import { useContext, useRef, useCallback } from 'octane';
+import { replaceEqualDeep } from '@tanstack/router-core';
+import { useRouter, matchContext } from './context';
+import { useStore } from './useStore';
+import { splitSlot, subSlot } from './internal';
+
+// Sentinel store + selection for "no match at this id" (upstream's dummyStore).
+const dummyStore = {
+	get() {},
+	subscribe() {
+		return { unsubscribe() {} };
+	},
+};
+
+// Selector wrapper honoring structural sharing: when enabled, the selection is
+// replaceEqualDeep'd against the previous one so deep-equal slices keep their
+// reference (no re-render). Port of react-router's useStructuralSharing.
+function useStructuralSharing(opts: any, router: any, slot: symbol | undefined) {
+	const previousResult = useRef<any>(undefined, subSlot(slot, 'ss'));
+	return (slice: any) => {
+		const selected = opts?.select ? opts.select(slice) : slice;
+		if (opts?.structuralSharing ?? router.options.defaultStructuralSharing) {
+			return (previousResult.current = replaceEqualDeep(previousResult.current, selected));
+		}
+		return selected;
+	};
+}
+
+export function useMatch(...args: any[]): any {
+	const [user, slot] = splitSlot(args);
+	const opts = user[0] ?? {};
+	const router = useRouter();
+	// octane has no rules of hooks, so the nearest-match context is read
+	// unconditionally (upstream reads a dummy context when `from` is given).
+	const nearestMatchId = useContext(matchContext);
+	const matchStore = opts.from
+		? router.stores.getRouteMatchStore(opts.from)
+		: router.stores.matchStores.get(nearestMatchId as string);
+
+	const selector = useStructuralSharing(opts, router, subSlot(slot, 'm'));
+	const matchSelection = useStore(
+		matchStore ?? dummyStore,
+		(match: any) => (match ? selector(match) : dummyStore),
+		undefined,
+		subSlot(slot, 'm:us'),
+	);
+
+	if (matchSelection !== dummyStore) return matchSelection;
+	if (opts.shouldThrow ?? true) {
+		throw new Error(
+			`Invariant failed: Could not find ${
+				opts.from ? `an active match from "${opts.from}"` : 'a nearest match!'
+			}`,
+		);
+	}
+	return undefined;
+}
+
+export function useParams(...args: any[]): any {
+	const [user, slot] = splitSlot(args);
+	const opts = user[0] ?? {};
+	return useMatch(
+		{
+			from: opts.from,
+			strict: opts.strict,
+			shouldThrow: opts.shouldThrow,
+			structuralSharing: opts.structuralSharing,
+			select: (match: any) => {
+				const params = opts.strict === false ? match.params : match._strictParams;
+				return opts.select ? opts.select(params) : params;
+			},
+		},
+		subSlot(slot, 'params'),
+	);
+}
+
+export function useSearch(...args: any[]): any {
+	const [user, slot] = splitSlot(args);
+	const opts = user[0] ?? {};
+	return useMatch(
+		{
+			from: opts.from,
+			strict: opts.strict,
+			shouldThrow: opts.shouldThrow,
+			structuralSharing: opts.structuralSharing,
+			select: (match: any) => (opts.select ? opts.select(match.search) : match.search),
+		},
+		subSlot(slot, 'search'),
+	);
+}
+
+export function useLoaderData(...args: any[]): any {
+	const [user, slot] = splitSlot(args);
+	const opts = user[0] ?? {};
+	return useMatch(
+		{
+			from: opts.from,
+			strict: opts.strict,
+			structuralSharing: opts.structuralSharing,
+			select: (match: any) => (opts.select ? opts.select(match.loaderData) : match.loaderData),
+		},
+		subSlot(slot, 'loader'),
+	);
+}
+
+export function useLoaderDeps(...args: any[]): any {
+	const [user, slot] = splitSlot(args);
+	const opts = user[0] ?? {};
+	const { select, ...rest } = opts;
+	return useMatch(
+		{
+			...rest,
+			select: (match: any) => (select ? select(match.loaderDeps) : match.loaderDeps),
+		},
+		subSlot(slot, 'deps'),
+	);
+}
+
+export function useRouteContext(...args: any[]): any {
+	const [user, slot] = splitSlot(args);
+	const opts = user[0] ?? {};
+	return useMatch(
+		{
+			...opts,
+			select: (match: any) => (opts.select ? opts.select(match.context) : match.context),
+		},
+		subSlot(slot, 'ctx'),
+	);
+}
+
+export function useLocation(...args: any[]): any {
+	const [user, slot] = splitSlot(args);
+	const opts = user[0] ?? {};
+	const router = useRouter();
+	return useStore(
+		router.stores.location,
+		useStructuralSharing(opts, router, subSlot(slot, 'loc')),
+		undefined,
+		subSlot(slot, 'loc:us'),
+	);
+}
+
+export function useMatches(...args: any[]): any {
+	const [user, slot] = splitSlot(args);
+	const opts = user[0] ?? {};
+	const router = useRouter();
+	return useStore(
+		router.stores.matches,
+		useStructuralSharing(opts, router, subSlot(slot, 'matches')),
+		undefined,
+		subSlot(slot, 'matches:us'),
+	);
+}
+
+export function useParentMatches(...args: any[]): any {
+	const [user, slot] = splitSlot(args);
+	const opts = user[0] ?? {};
+	const contextMatchId = useContext(matchContext);
+	return useMatches(
+		{
+			select: (matches: any[]) => {
+				matches = matches.slice(
+					0,
+					matches.findIndex((d: any) => d.id === contextMatchId),
+				);
+				return opts.select ? opts.select(matches) : matches;
+			},
+			structuralSharing: opts.structuralSharing,
+		},
+		subSlot(slot, 'parents'),
+	);
+}
+
+export function useChildMatches(...args: any[]): any {
+	const [user, slot] = splitSlot(args);
+	const opts = user[0] ?? {};
+	const contextMatchId = useContext(matchContext);
+	return useMatches(
+		{
+			select: (matches: any[]) => {
+				matches = matches.slice(matches.findIndex((d: any) => d.id === contextMatchId) + 1);
+				return opts.select ? opts.select(matches) : matches;
+			},
+			structuralSharing: opts.structuralSharing,
+		},
+		subSlot(slot, 'children'),
+	);
+}
+
+// Returns a STABLE navigate function (upstream useCallback([from, router])) that
+// forwards to `router.navigate`, defaulting `from` to the hook's option.
+export function useNavigate(...args: any[]): (to: any) => any {
+	const [user, slot] = splitSlot(args);
+	const opts = user[0] ?? {};
+	const router = useRouter(opts.router ? { router: opts.router } : undefined);
+	return useCallback(
+		(options: any) => router.navigate({ ...options, from: options?.from ?? opts.from }),
+		[opts.from, router],
+		subSlot(slot, 'nav'),
+	);
+}
+
+// True when the current history entry isn't the first (there is somewhere to go
+// back to) — per upstream useCanGoBack (location.state.__TSR_index !== 0).
+export function useCanGoBack(...args: any[]): boolean {
+	const [, slot] = splitSlot(args);
+	const router = useRouter();
+	return useStore(
+		router.stores.location,
+		(location: any) => location.state.__TSR_index !== 0,
+		undefined,
+		subSlot(slot, 'back'),
+	);
+}

package/src/index.ts

@@ -0,0 +1,91 @@
+// @octanejs/tanstack-router — TanStack Router for the octane renderer.
+//
+// TanStack Router splits a framework-agnostic core (`@tanstack/router-core`: the
+// Router/route-tree/matching/history/reactive-store) from a thin React binding
+// (`@tanstack/react-router`). Mirroring @octanejs/tanstack-query, this package re-exports
+// the core VERBATIM and reimplements only the React binding on octane's hooks. The
+// load-bearing seam is router-core's reactive store: `createRouter` supplies the
+// CLIENT store factory (`createAtom`/`batch` from `@tanstack/store`), whose atoms
+// expose `.subscribe`/`.get` — bound to octane's `useSyncExternalStore` by
+// `useStore`. The match tree renders pull-based: `RouterProvider` → first match →
+// each route's `<Outlet/>` looks up the NEXT match via `matchContext`.
+//
+// Scope: code-based routing at react-router parity — RouterProvider (+
+// RouterContextProvider/Wrap/InnerWrap), the full Match pipeline (Suspense /
+// CatchBoundary / CatchNotFound per route, pending/error/redirect statuses,
+// remountDeps, shellComponent), the router event lifecycle
+// (onLoad/onBeforeRouteMount/onResolved/onRendered + resolvedLocation — scroll
+// restoration restores off it), Link with preloading/masking/active-options,
+// createLink/useLinkProps, navigation blocking (useBlocker/Block), the full
+// read-hook set (useMatch and friends, nearest-match resolution via
+// matchContext), Route/getRouteApi hook accessors, Await/useAwaited, lazy
+// routes, and search validation/middleware from core. Deferred: file-based
+// routing + codegen (`createFileRoute`, @tanstack/router-plugin), SSR entries
+// (RouterServer/RouterClient, HeadContent/Scripts), and devtools.
+export * from '@tanstack/router-core';
+export {
+	createHistory,
+	createBrowserHistory,
+	createHashHistory,
+	createMemoryHistory,
+} from './history';
+// History types on the main entry (upstream parity). `NavigateOptions` is NOT
+// re-exported from history — router-core's richer NavigateOptions wins.
+export type {
+	RouterHistory,
+	HistoryLocation,
+	ParsedPath,
+	HistoryState,
+	ParsedHistoryState,
+	HistoryAction,
+	BlockerFnArgs,
+	BlockerFn,
+	NavigationBlocker,
+} from '@tanstack/history';
+
+export { createRouter, Router } from './router';
+export {
+	createRoute,
+	createRootRoute,
+	createRootRouteWithContext,
+	createRouteMask,
+	getRouteApi,
+	Route,
+	RootRoute,
+	RouteApi,
+} from './route';
+export { routerContext, getRouterContext, matchContext, useRouter } from './context';
+export { useStore } from './useStore';
+export { useRouterState } from './useRouterState';
+export {
+	useMatch,
+	useLocation,
+	useParams,
+	useSearch,
+	useLoaderData,
+	useLoaderDeps,
+	useRouteContext,
+	useMatches,
+	useParentMatches,
+	useChildMatches,
+	useNavigate,
+	useCanGoBack,
+} from './hooks';
+export { useAwaited } from './useAwaited';
+export { useLinkProps, createLink, linkOptions } from './link';
+export { useBlocker, Block } from './useBlocker.tsrx';
+export { useMatchRoute, MatchRoute } from './MatchRoute.tsrx';
+export { useElementScrollRestoration } from './useElementScrollRestoration';
+export { lazyRouteComponent } from './lazyRouteComponent';
+
+export { RouterProvider, RouterContextProvider } from './RouterProvider.tsrx';
+export { Outlet } from './Outlet.tsrx';
+export { Link } from './Link.tsrx';
+export { Navigate } from './Navigate.tsrx';
+export { Await } from './Await.tsrx';
+export { ScrollRestoration } from './ScrollRestoration.tsrx';
+export { Matches } from './Matches.tsrx';
+export { Match } from './Match.tsrx';
+export { CatchBoundary, ErrorComponent } from './CatchBoundary.tsrx';
+export { CatchNotFound, DefaultGlobalNotFound } from './not-found.tsrx';
+export { ClientOnly, useHydrated } from './ClientOnly.tsrx';