@buzola/router 0.0.3 → 0.0.4

package/src/engine/router.ts

@@ -1,17 +1,14 @@
-import { matchRoutes } from './matcher'
-import type { BlockerFn, GuardRedirect, NavigateOptions, NavigationAdapter, RouteMatch, RouteNode, RouterState } from './types'
-import { extractParamNames } from './utils'
-
-function isGuardRedirect(value: unknown): value is GuardRedirect {
-	return typeof value === 'object' && value !== null && 'redirect' in value && typeof (value as GuardRedirect).redirect === 'string'
-}
+import { LoaderCache } from './loader-cache.js'
+import { matchRoutes } from './matcher.js'
+import type { BlockerFn, NavigateOptions, NavigationAdapter, RouteNode, RouterState } from './types.js'
+import { extractParamNames, parseParamSegment } from './utils.js'
 
 /**
  * Thrown when a route guard prevents navigation.
  */
 export class NavigationAbortedError extends Error {
 	constructor() {
-		super('Navigation aborted by route guard')
+		super('Navigation aborted by blocker')
 		this.name = 'NavigationAbortedError'
 	}
 }
@@ -42,7 +39,7 @@ export interface RouterOptions {
 	 */
 	pageRegistry?: Record<string, string>
 	/**
-	 * Number of previously visited URLs to keep cached per page component.
+	 * Maximum number of entries in the global loader cache (shared across all pages).
 	 * When navigating back to a cached URL, stale data is shown immediately
 	 * while a background reload runs (SWR).
 	 * Set to 0 to always re-fetch on URL change (default).
@@ -65,11 +62,10 @@ export class Router {
 	private invalidationListeners = new Set<() => void>()
 	private state: RouterState
 	private navigationId = 0
-	private currentAbortController?: AbortController
 	private stopFn: (() => void) | undefined
 	private blockers = new Set<BlockerFn>()
 	private pendingScrollBehavior: 'after-transition' | 'manual' = 'after-transition'
-	private readonly _loaderCacheSize: number
+	private readonly _loaderCache: LoaderCache | undefined
 
 	constructor(options: RouterOptions) {
 		this.routes = options.routes
@@ -78,11 +74,16 @@ export class Router {
 		this._basePath = options.basePath ? options.basePath.replace(/\/$/, '') : ''
 		this.persistentParamsFn = options.persistentParams
 		this.pageRegistry = options.pageRegistry ?? {}
-		this._loaderCacheSize = options.loaderCacheSize ?? 0
+		this._loaderCache = options.loaderCacheSize ? new LoaderCache(options.loaderCacheSize) : undefined
 
 		// Initialize state from current URL
 		const url = this.adapter.getCurrentURL()
-		const matches = matchRoutes(this.routes, this.createMatchUrl(url)) ?? []
+		const matchUrl = this.createMatchUrl(url)
+		const matches = matchRoutes(this.routes, matchUrl) ?? []
+
+		if (matches.length === 0) {
+			console.warn(`[buzola] No route matched URL "${url.pathname}". Define a catch-all 404 route to handle unmatched URLs.`)
+		}
 
 		this.state = {
 			location: url,
@@ -100,10 +101,11 @@ export class Router {
 	}
 
 	/**
-	 * Number of previously visited URLs to keep cached per page component.
+	 * Global LRU cache for page loader data, shared across all page components.
+	 * Undefined when loaderCacheSize is 0 (no caching).
 	 */
-	get loaderCacheSize(): number {
-		return this._loaderCacheSize
+	get loaderCache(): LoaderCache | undefined {
+		return this._loaderCache
 	}
 
 	/**
@@ -134,20 +136,16 @@ export class Router {
 			const url = new URL(event.destination.url)
 			const matchUrl = this.createMatchUrl(url)
 			const matches = matchRoutes(this.routes, matchUrl)
-			if (!matches) return
+			if (!matches) {
+				console.warn(`[buzola] No route matched URL "${url.pathname}". The navigation was not intercepted.`)
+				return
+			}
 
 			const currentNavId = ++this.navigationId
 			const useViewTransition = event.viewTransition || this.viewTransitions
 			const scrollBehavior = this.pendingScrollBehavior
 			this.pendingScrollBehavior = 'after-transition'
 
-			// Abort any in-flight guard from a previous navigation
-			if (this.currentAbortController) {
-				this.currentAbortController.abort()
-			}
-			const controller = new AbortController()
-			this.currentAbortController = controller
-
 			event.intercept({
 				scroll: scrollBehavior,
 				handler: async () => {
@@ -166,39 +164,6 @@ export class Router {
 						isPending: true,
 					})
 
-					// Run route guards (outer → inner)
-					for (const match of matches) {
-						// A newer navigation has started — abandon this one
-						if (this.navigationId !== currentNavId) return
-
-						if (match.node.beforeEnter) {
-							const result = await match.node.beforeEnter(match, { signal: controller.signal })
-							if (result === false) {
-								// Guard prevented navigation
-								if (this.navigationId === currentNavId) {
-									this.setState({
-										...this.state,
-										isPending: false,
-									})
-								}
-								throw new NavigationAbortedError()
-							}
-							if (isGuardRedirect(result)) {
-								// Guard requested redirect — don't reset isPending, the redirect
-								// navigation will take over the pending state.
-								if (this.navigationId === currentNavId) {
-									const redirectURL = new URL(result.redirect, url)
-									const redirectMatches = matchRoutes(this.routes, this.createMatchUrl(redirectURL))
-									if (!redirectMatches) {
-										throw new Error(`[buzola] Guard redirect target "${result.redirect}" does not match any route.`)
-									}
-									this.navigate(result.redirect, { replace: true })
-								}
-								throw new NavigationAbortedError()
-							}
-						}
-					}
-
 					// A newer navigation has started — abandon this one
 					if (this.navigationId !== currentNavId) return
 
@@ -289,9 +254,7 @@ export class Router {
 
 		for (const segment of segments) {
 			if (segment.startsWith(':')) {
-				// Catch-all param (:slug+)
-				const isCatchAll = segment.endsWith('+')
-				const paramName = isCatchAll ? segment.slice(1, -1) : segment.slice(1)
+				const { name: paramName, isCatchAll } = parseParamSegment(segment)
 				const value = params?.[paramName]
 				if (value === undefined) {
 					missing.push(paramName)
@@ -310,9 +273,9 @@ export class Router {
 
 		if (missing.length > 0) {
 			if (!params) {
-				throw new Error(`Missing params for path "${pattern}": ${missing.join(', ')}`)
+				throw new Error(`[buzola] Missing params for path "${pattern}": ${missing.join(', ')}`)
 			}
-			throw new Error(`Missing param "${missing[0]}" for path "${pattern}"`)
+			throw new Error(`[buzola] Missing param "${missing[0]}" for path "${pattern}"`)
 		}
 
 		// Extra params (not in path pattern) → query string
@@ -351,7 +314,7 @@ export class Router {
 	 * Only fills params that are present in the target pattern.
 	 */
 	resolveParams(pattern: string, explicitParams?: Record<string, string>): Record<string, string> {
-		const paramNames = this.extractParamNames(pattern)
+		const paramNames = extractParamNames(pattern)
 		const currentParams = this.getCurrentParams()
 		const fallbackParams = this.persistentParamsFn?.() ?? {}
 		const result: Record<string, string> = {}
@@ -376,13 +339,6 @@ export class Router {
 		return result
 	}
 
-	/**
-	 * Extract parameter names from a route pattern.
-	 */
-	private extractParamNames(pattern: string): string[] {
-		return extractParamNames(pattern)
-	}
-
 	/**
 	 * Get merged params from all current route matches.
 	 */
@@ -456,9 +412,7 @@ export class Router {
 	private createMatchUrl(url: URL): URL {
 		if (!this._basePath) return url
 		const stripped = new URL(url)
-		if (stripped.pathname.startsWith(this._basePath)) {
-			stripped.pathname = stripped.pathname.slice(this._basePath.length) || '/'
-		}
+		stripped.pathname = this.stripBasePath(stripped.pathname)
 		return stripped
 	}
 

package/src/engine/schema.ts

@@ -1,4 +1,4 @@
-import type { StandardSchema } from './types'
+import type { StandardSchema } from './types.js'
 
 /**
  * Built-in minimal Standard Schema builders for route params.
@@ -72,6 +72,17 @@ function object<T extends Record<string, StandardSchema>>(
 
 export const s = { object, string, optional }
 
+/**
+ * Validate a value against a Standard Schema, throwing on failure.
+ */
+export function validateSchema<T>(schema: StandardSchema<T>, value: unknown, errorPrefix: string): T {
+	const result = schema['~standard'].validate(value)
+	if ('issues' in result) {
+		throw new Error(`${errorPrefix}${result.issues.map(i => i.message).join(', ')}`)
+	}
+	return result.value
+}
+
 // ─── Param literals ─────────────────────────────────────────────────────────
 
 export type ParamLiteral = 'string' | 'number' | 'uuid' | '?string' | '?number' | '?uuid' | 'string[]' | 'number[]' | '?string[]' | '?number[]'
@@ -100,7 +111,7 @@ export function resolveParamLiteral(literal: ParamLiteral): {
 	const baseType = isArr ? rest.slice(0, -2) : rest
 
 	const validateScalar = scalarValidators[baseType]
-	if (!validateScalar) throw new Error(`Unknown param type: ${baseType}`)
+	if (!validateScalar) throw new Error(`[buzola] Unknown param type: ${baseType}`)
 
 	let validate: StandardSchema['~standard']['validate']
 

package/src/engine/types.ts

@@ -50,20 +50,6 @@ export interface StandardSchema<T = unknown> {
 	}
 }
 
-/** Result returned by a route guard to redirect navigation. */
-export interface GuardRedirect {
-	redirect: string
-}
-
-/** Context passed to route guards. */
-export interface GuardContext {
-	signal: AbortSignal
-}
-
-/** Guard function — return false to block, a GuardRedirect to redirect, or true/void to allow. */
-export type RouteGuardResult = boolean | void | GuardRedirect
-export type RouteGuard = (match: RouteMatch, context: GuardContext) => RouteGuardResult | Promise<RouteGuardResult>
-
 /** Route component — either a regular component or a lazy-loaded one. */
 export type RouteComponent = ComponentType<Record<string, never>> | LazyExoticComponent<ComponentType<Record<string, never>>>
 
@@ -71,12 +57,12 @@ export type RouteComponent = ComponentType<Record<string, never>> | LazyExoticCo
 export interface RouteConfig {
 	/** The path segment for this route. */
 	path: string
+	/** Override the URL path for matching (absolute, not joined with parent). */
+	matchPath?: string
 	/** Component to render for this route. */
 	component?: RouteComponent
 	/** Schema for validating search params (Standard Schema compatible). */
 	searchSchema?: StandardSchema
-	/** Guard function called before entering this route. */
-	beforeEnter?: RouteGuard
 	/** Child routes. */
 	children?: RouteConfig[]
 	/** Whether this is a layout route (has outlet but no own path segment). */
@@ -117,8 +103,6 @@ export interface RouteNode {
 	component?: RouteComponent
 	/** Search params schema. */
 	searchSchema?: StandardSchema
-	/** Route guard. */
-	beforeEnter?: RouteGuard
 	/** Child nodes. */
 	children: RouteNode[]
 	/** Parent node reference. */

package/src/engine/utils.ts

@@ -1,3 +1,13 @@
+/**
+ * Parse a dynamic route segment (e.g., ":userId" or ":slug+").
+ * Returns the parameter name and whether it's a catch-all.
+ */
+export function parseParamSegment(segment: string): { name: string; isCatchAll: boolean } {
+	const isCatchAll = segment.endsWith('+')
+	const name = isCatchAll ? segment.slice(1, -1) : segment.slice(1)
+	return { name, isCatchAll }
+}
+
 /**
  * Extract parameter names from a route pattern.
  * "/users/:userId/posts/:postId" → ["userId", "postId"]
@@ -7,9 +17,7 @@ export function extractParamNames(pattern: string): string[] {
 	const names: string[] = []
 	for (const segment of pattern.split('/')) {
 		if (segment.startsWith(':')) {
-			// Strip catch-all suffix (+)
-			const name = segment.endsWith('+') ? segment.slice(1, -1) : segment.slice(1)
-			names.push(name)
+			names.push(parseParamSegment(segment).name)
 		}
 	}
 	return names

package/src/index.ts

@@ -1,14 +1,16 @@
 // ─── Engine ─────────────────────────────────────────────────────────────────
-export { NavigationAbortedError, Router } from './engine/router'
-export type { RouterOptions, RouterSubscriber } from './engine/router'
+export { LoaderCache } from './engine/loader-cache.js'
 
-export { buildRouteTree, createRouteNode } from './engine/route-tree'
-export type { CreateRouteNodeOptions } from './engine/route-tree'
+export { NavigationAbortedError, Router } from './engine/router.js'
+export type { RouterOptions, RouterSubscriber } from './engine/router.js'
 
-export { matchRoutes } from './engine/matcher'
+export { buildRouteTree, createRouteNode } from './engine/route-tree.js'
+export type { CreateRouteNodeOptions } from './engine/route-tree.js'
 
-export { createBrowserNavigationAdapter, createMemoryNavigationAdapter } from './engine/navigation-adapter'
-export type { MemoryNavigationAdapterOptions } from './engine/navigation-adapter'
+export { matchRoutes } from './engine/matcher.js'
+
+export { createBrowserNavigationAdapter, createMemoryNavigationAdapter } from './engine/navigation-adapter.js'
+export type { MemoryNavigationAdapterOptions } from './engine/navigation-adapter.js'
 
 // ─── Types ──────────────────────────────────────────────────────────────────
 export type {
@@ -17,28 +19,24 @@ export type {
 	BuzolaPageMap,
 	BuzolaPersistentParams,
 	EffectivePageParams,
-	GuardContext,
-	GuardRedirect,
 	NavigateOptions,
 	NavigationAdapter,
 	PageParams,
 	RegisteredPage,
 	RouteComponent,
 	RouteConfig,
-	RouteGuard,
-	RouteGuardResult,
 	RouteMatch,
 	RouteNode,
 	RouterState,
 	StandardSchema,
-} from './engine/types'
+} from './engine/types.js'
 
 // ─── Schema ──────────────────────────────────────────────────────────────────
-export { s } from './engine/schema'
+export { s } from './engine/schema.js'
 
 // ─── Route definition ───────────────────────────────────────────────────────
-export { createPage } from './define/create-page'
-export type { CatchContext, PageDefinition, PageProps } from './define/create-page'
+export { BuzolaRedirect, createPage, redirect } from './define/create-page.js'
+export type { CatchContext, PageDefinition, PageProps, RedirectFn } from './define/create-page.js'
 
 // ─── React (re-export from subpath) ─────────────────────────────────────────
 export {
@@ -57,5 +55,5 @@ export {
 	useRouter,
 	useRouterState,
 	useSearchParams,
-} from './react/index'
-export type { BlockerState, BuzolaProviderProps, LinkProps, OutletProps, RouteContextValue } from './react/index'
+} from './react/index.js'
+export type { BlockerState, BuzolaProviderProps, LinkProps, OutletProps, RouteContextValue } from './react/index.js'

package/src/react/context.ts

@@ -1,6 +1,6 @@
 import { createContext } from 'react'
-import type { Router } from '../engine/router'
-import type { RouteMatch, RouterState } from '../engine/types'
+import type { Router } from '../engine/router.js'
+import type { RouteMatch, RouterState } from '../engine/types.js'
 
 /**
  * Context providing the Router instance.

package/src/react/hooks.ts

@@ -1,7 +1,8 @@
 import { use, useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import type { Router } from '../engine/router'
-import type { EffectivePageParams, NavigateOptions, RegisteredPage, RouterState, StandardSchema } from '../engine/types'
-import { RouteContext, RouterContext } from './context'
+import type { Router } from '../engine/router.js'
+import { validateSchema } from '../engine/schema.js'
+import type { EffectivePageParams, NavigateOptions, RegisteredPage, RouterState, StandardSchema } from '../engine/types.js'
+import { RouteContext, RouterContext } from './context.js'
 
 /**
  * Get the Router instance.
@@ -73,24 +74,24 @@ export function useSearchParams<T = Record<string, string>>(
 
 	return useMemo(() => {
 		const searchParams = context.state.location.searchParams
-		const raw: Record<string, string[]> = {}
+		const collected = new Map<string, string[]>()
 		searchParams.forEach((value, key) => {
-			const existing = raw[key]
+			const existing = collected.get(key)
 			if (existing) {
 				existing.push(value)
 			} else {
-				raw[key] = [value]
+				collected.set(key, [value])
 			}
 		})
 
+		// Single-value params are unwrapped to strings, multi-value remain as arrays
+		const raw: Record<string, string | string[]> = {}
+		for (const [key, values] of collected) {
+			raw[key] = values.length === 1 ? values[0] : values
+		}
+
 		if (schema) {
-			const result = schema['~standard'].validate(raw)
-			if ('issues' in result) {
-				throw new Error(
-					`Search params validation failed: ${result.issues.map(i => i.message).join(', ')}`,
-				)
-			}
-			return result.value
+			return validateSchema(schema, raw, '[buzola] Search params validation failed: ')
 		}
 
 		return raw as T

package/src/react/index.ts

@@ -1,16 +1,26 @@
-export { BuzolaProvider } from './provider'
-export type { BuzolaProviderProps } from './provider'
+export { BuzolaProvider } from './provider.js'
+export type { BuzolaProviderProps, MiddlewareComponent, MiddlewareProps } from './provider.js'
 
-export { Outlet } from './outlet'
-export type { OutletProps } from './outlet'
+export { Outlet } from './outlet.js'
+export type { OutletProps } from './outlet.js'
 
-export { Link } from './link'
-export type { LinkProps } from './link'
+export { Link } from './link.js'
+export type { LinkProps } from './link.js'
 
-export { ErrorBoundary } from './error-boundary'
+export { ErrorBoundary } from './error-boundary.js'
 
-export { useBlocker, useInvalidate, useNavigate, useNavigationState, useParams, useRoute, useRouter, useRouterState, useSearchParams } from './hooks'
-export type { BlockerState } from './hooks'
+export {
+	useBlocker,
+	useInvalidate,
+	useNavigate,
+	useNavigationState,
+	useParams,
+	useRoute,
+	useRouter,
+	useRouterState,
+	useSearchParams,
+} from './hooks.js'
+export type { BlockerState } from './hooks.js'
 
-export { RouteContext, RouterContext } from './context'
-export type { RouteContextValue } from './context'
+export { RouteContext, RouterContext } from './context.js'
+export type { RouteContextValue } from './context.js'

package/src/react/link.tsx

@@ -22,6 +22,11 @@ type LinkPropsBase = Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'href'>
 	 * When `false`, `data-active` is also set when the current path starts with the link target.
 	 */
 	activeExact?: boolean
+	/**
+	 * Render as child element instead of `<a>`.
+	 * When `true`, clones the single child element and merges `href`, `onClick`, and `data-active` props into it.
+	 */
+	asChild?: boolean
 }
 
 export type LinkProps<P extends RegisteredPage = RegisteredPage> = [keyof EffectivePageParams<P>] extends [never]
@@ -47,6 +52,7 @@ export function Link<P extends RegisteredPage>(props: LinkProps<P>): React.React
 		viewTransition,
 		resetScroll,
 		activeExact = true,
+		asChild,
 		onClick,
 		children,
 		...rest
@@ -85,6 +91,16 @@ export function Link<P extends RegisteredPage>(props: LinkProps<P>): React.React
 		[onClick, needsProgrammaticNav, router, to, params, replace, state, viewTransition, resetScroll],
 	)
 
+	if (asChild) {
+		const child = React.Children.only(children) as React.ReactElement<any>
+		return React.cloneElement(child, {
+			href,
+			onClick: handleClick,
+			'data-active': isActive ? '' : undefined,
+			...rest,
+		})
+	}
+
 	return (
 		<a href={href} onClick={handleClick} data-active={isActive ? '' : undefined} {...rest}>
 			{children}

package/src/react/outlet.tsx

@@ -2,18 +2,44 @@ import React, { Suspense, use, useMemo } from 'react'
 import { RouteContext, type RouteContextValue } from './context.js'
 import { ErrorBoundary } from './error-boundary.js'
 
+const isDev = typeof process !== 'undefined' && process.env.NODE_ENV !== 'production'
+
+function DefaultNotFound(): React.ReactElement {
+	return React.createElement(
+		'div',
+		{
+			style: { fontFamily: 'system-ui, sans-serif', padding: '2rem', maxWidth: '600px', margin: '0 auto' },
+		},
+		isDev
+			? [
+				React.createElement('h1', { key: 'h' }, '404 — Page Not Found'),
+				React.createElement('p', { key: 'p1' }, `No route matches "${typeof window !== 'undefined' ? window.location.pathname : ''}".`),
+				React.createElement('p', {
+					key: 'p2',
+					style: { color: '#666', fontSize: '0.9rem' },
+				}, 'To handle this, add a _404.tsx catch-all route or pass a notFound prop to <Outlet />.'),
+			]
+			: [
+				React.createElement('h1', { key: 'h' }, '404'),
+				React.createElement('p', { key: 'p' }, 'Page not found.'),
+			],
+	)
+}
+
 export interface OutletProps {
 	/** Fallback to show while lazy components load. */
 	fallback?: React.ReactNode
 	/** Fallback to show when a route component throws an error. */
 	errorFallback?: React.ReactNode | ((error: Error) => React.ReactNode)
+	/** Content to show when no route matches. Defaults to a built-in 404 page. Pass `null` to render nothing. */
+	notFound?: React.ReactNode
 }
 
 /**
  * Renders the component for the current depth in the route match chain.
  * Each Outlet increments the depth and renders the next matched route's component.
  */
-export function Outlet({ fallback, errorFallback }: OutletProps): React.ReactElement | null {
+export function Outlet({ fallback, errorFallback, notFound }: OutletProps): React.ReactElement | null {
 	const routeContext = use(RouteContext)
 	if (!routeContext) {
 		throw new Error('<Outlet /> must be used within a <BuzolaProvider>')
@@ -48,6 +74,11 @@ export function Outlet({ fallback, errorFallback }: OutletProps): React.ReactEle
 	}, [state, depth, effectiveDepth, matches, match, routeContext.params])
 
 	if (!match) {
+		// At root depth with no matches — show 404
+		if (depth === 0 && matches.length === 0) {
+			if (notFound === null) return null
+			return (notFound ?? React.createElement(DefaultNotFound, null)) as React.ReactElement
+		}
 		return null
 	}
 

package/src/react/provider.tsx

@@ -1,13 +1,28 @@
-import React, { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react'
+import React, { useCallback, useLayoutEffect, useMemo, useRef, useSyncExternalStore } from 'react'
 import { createBrowserNavigationAdapter } from '../engine/navigation-adapter.js'
 import { Router } from '../engine/router.js'
-import type { RouteNode } from '../engine/types.js'
+import type { RouteMatch, RouteNode } from '../engine/types.js'
 import { RouteContext, type RouteContextValue, RouterContext } from './context.js'
 import { Outlet } from './outlet.js'
 
+/** Props passed to the middleware component. */
+export interface MiddlewareProps {
+	/** Merged params from all matched routes. */
+	params: Record<string, string>
+	/** All route matches from root to leaf. */
+	matches: RouteMatch[]
+	/** The rendered route tree to wrap. */
+	children: React.ReactNode
+}
+
+/** Middleware component that wraps the entire router output. */
+export type MiddlewareComponent = React.ComponentType<MiddlewareProps>
+
 export type BuzolaProviderProps =
 	& {
 		children?: React.ReactNode
+		/** Global middleware that wraps the rendered route tree. Has access to all matched params. */
+		middleware?: MiddlewareComponent
 	}
 	& (
 		| { router: Router; routes?: never; persistentParams?: never; pageRegistry?: never }
@@ -23,7 +38,7 @@ export type BuzolaProviderProps =
  * Root provider for Buzola router.
  * Subscribes to router state and provides context to the React tree.
  */
-export function BuzolaProvider({ routes, children, ...props }: BuzolaProviderProps): React.ReactElement {
+export function BuzolaProvider({ routes, children, middleware: Middleware, ...props }: BuzolaProviderProps): React.ReactElement {
 	const routerRef = useRef<Router | undefined>(props.router)
 	if (!routerRef.current) {
 		routerRef.current = new Router({
@@ -39,7 +54,7 @@ export function BuzolaProvider({ routes, children, ...props }: BuzolaProviderPro
 	const state = useSyncExternalStore(subscribe, getSnapshot, getSnapshot)
 
 	// Start navigation interception
-	useEffect(() => {
+	useLayoutEffect(() => {
 		return router.start()
 	}, [router])
 
@@ -50,10 +65,23 @@ export function BuzolaProvider({ routes, children, ...props }: BuzolaProviderPro
 		params: {},
 	}), [state])
 
+	// Merge params from all matches for middleware
+	const allParams = useMemo(() => {
+		let merged: Record<string, string> = {}
+		for (const match of state.matches) {
+			merged = { ...merged, ...match.params }
+		}
+		return merged
+	}, [state.matches])
+
+	const content = children ?? <Outlet />
+
 	return (
 		<RouterContext value={router}>
 			<RouteContext value={routeContextValue}>
-				{children ?? <Outlet />}
+				{Middleware
+					? <Middleware params={allParams} matches={state.matches}>{content}</Middleware>
+					: content}
 			</RouteContext>
 		</RouterContext>
 	)

package/dist/__tests__/create-page.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=create-page.test.d.ts.map

package/dist/__tests__/create-page.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-page.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/create-page.test.ts"],"names":[],"mappings":""}