@jk2908/solas 0.3.0 → 0.3.2

package/dist/internal/browser-router/router.d.ts

@@ -0,0 +1,184 @@
+import type { RscPayload } from '../env/rsc.js';
+import { Solas } from '../../solas.js';
+export declare namespace BrowserRouter {
+    export type Params = Record<string, string>;
+    export type Query = Record<string, string | number | boolean>;
+    export type Path = keyof Solas.Routes & string;
+    type Replace = {
+        replace?: boolean;
+    };
+    export type GoOptions = {
+        replace?: boolean;
+        query?: Query;
+        params?: Params;
+    };
+    /**
+     * These targets are used as-is. They are not matched against the route table,
+     * so this covers normal external URLs and hash-only links
+     */
+    export type ExternalTarget = `${string}:${string}` | `//${string}` | `#${string}`;
+    export function isHashOnlyTarget(target: string): boolean;
+    export function isExternalTarget(target: string, origin: string): boolean;
+    /**
+     * Turn a route pattern into the real path shape a caller can use. In practice,
+     * every ':param' or '*' part becomes a plain string slot
+     *
+     * @example
+     * ```ts
+     * // '/p/:id' becomes '/p/${string}'
+     * // '/test/*' becomes '/test/${string}'
+     * // '/posts' stays '/posts'
+     * ```
+     *
+     * @example
+     * ```ts
+     * type A = ResolvedPath<'/posts/:id'>
+     * // '/posts/${string}'
+     * ```
+     *
+     * @example
+     * ```ts
+     * type B = ResolvedPath<'/docs/*'>
+     * // '/docs/${string}'
+     * ```
+     */
+    export type ResolvedPath<TPath extends string> = TPath extends `${infer Start}:${string}/${infer Rest}` ? `${Start}${string}/${ResolvedPath<Rest>}` : TPath extends `${infer Start}:${string}` ? `${Start}${string}` : TPath extends `${infer Start}*${infer Rest}` ? `${Start}${string}${ResolvedPath<Rest>}` : TPath;
+    /**
+     * Once we have a real path, also allow the usual query-string and hash forms
+     *
+     * @example
+     * ```ts
+     * type A = TargetSuffix<'/posts/123'>
+     * // '/posts/123' | '/posts/123?${string}' | '/posts/123#${string}' | '/posts/123?${string}#${string}'
+     * ```
+     */
+    export type TargetSuffix<TPath extends string> = TPath | `${TPath}?${string}` | `${TPath}#${string}` | `${TPath}?${string}#${string}`;
+    /**
+     * This is the final string form a caller can navigate to. It can be an external
+     * URL, or a concrete URL that matches one of the  known routes
+     *
+     * @example
+     * ```ts
+     * type A = Target
+     * // 'https://example.com'
+     * // '#intro'
+     * // '/posts/123'
+     * // '/posts/123?draft=true'
+     * ```
+     */
+    export type Target = ExternalTarget | TargetSuffix<ResolvedPath<Path>>;
+    /**
+     * Extra options for callers who already have a finished target string
+     *
+     * @example
+     * ```ts
+     * const a: TargetConfig = { query: { page: 2 } }
+     * // params is rejected here because the path is already complete
+     * ```
+     */
+    type TargetConfig = {
+        params?: never;
+        query?: Query;
+    };
+    /**
+     * Extra options for callers who pass a route pattern and params separately.
+     * If the route definition says that route needs params, this type makes
+     * those params required. If the route has no params, it rejects them
+     *
+     * @example
+     * ```ts
+     * // if Solas.Routes['/posts/:id'] is { params: { id: string } }
+     * type A = PatternConfig<'/posts/:id'>
+     * // { query?: Query } & { params: { id: string } }
+     * ```
+     *
+     * @example
+     * ```ts
+     * // if Solas.Routes['/about'] has no params field
+     * type B = PatternConfig<'/about'>
+     * // { query?: Query } & { params?: never }
+     * ```
+     */
+    type PatternConfig<TPath extends Path> = {
+        query?: Query;
+    } & (Solas.Routes[TPath] extends {
+        params: infer TParams extends Params;
+    } ? {
+        params: TParams;
+    } : {
+        params?: never;
+    });
+    /**
+     * Typed <Link /> props, using `href` instead of the internal `to` name
+     *
+     * `query` is always allowed
+     * `params` are only allowed when `href` is a known route pattern
+     *
+     * @example
+     * ```ts
+     * const a: LinkProps = { href: '/posts/:id', params: { id: '123' } }
+     * const b: LinkProps = { href: '/posts/123?draft=true' }
+     * ```
+     */
+    export type LinkProps = ({
+        href: Target;
+    } & TargetConfig) | (keyof Solas.Routes extends never ? never : {
+        [TPath in Path]: {
+            href: TPath;
+        } & PatternConfig<TPath>;
+    }[Path]);
+    /**
+     * Typed input for router.go(), using the same route rules as <Link />
+     *
+     * @example
+     * ```ts
+     * go('/p/post-2')
+     * go('/?foo=bar', { replace: true })
+     * ```
+     *
+     * @example
+     * ```ts
+     * go('/p/:id', { params: { id: 'post-2' }, replace: true })
+     * ```
+     *
+     * The last overload is the fallback for plain `string` values. The
+     * `string extends TTo` check stops that fallback from taking over
+     * when TypeScript already knows the caller passed a more specific
+     * string literal
+     *
+     * @example
+     * ```ts
+     * declare const dynamicPath: string
+     * go(dynamicPath, { replace: true })
+     * ```
+     */
+    export type Go = {
+        <TTo extends Path>(to: TTo, opts?: PatternConfig<TTo> & Replace): Promise<string>;
+        <TTo extends Target>(to: TTo, opts?: TargetConfig & Replace): Promise<string>;
+        <TTo extends string>(to: string extends TTo ? TTo : never, opts?: GoOptions): Promise<string>;
+    };
+    /**
+     * Convert a route pattern and params into a real path string. This is used internally
+     * to implement <Link /> and router.go
+     */
+    export function toTarget(path: string, params?: Record<string, string>, query?: BrowserRouter.Query): string;
+    export {};
+}
+export declare const BrowserRouterContext: import("react").Context<{
+    go: BrowserRouter.Go;
+    prefetch: (path: string) => void;
+    isNavigating: boolean;
+    url: {
+        pathname?: string | undefined;
+        search?: string | undefined;
+    };
+}>;
+export declare function BrowserRouterProvider({ children, setPayload, isNavigating, url }: {
+    children: React.ReactNode;
+    setPayload?: (payload: RscPayload) => void;
+    isNavigating?: boolean;
+    url?: {
+        pathname?: string;
+        search?: string;
+    };
+}): import("react/jsx-runtime").JSX.Element;

package/dist/internal/{router/router-provider.js → browser-router/router.js}

@@ -1,17 +1,85 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { createContext, useCallback, useEffect, useMemo, useRef } from 'react';
 import { createFromFetch } from '@vitejs/plugin-rsc/browser';
 import { Logger } from '../../utils/logger.js';
 import { Solas } from '../../solas.js';
-import { Prefetcher } from './prefetcher.js';
-import { RouterContext } from './router-context.js';
+import { Prefetcher } from './../prefetcher.js';
+export { BrowserRouter };
+var BrowserRouter;
+(function (BrowserRouter) {
+    function isHashOnlyTarget(target) {
+        return target.startsWith('#');
+    }
+    BrowserRouter.isHashOnlyTarget = isHashOnlyTarget;
+    function isExternalTarget(target, origin) {
+        if (isHashOnlyTarget(target))
+            return false;
+        try {
+            return new URL(target, origin).origin !== origin;
+        }
+        catch {
+            return false;
+        }
+    }
+    BrowserRouter.isExternalTarget = isExternalTarget;
+    /**
+     * Convert a route pattern and params into a real path string. This is used internally
+     * to implement <Link /> and router.go
+     */
+    function toTarget(path, params, query) {
+        // keep track of which params were consumed by named `:param` slots
+        const used = new Set();
+        // replace each named route param with its URL-encoded value
+        let to = path.replaceAll(/:([A-Za-z0-9_]+)/g, (_, key) => {
+            const value = params?.[key];
+            if (value == null) {
+                throw new Error(`[Link]: missing route param: ${key}`);
+            }
+            used.add(key);
+            return encodeURIComponent(value);
+        });
+        if (to.includes('*')) {
+            // wildcard routes use the one param that was not already matched by a named slot
+            const remaining = Object.entries(params ?? {}).filter(([key]) => !used.has(key));
+            if (remaining.length !== 1) {
+                throw new Error('[Link]: wildcard routes require exactly one unmatched param');
+            }
+            // encode each path segment separately so embedded '/' still acts like a path separator
+            to = to.replace('*', remaining[0][1].split('/').map(encodeURIComponent).join('/'));
+        }
+        if (!query)
+            return to;
+        // split the URL up so new query params can be merged without losing an existing hash
+        const hashIndex = to.indexOf('#');
+        const hash = hashIndex >= 0 ? to.slice(hashIndex) : '';
+        const pathWithSearch = hashIndex >= 0 ? to.slice(0, hashIndex) : to;
+        const searchIndex = pathWithSearch.indexOf('?');
+        const pathname = searchIndex >= 0 ? pathWithSearch.slice(0, searchIndex) : pathWithSearch;
+        const currentSearch = searchIndex >= 0 ? pathWithSearch.slice(searchIndex + 1) : '';
+        const search = new URLSearchParams(currentSearch);
+        // later values win, so passed query props overwrite any existing query string values
+        for (const [key, value] of Object.entries(query)) {
+            search.set(key, String(value));
+        }
+        const value = search.toString();
+        // rebuild the URL in the same order: pathname, optional query string, then hash
+        return `${pathname}${value.length > 0 ? `?${value}` : ''}${hash}`;
+    }
+    BrowserRouter.toTarget = toTarget;
+})(BrowserRouter || (BrowserRouter = {}));
+export const BrowserRouterContext = createContext({
+    go: async () => '',
+    prefetch: () => { },
+    isNavigating: false,
+    url: {},
+});
 const DEFAULT_GO_CONFIG = {
     replace: false,
 };
 const logger = new Logger();
 const prefetcher = new Prefetcher();
-export function RouterProvider({ children, setPayload, isNavigating = false, url, }) {
+export function BrowserRouterProvider({ children, setPayload, isNavigating = false, url, }) {
     // id to track active navigations
     const id = useRef(0);
     // abort controller for in-flight navigation
@@ -35,16 +103,15 @@ export function RouterProvider({ children, setPayload, isNavigating = false, url
         // opportunistically for this navigation
         let existing = false;
         try {
-            const url = new URL(to, window.location.origin);
-            if (opts?.query) {
-                for (const [key, value] of Object.entries(opts.query)) {
-                    url.searchParams.set(key, String(value));
-                }
+            const target = BrowserRouter.toTarget(to, opts.params, opts.query);
+            if (BrowserRouter.isExternalTarget(target, window.location.origin)) {
+                throw new Error('[router.go]: external URLs are not supported. Use <a> instead');
             }
+            const url = new URL(target, window.location.origin);
             const key = Prefetcher.key(url.toString(), window.location.origin);
             if (!key)
                 throw new Error('Invalid navigation url');
-            // switch to the normalized target once the url is valid
+            // switch to the normalised target once the url is valid
             path = key;
             // if the target was already prefetched, use the cached response promise
             // and set existing to true so we don't remove it from cache
@@ -128,7 +195,9 @@ export function RouterProvider({ children, setPayload, isNavigating = false, url
         prefetcher.set(key, fetch(key, { headers: { Accept: 'text/x-component' } }));
     }, []);
     useEffect(() => {
-        const handler = () => go(window.location.href, { replace: true });
+        const handler = () => go(BrowserRouter.toTarget(window.location.pathname + window.location.search), {
+            replace: true,
+        });
         window.addEventListener('popstate', handler);
         return () => {
             controller.current?.abort();
@@ -145,5 +214,5 @@ export function RouterProvider({ children, setPayload, isNavigating = false, url
             search: url?.search,
         },
     }), [go, prefetch, isNavigating, url]);
-    return _jsx(RouterContext, { value: value, children: children });
+    return _jsx(BrowserRouterContext, { value: value, children: children });
 }

package/dist/internal/{router → browser-router}/use-router.d.ts

@@ -1,5 +1,5 @@
 export declare function useRouter(): {
-    go: (to: string, opts?: import("./router-context.js").Navigation.GoOptions | undefined) => Promise<string>;
+    go: import("./router.js").BrowserRouter.Go;
     prefetch: (path: string) => void;
     isNavigating: boolean;
     url: {

package/dist/internal/browser-router/use-router.js

@@ -0,0 +1,5 @@
+import { use } from 'react';
+import { BrowserRouterContext } from './router.js';
+export function useRouter() {
+    return use(BrowserRouterContext);
+}

package/dist/internal/{navigation → browser-router}/use-search-params.js

@@ -1,6 +1,6 @@
 import { useMemo, useSyncExternalStore } from 'react';
-import { useRouter } from '../../router.js';
 import { Solas } from '../../solas.js';
+import { useRouter } from '../browser-router/use-router.js';
 export function useSearchParams() {
     const { url } = useRouter();
     const search = useSyncExternalStore(fn => {

package/dist/internal/build.js

@@ -1,8 +1,8 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { Solas } from '../solas.js';
 import { Logger } from '../utils/logger.js';
-import { normalisePathname } from './router/utils.js';
+import { Solas } from '../solas.js';
+import { normalisePathname } from './http-router/utils.js';
 import { Prerender } from './prerender.js';
 export { Build };
 /**

package/dist/internal/codegen/config.js

@@ -1,19 +1,28 @@
 import { Solas } from '../../solas.js';
-import { AUTOGEN_MSG, toSourceLiteral } from './utils.js';
+import { AUTOGEN_MSG, source, toSourceLiteral } from './utils.js';
 /**
  * Generates the code to create an exported config object
  */
 export function writeConfig(config) {
-    return `
+    const loggerLevel = config.logger?.level;
+    const importLines = [
+        `import type { PluginConfig } from '${Solas.Config.PKG_NAME}'`,
+        loggerLevel ? `import { Logger } from '${Solas.Config.PKG_NAME}/utils/logger'` : '',
+    ]
+        .filter(Boolean)
+        .join('\n');
+    const configStatement = `const config = ${toSourceLiteral(config)} as const satisfies PluginConfig`;
+    const loggerStatement = loggerLevel
+        ? `Logger.defaultLevel = ${toSourceLiteral(loggerLevel)}`
+        : '';
+    return source `
 		${AUTOGEN_MSG}
 
-		import type { PluginConfig } from '${Solas.Config.PKG_NAME}'
-		import { Logger } from '${Solas.Config.PKG_NAME}/utils/logger'
+		${importLines}
 
-		const config = ${toSourceLiteral(config)} as const satisfies PluginConfig
-
-		if (config.logger?.level) Logger.defaultLevel = config.logger.level
+		${configStatement}
+		${loggerStatement}
 
 		export { config }
-	`.trim();
+	`;
 }

package/dist/internal/codegen/environments.js

@@ -1,10 +1,10 @@
 import { Solas } from '../../solas.js';
-import { AUTOGEN_MSG } from './utils.js';
+import { AUTOGEN_MSG, source } from './utils.js';
 /**
  * Generates the RSC entry code
  */
 export function writeRSCEntry() {
-    return `
+    return source `
 		${AUTOGEN_MSG}
 
 		import { createHandler } from '${Solas.Config.PKG_NAME}/env/rsc'
@@ -20,27 +20,27 @@ export function writeRSCEntry() {
 		export default createHandler(config, manifest, importMap, artifactManifest)
 
 		import.meta.hot?.accept()
-	`.trim();
+	`;
 }
 /**
  * Generates the SSR entry code
  */
 export function writeSSREntry() {
-    return `
+    return source `
 		${AUTOGEN_MSG}
 
 		export { prerender, resume, ssr } from '${Solas.Config.PKG_NAME}/env/ssr'
-	`.trim();
+	`;
 }
 /**
  * Generates the browser entry code
  */
 export function writeBrowserEntry() {
-    return `
+    return source `
 		${AUTOGEN_MSG}
 
 		import { browser } from '${Solas.Config.PKG_NAME}/env/browser'
 
 		browser()
-	`.trim();
+	`;
 }

package/dist/internal/codegen/manifest.js

@@ -1,14 +1,14 @@
 import { Solas } from '../../solas.js';
-import { AUTOGEN_MSG, toSourceLiteral } from './utils.js';
+import { AUTOGEN_MSG, source, toSourceLiteral } from './utils.js';
 /**
  * Generates the code to create an exported manifest object
  */
 export function writeManifest(manifest) {
-    return `
+    return source `
 		${AUTOGEN_MSG}
 
 		import type { Manifest } from '${Solas.Config.PKG_NAME}'
 
 		export const manifest = ${toSourceLiteral(manifest)} as const satisfies Manifest
-	`.trim();
+	`;
 }

package/dist/internal/codegen/maps.js

@@ -1,5 +1,5 @@
 import { Solas } from '../../solas.js';
-import { AUTOGEN_MSG, toIdentifier, toIdentifierList, toRelativeModuleSpecifier, toStringLiteral, } from './utils.js';
+import { AUTOGEN_MSG, indent, source, toIdentifier, toIdentifierList, toRelativeModuleSpecifier, toStringLiteral, } from './utils.js';
 /**
  * Generates the import map for all route components, endpoints, layouts, shells, and middlewares
  */
@@ -61,26 +61,22 @@ export function writeMaps(imports, modules) {
             parts.push(`middlewares: [${middleware}]`);
         }
         if (parts.length === 0)
-            return `\t${toStringLiteral(moduleId)}: {}`;
-        return `\t${toStringLiteral(moduleId)}: {\n\t\t${parts.join(',\n\t\t')}\n\t}`;
+            return `${toStringLiteral(moduleId)}: {}`;
+        return `${toStringLiteral(moduleId)}: {\n${parts.map(part => indent(part, 1)).join(',\n')}\n}`;
     });
-    return `
+    const importLines = [...statics, ...dynamics].join('\n');
+    const entries = map.map(entry => indent(entry, 1)).join(',\n');
+    return source `
 		${AUTOGEN_MSG}
 
 		import type { ImportMap } from '${Solas.Config.PKG_NAME}'
-
-		${statics.length
-        ? `${statics.join('\n')}
-
-		`
-        : ''}${dynamics.length
-        ? `${dynamics.join('\n')}
-
-		`
+${importLines
+        ? `
+${importLines}`
         : ''}
 
 		export const importMap = {
-		${map.join(',\n')}
+${entries}
 		} as const satisfies ImportMap
-	`.trim();
+	`;
 }

package/dist/internal/codegen/types.d.ts

@@ -0,0 +1,5 @@
+import { Manifest } from '../../types.js';
+/**
+ * Generates runtime types
+ */
+export declare function writeTypes(manifest: Manifest): string;

package/dist/internal/codegen/types.js

@@ -0,0 +1,48 @@
+import { Solas } from '../../solas.js';
+import { Build } from '../build.js';
+import { AUTOGEN_MSG, source } from './utils.js';
+function render(path, params) {
+    if (!params || params.length === 0) {
+        return `\t\t\t'${path}': {}`;
+    }
+    const fields = params.map(param => `\t\t\t\t\t${param}: string`).join('\n');
+    return [`\t\t\t'${path}': {`, `\t\t\t\tparams: {`, fields, `\t\t\t\t}`, `\t\t\t}`].join('\n');
+}
+/**
+ * Generates runtime types
+ */
+export function writeTypes(manifest) {
+    const routes = new Map();
+    for (const path in manifest) {
+        const route = manifest[path];
+        if (Array.isArray(route)) {
+            for (const r of route) {
+                if (r.__kind !== Build.EntryKind.PAGE)
+                    continue;
+                routes.set(r.__path, r.__params);
+            }
+        }
+        else {
+            if (route.__kind !== Build.EntryKind.PAGE)
+                continue;
+            routes.set(route.__path, route.__params);
+        }
+    }
+    const body = [...routes.entries()]
+        // sort routes by path for stable output
+        .toSorted(([a], [b]) => a.localeCompare(b))
+        .map(([path, params]) => render(path, params))
+        .join('\n');
+    return source `
+   ${AUTOGEN_MSG}
+
+	 import '${Solas.Config.PKG_NAME}'
+
+	 declare module '${Solas.Config.PKG_NAME}' {
+		export namespace Solas {
+			export interface Routes {
+				${body}
+			}
+		}
+	 }`;
+}

package/dist/internal/codegen/utils.d.ts

@@ -15,7 +15,17 @@ export declare function toIdentifierList(values: readonly (string | null)[], lab
  * Escape text into a safe string literal for generated source
  */
 export declare function toStringLiteral(value: string, quoteStyle?: "'" | '"'): string;
+/**
+ * Dedent an interpolated template literal while preserving indentation for
+ * multiline substitutions
+ */
+export declare function source(strings: TemplateStringsArray, ...values: Array<string | number | boolean | false | null | undefined>): string;
 /**
  * Emit readable ts source for generated config and manifest data
  */
 export declare function toSourceLiteral(value: unknown, level?: number): string;
+/**
+ * Indent each line of a block of source code by the specified level for embedding in
+ * generated output
+ */
+export declare function indent(value: string, level?: number): string;

package/dist/internal/codegen/utils.js

@@ -60,6 +60,31 @@ export function toStringLiteral(value, quoteStyle = "'") {
         .replace(/\r/g, '\\r')
         .replace(/\t/g, '\\t')}${quoteStyle}`;
 }
+/**
+ * Dedent an interpolated template literal while preserving indentation for
+ * multiline substitutions
+ */
+export function source(strings, ...values) {
+    let text = strings[0] ?? '';
+    for (let index = 0; index < values.length; index += 1) {
+        const value = values[index];
+        const indentation = text.match(/(?:^|\n)([ \t]*)$/)?.[1] ?? '';
+        const chunk = value === false || value == null ? '' : String(value);
+        text += chunk.replace(/\n/g, `\n${indentation}`);
+        text += strings[index + 1] ?? '';
+    }
+    const lines = text.replace(/^\n+|\n+$/g, '').split('\n');
+    const margin = lines
+        .filter(line => line.trim().length > 0)
+        .reduce((smallest, line) => {
+        const indentation = line.match(/^[ \t]*/)?.[0].length ?? 0;
+        return Math.min(smallest, indentation);
+    }, Number.POSITIVE_INFINITY);
+    if (!Number.isFinite(margin) || margin === 0) {
+        return lines.join('\n');
+    }
+    return lines.map(line => line.slice(margin)).join('\n');
+}
 /**
  * Convert a string into a valid unquoted property key if possible, otherwise quote it
  * as a string literal for generated source
@@ -120,7 +145,7 @@ export function toSourceLiteral(value, level = 0) {
                     }
                     return `${prefix}${source.replace(/\n/g, `\n${INDENT.repeat(level + 1)}`)}`;
                 }
-                return `${prefix}${toSourceLiteral(entryValue, level + 1).replace(/\n/g, `\n${INDENT.repeat(level + 1)}`)}`;
+                return `${prefix}${toSourceLiteral(entryValue, level + 1)}`;
             })
                 .join(',\n'),
             `${INDENT.repeat(level)}}`,
@@ -132,7 +157,7 @@ export function toSourceLiteral(value, level = 0) {
  * Indent each line of a block of source code by the specified level for embedding in
  * generated output
  */
-function indent(value, level = 1) {
+export function indent(value, level = 1) {
     const prefix = INDENT.repeat(level);
     return value
         .split('\n')

package/dist/internal/env/browser.js

@@ -2,18 +2,18 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { StrictMode, Suspense, useCallback, useState, useTransition } from 'react';
 import { hydrateRoot } from 'react-dom/client';
 import { createFromFetch, createFromReadableStream, createTemporaryReferenceSet, encodeReply, setServerCallback, } from '@vitejs/plugin-rsc/browser';
-import { rscStream } from 'rsc-html-stream/client';
+import { BrowserRouterProvider } from '../browser-router/router.js';
 import { RedirectBoundary } from '../navigation/redirect-boundary.js';
 import { Head } from '../render/head.js';
-import { RouterProvider } from '../router/router-provider.js';
 import { ErrorBoundary } from '../ui/error-boundary.js';
+import { rscStream } from './flight.js';
 /**
  * Browser RSC hydration entry point
  */
 export async function browser() {
-    const payload = await createFromReadableStream(rscStream, {
-        unstable_allowPartialStream: true,
-    });
+    // read the initial payload from the inline __FLIGHT_DATA pushes that were
+    // injected into the html document during ssr/prerender
+    const payload = await createFromReadableStream(rscStream);
     const payloadSetter = {
         current: () => { },
     };
@@ -28,7 +28,7 @@ export async function browser() {
         // make the latest payload updater available to action/hmr callbacks
         // immediately during render, without waiting for an effect to run
         payloadSetter.current = setPayloadInTransition;
-        return (_jsx(RedirectBoundary, { children: _jsxs(RouterProvider, { setPayload: setPayloadInTransition, isNavigating: isPending, url: p.url, children: [
+        return (_jsx(RedirectBoundary, { children: _jsxs(BrowserRouterProvider, { setPayload: setPayloadInTransition, isNavigating: isPending, url: p.url, children: [
                     _jsx(ErrorBoundary, { fallback: null, children: _jsx(Suspense, { fallback: null, children: _jsx(Head, { metadata: p.metadata }) }) }), p.root] }) }));
     }
     setServerCallback(async (id, args) => {