@jk2908/solas 0.11.1 → 0.13.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.13.0
+
+### Features
+
+- Client navigation now scrolls to the top of a route on push, scrolls to a hash target when the URL has one, and restores the previous position on back and forward. `router.go(...)` and `Link` accept a `scroll` option (`'top'`, `'none'`, or `{ restore: y }`) to control this.
+
+### Fixes
+
+- Endpoint handlers with default or rest parameters now receive the request. Previously Solas passed it only when `Function.length` was non-zero.
+- Request handling no longer resolves the base path and trailing slash twice per request: the dispatch layer passes its already-normalised path to the router.
+
+### Changed
+
+- The route finder caches import paths, and the dev watcher ignores `dist`, so large route graphs and long dev sessions do less repeated work.
+
+## 0.12.0
+
+### Features
+
+- The static adapter supports client-side navigation. The build emits each fully prerendered route's RSC payload as `<route>.rsc.txt` next to its HTML, and the browser router fetches it, so a static host needs no server to answer navigations.
+- The active adapter's name is exposed as `import.meta.env.SOLAS_ADAPTER`, so apps can branch on the platform.
+
 ## 0.11.1
 
 ### Fixes

package/README.md

@@ -213,6 +213,18 @@ That keeps your route params aligned across links, imperative navigation, metada
 
 `router.refresh()` clears the cached RSC response for the current path and fetches a fresh payload, so it is most useful for routes that render request-time data. `router.isNavigating` exposes pending client-side navigation state.
 
+Navigation manages scroll for you: `Link` and `router.go(...)` scroll to the top of the new route, or to the target element when the URL has a hash. Back and forward restore the position each history entry was left at. Override this with the `scroll` option:
+
+```tsx
+await router.go('/search', { query: { q }, scroll: 'none' })
+
+<Link href="/results" scroll="none">
+	Keep position
+</Link>
+```
+
+`scroll` accepts `'top'` (the default), `'none'` to leave the position untouched, or `{ restore: y }` to restore a specific offset.
+
 ## Config
 
 All Solas options are passed to `solas()` inside `defineConfig`.
@@ -229,6 +241,8 @@ Solas resolves the origin in this order:
 
 The resolved origin is exposed to your app as `import.meta.env.VITE_APP_URL` and is used for build-time prerender requests and `sitemap` URLs. When `url` is set, it is also used as a trusted origin for CSRF.
 
+The active adapter's name is exposed as `import.meta.env.SOLAS_ADAPTER`, so your app can branch on the platform it is deployed to.
+
 You usually only need `url` in production, where the Vite dev server origin is meaningless. For example, to generate a `sitemap.xml` with real URLs:
 
 ```ts
@@ -538,7 +552,7 @@ Valid values are `debug`, `info`, `warn`, `error`, and `fatal`.
 - `error`: only errors
 - `fatal`: only fatal errors
 
-This is mainly useful when debugging framework behaviour such as routing and prerendering. It is for Solas internals, not your app's general-purpose logging, and it does not control top-level CLI status output such as build and preview progress messages.
+This is mainly useful when debugging framework behaviour such as routing and prerendering. It is for Solas internals, not your app's general-purpose logging, and it does not control top-level build and preview status output.
 
 ```ts
 export default defineConfig({
@@ -707,7 +721,9 @@ export default defineConfig({
 })
 ```
 
-`vite build` writes the site to `build/` (override with `outDir`): the client assets, each route as `<route>.html` (or `<route>/index.html` under `trailingSlash: 'always'`), plus `sitemap.xml` and `robots.txt`. Serve that directory with anything — `npx serve build`, GitHub Pages, Netlify, an S3 bucket, nginx.
+`vite build` writes the site to `build/` (override with `outDir`): the client assets, each route as `<route>.html` (or `<route>/index.html` under `trailingSlash: 'always'`), its RSC payload as `<route>.rsc.txt`, plus `sitemap.xml` and `robots.txt`. Serve that directory with anything — `npx serve build`, GitHub Pages, Netlify, an S3 bucket, nginx.
+
+Client-side navigation works with no server: the browser router fetches each route's `<route>.rsc.txt` payload instead of asking a server for `text/x-component`.
 
 Because it forces full prerendering, routes that need a server are not a fit: per-route PPR or SSR opt-ins and dynamic routes without `params()`.
 

package/dist/index.js

@@ -249,6 +249,20 @@ function solas(c) {
             viteConfig.publicDir ??= Config.PUBLIC_DIR;
             viteConfig.server ??= {};
             viteConfig.server.port ??= 8787;
+            // build output can be large and is rewritten during a session; keep it
+            // out of the watcher so route-change filtering does not process it.
+            // `.solas` stays watched on purpose: Vite needs those generated-file
+            // events to reload the route graph during dev
+            viteConfig.server.watch ??= {};
+            const watchIgnored = viteConfig.server.watch.ignored;
+            viteConfig.server.watch.ignored = [
+                ...(Array.isArray(watchIgnored)
+                    ? watchIgnored
+                    : watchIgnored
+                        ? [watchIgnored]
+                        : []),
+                `**/${Config.OUT_DIR}/**`,
+            ];
             // derive the public url from vite's dev server settings when no
             // origin was set explicitly via the url option or VITE_APP_URL
             if (resolvedUrl === undefined) {
@@ -261,6 +275,7 @@ function solas(c) {
             viteConfig.define ??= {};
             viteConfig.define['import.meta.env.VITE_APP_URL'] = JSON.stringify(resolvedUrl);
             viteConfig.define['import.meta.env.SOLAS_VERSION'] = JSON.stringify(pkg.version);
+            viteConfig.define['import.meta.env.SOLAS_ADAPTER'] = JSON.stringify(config.adapter?.name ?? '');
             viteConfig.optimizeDeps ??= {};
             viteConfig.optimizeDeps.exclude = [
                 ...new Set([
@@ -335,6 +350,7 @@ function solas(c) {
                 precompress: config.precompress,
                 trailingSlash: config.trailingSlash,
                 url: resolvedUrl,
+                adapter: config.adapter?.name ?? '',
             }));
         },
         buildApp: {

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

@@ -28,13 +28,17 @@ export declare class BrowserRouterHistory {
      */
     get current(): BrowserRouter.HistoryEntry;
     /**
-     * Pushes a new history entry and advances the index.
+     * Push a new history entry and advances the index.
      */
     pushState(path: string): BrowserRouter.HistoryEntry;
     /**
      * Replaces the current history entry without changing length.
      */
     replaceState(path: string): BrowserRouter.HistoryEntry;
+    /**
+     * Store the current window scroll position on the active entry.
+     */
+    saveScroll(): void;
     /**
      * Applies relative history movement and updates local index.
      */

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

@@ -11,6 +11,7 @@ export class BrowserRouterHistory {
             pathname: url.pathname,
             search: url.search ?? '',
             hash: url.hash ?? '',
+            scrollY: 0,
         };
         this.#entries = [entry];
         this.#index = 0;
@@ -40,9 +41,12 @@ export class BrowserRouterHistory {
         return this.#entries[this.#index] ?? null;
     }
     /**
-     * Pushes a new history entry and advances the index.
+     * Push a new history entry and advances the index.
      */
     pushState(path) {
+        // remember where the user was before leaving the current entry so a
+        // later back navigation can restore it
+        this.saveScroll();
         if (this.#index < this.#entries.length - 1) {
             // drop forward entries when pushing from the middle
             this.#entries = this.#entries.slice(0, this.#index + 1);
@@ -52,6 +56,7 @@ export class BrowserRouterHistory {
             pathname: window.location.pathname,
             search: window.location.search,
             hash: window.location.hash,
+            scrollY: 0,
         };
         this.#entries.push(entry);
         this.#index++;
@@ -66,6 +71,8 @@ export class BrowserRouterHistory {
             pathname: window.location.pathname,
             search: window.location.search,
             hash: window.location.hash,
+            // replacing the url does not move the page, so keep the position
+            scrollY: this.#entries[this.#index]?.scrollY ?? 0,
         };
         if (this.#entries.length === 0) {
             this.#entries = [entry];
@@ -75,6 +82,15 @@ export class BrowserRouterHistory {
         this.#entries[this.#index] = entry;
         return entry;
     }
+    /**
+     * Store the current window scroll position on the active entry.
+     */
+    saveScroll() {
+        const current = this.#entries[this.#index];
+        if (!current)
+            return;
+        current.scrollY = window.scrollY;
+    }
     /**
      * Applies relative history movement and updates local index.
      */
@@ -82,6 +98,8 @@ export class BrowserRouterHistory {
         if (!Number.isInteger(delta) || delta === 0) {
             return this.current;
         }
+        // capture the outgoing position before the browser moves
+        this.saveScroll();
         const nextIndex = Math.max(0, Math.min(this.#index + delta, this.#entries.length - 1));
         if (nextIndex !== this.#index)
             this.#index = nextIndex;
@@ -96,31 +114,30 @@ export class BrowserRouterHistory {
             pathname: window.location.pathname,
             search: window.location.search,
             hash: window.location.hash,
+            // unknown entries start at the top
+            scrollY: 0,
         };
         const prev = this.#entries[this.#index - 1];
         const next = this.#entries[this.#index + 1];
-        if (prev &&
-            prev.pathname === current.pathname &&
-            prev.search === current.search &&
-            prev.hash === current.hash) {
+        if (prev && matches(prev, current)) {
             this.#index--;
+            // restore the position this entry had when it was left
+            current.scrollY = prev.scrollY;
             this.#entries[this.#index] = current;
             return current;
         }
-        if (next &&
-            next.pathname === current.pathname &&
-            next.search === current.search &&
-            next.hash === current.hash) {
+        if (next && matches(next, current)) {
             this.#index++;
+            current.scrollY = next.scrollY;
             this.#entries[this.#index] = current;
             return current;
         }
         // fallback: locate an existing matching entry
-        const index = this.#entries.findIndex(entry => entry.pathname === current.pathname &&
-            entry.search === current.search &&
-            entry.hash === current.hash);
+        const index = this.#entries.findIndex(entry => matches(entry, current));
         if (index >= 0) {
+            const entry = this.#entries[index];
             this.#index = index;
+            current.scrollY = entry?.scrollY ?? 0;
             this.#entries[index] = current;
             return current;
         }
@@ -129,3 +146,9 @@ export class BrowserRouterHistory {
         return current;
     }
 }
+/**
+ * Whether two history entries point at the same location.
+ */
+function matches(a, b) {
+    return a.pathname === b.pathname && a.search === b.search && a.hash === b.hash;
+}

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

@@ -13,7 +13,7 @@ function guard(path, prefetcher) {
         return;
     prefetcher(path);
 }
-export function Link({ children, href, params, prefetch = 'none', query, ...rest }) {
+export function Link({ children, href, params, prefetch = 'none', query, scroll, ...rest }) {
     const { go, prefetch: prefetcher } = useRouter();
     const timer = useRef(null);
     // track whether the link is meant to be handled by the router, to avoid
@@ -46,7 +46,7 @@ export function Link({ children, href, params, prefetch = 'none', query, ...rest
             if (handled.current)
                 return;
             e.preventDefault();
-            go(href, { params, query });
+            go(href, { params, query, scroll });
         }, onFocus: e => {
             rest.onFocus?.(e);
             if (e.defaultPrevented)

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

@@ -28,6 +28,81 @@ const DEFAULT_GO_CONFIG = {
 };
 const logger = new Logger();
 const responseCache = new ResponseCache();
+const STATIC = import.meta.env.SOLAS_ADAPTER === 'static';
+/**
+ * The URL to fetch the response for a navigation. On a static host that is the
+ * pre-generated RSC payload; otherwise the path itself carries the RSC response
+ * for an `Accept: text/x-component` request.
+ */
+function getPayloadUrl(path) {
+    const url = new URL(path, window.location.origin);
+    url.pathname = url.pathname.endsWith('/')
+        ? `${url.pathname}index.rsc.txt`
+        : `${url.pathname}.rsc.txt`;
+    url.search = '';
+    return url;
+}
+function performNavigationFetch(path, init) {
+    return STATIC
+        ? fetch(getPayloadUrl(path), init)
+        : fetch(path, { ...init, headers: { ...init?.headers, accept: 'text/x-component' } });
+}
+const MAX_HASH_ATTEMPTS = 20;
+function nextFrame(callback) {
+    if (typeof requestAnimationFrame === 'function') {
+        requestAnimationFrame(callback);
+        return;
+    }
+    setTimeout(callback, 0);
+}
+/**
+ * Scroll to the element a hash points at, retrying for a few frames because the
+ * incoming tree may still be committing when the navigation resolves.
+ */
+function scrollToHash(hash, attempts = MAX_HASH_ATTEMPTS) {
+    let id;
+    try {
+        id = decodeURIComponent(hash.replace(/^#/, ''));
+    }
+    catch {
+        id = hash.replace(/^#/, '');
+    }
+    if (!id) {
+        window.scrollTo(0, 0);
+        return;
+    }
+    const element = document.getElementById(id) ?? document.getElementsByName(id)[0] ?? null;
+    if (element) {
+        element.scrollIntoView();
+        return;
+    }
+    if (attempts <= 0)
+        return;
+    nextFrame(() => scrollToHash(hash, attempts - 1));
+}
+/**
+ * Apply the scroll position for a completed navigation. Push navigations go to
+ * the top (or the target hash), back/forward restore the saved position, and
+ * refreshes leave the page where it is.
+ */
+function applyScroll(intent, hash) {
+    if (typeof window === 'undefined')
+        return;
+    if (intent === 'none')
+        return;
+    if (typeof window.scrollTo !== 'function')
+        return;
+    if (typeof intent === 'object') {
+        // wait for the restored tree to commit so it has its full height
+        nextFrame(() => nextFrame(() => window.scrollTo(0, intent.restore)));
+        return;
+    }
+    if (hash) {
+        scrollToHash(hash);
+        return;
+    }
+    window.scrollTo(0, 0);
+}
 export function BrowserRouterProvider({ children, setPayload, isNavigating = false, url, }) {
     const id = useRef(0);
     const controller = useRef(null);
@@ -41,6 +116,9 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
      * @returns The final path navigated to after any redirects, or the original path if navigation failed.
      */
     const go = useCallback(async (to, opts = {}) => {
+        // capture before the first await so a mutated options object cannot
+        // change how this navigation scrolls
+        const scrollIntent = opts.scroll ?? 'top';
         id.current += 1;
         const navigationId = id.current;
         const currentPath = window.location.pathname + window.location.search;
@@ -62,6 +140,7 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
                 throw new Error('[router.go]: external URLs are not supported. Use <a> instead');
             }
             const url = new URL(target, window.location.origin);
+            const hash = url.hash;
             const key = ResponseCache.toCacheKey(url.toString(), window.location.origin);
             if (!key)
                 throw new Error('Invalid navigation url');
@@ -79,10 +158,7 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
             if (!promise) {
                 const ctrl = new AbortController();
                 controller.current = ctrl;
-                promise = fetch(path, {
-                    headers: { accept: 'text/x-component' },
-                    signal: ctrl.signal,
-                });
+                promise = performNavigationFetch(path, { signal: ctrl.signal });
                 responseCache.set(path, promise);
             }
             if (navigationId !== id.current)
@@ -91,13 +167,18 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
                 promise,
                 createFromFetch(promise),
             ]);
-            const resolvedPath = ResponseCache.toCacheKey(res.url, window.location.origin) ?? path;
+            // on a static host the payload comes from `<path>.rsc.txt`, so the
+            // response URL is not the page path
+            const resolvedPath = STATIC
+                ? path
+                : (ResponseCache.toCacheKey(res.url, window.location.origin) ?? path);
             if (navigationId !== id.current)
                 return resolvedPath;
             if (resolvedPath !== path) {
                 history.current.replaceState(resolvedPath);
             }
             setPayload?.(payload);
+            applyScroll(scrollIntent, hash);
             window.dispatchEvent(new CustomEvent(Events.names.NAVIGATION, {
                 detail: { path: resolvedPath },
             }));
@@ -136,7 +217,7 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
             return;
         if (responseCache.has(key))
             return;
-        responseCache.set(key, fetch(key, { headers: { Accept: 'text/x-component' } }));
+        responseCache.set(key, performNavigationFetch(key));
     }, []);
     /**
      * Refreshes the current page by re-fetching the RSC response for the current path and updating the
@@ -150,16 +231,17 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
             return Promise.resolve(currentPath);
         if (responseCache.has(key))
             responseCache.remove(key);
-        return go(currentPath, {
-            replace: true,
-        });
+        // a refresh stays exactly where the user is
+        return go(currentPath, { replace: true, scroll: 'none' });
     }, [go]);
     useEffect(() => {
         const h = history.current;
         function handler() {
-            h.onPopState();
+            const entry = h.onPopState();
+            // back/forward restores the position the entry was left at
             void go(BrowserRouter.toTarget(window.location.pathname + window.location.search), {
                 replace: true,
+                scroll: { restore: entry?.scrollY ?? 0 },
             });
         }
         window.addEventListener('popstate', handler);
@@ -169,6 +251,31 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
             window.removeEventListener('popstate', handler);
         };
     }, [go]);
+    // take over scroll restoration so back/forward can restore saved positions
+    useEffect(() => {
+        // remember the browser's own setting so an unmount can hand it back
+        const previous = 'scrollRestoration' in window.history ? window.history.scrollRestoration : undefined;
+        if (previous !== undefined) {
+            window.history.scrollRestoration = 'manual';
+        }
+        let pending = false;
+        function onScroll() {
+            if (pending)
+                return;
+            pending = true;
+            nextFrame(() => {
+                pending = false;
+                history.current.saveScroll();
+            });
+        }
+        window.addEventListener('scroll', onScroll, { passive: true });
+        return () => {
+            window.removeEventListener('scroll', onScroll);
+            if (previous !== undefined) {
+                window.history.scrollRestoration = previous;
+            }
+        };
+    }, []);
     const value = useMemo(() => ({
         go,
         prefetch,

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

@@ -5,10 +5,25 @@ export type Path = keyof Solas.Routes & string;
 type Replace = {
     replace?: boolean;
 };
+/**
+ * Where to position the page after a navigation.
+ *
+ * - `'top'`: scroll to the target hash when the URL has one, otherwise the top.
+ * - `'none'`: leave the scroll position untouched.
+ * - `{ restore: number }`: restore a specific offset. Used by the router for
+ *   back and forward.
+ */
+export type ScrollIntent = 'top' | 'none' | {
+    restore: number;
+};
 export type GoOptions = {
     replace?: boolean;
     query?: Query;
     params?: Params;
+    /**
+     * Where to position the page after navigating. Defaults to `'top'`.
+     */
+    scroll?: ScrollIntent;
 };
 export type Context = {
     go: Go;
@@ -29,6 +44,7 @@ export type HistoryEntry = {
     pathname: string;
     search: string;
     hash: string;
+    scrollY: number;
 };
 /**
  * These targets are used as-is. They are not matched against the route table,
@@ -97,6 +113,7 @@ export type Target = ExternalTarget | TargetSuffix<ResolvedPath<Path>>;
 type TargetConfig = {
     params?: never;
     query?: Query;
+    scroll?: ScrollIntent;
 };
 /**
  * Extra options for callers who pass a route pattern and params separately.
@@ -119,6 +136,7 @@ type TargetConfig = {
  */
 type PatternConfig<TPath extends Path> = {
     query?: Query;
+    scroll?: ScrollIntent;
 } & (Solas.Routes[TPath] extends {
     params: infer TParams extends Params;
 } ? {

package/dist/internal/build.js

@@ -104,6 +104,7 @@ function buildSegment(dir, page, chains) {
 export class Finder {
     buildContext;
     config;
+    static #importPaths = new Map();
     constructor(buildContext, config) {
         this.buildContext = buildContext;
         this.config = config;
@@ -143,11 +144,19 @@ export class Finder {
      */
     static getImportPath(file) {
         const cwd = process.cwd();
+        const key = `${cwd}\0${file}`;
+        const cached = Finder.#importPaths.get(key);
+        if (cached !== undefined)
+            return cached;
         const generatedDir = path.join(cwd, Config.GENERATED_DIR);
-        return path
+        const result = path
             .relative(generatedDir, path.resolve(cwd, file))
             .replace(/\\/g, '/')
             .replace(/\.(t|j)sx?$/, '');
+        // shared shells, layouts and boundaries are resolved once per segment, so
+        // cache the result for the rest of the build
+        Finder.#importPaths.set(key, result);
+        return result;
     }
     /**
      * Entry point: scan the app directory then process the result

package/dist/internal/env/rsc.js

@@ -6,7 +6,7 @@ import * as Config from '../../config.js';
 import * as RuntimeManifest from '../../manifest.js';
 import { createHttpRouter } from '../http-router/create-http-router.js';
 import { HttpRouter } from '../http-router/router.js';
-import { isRscRequest, normaliseTrailingSlash } from '../http-router/utils.js';
+import { isRscRequest, normaliseTrailingSlash, resolveRequestPath, } from '../http-router/utils.js';
 import { Metadata } from '../metadata.js';
 import { HttpException, isHttpException, toHttpException, toHttpExceptionLike, } from '../navigation/http-exception.js';
 import { isRedirect, toRedirect } from '../navigation/redirect.js';
@@ -230,8 +230,8 @@ export function createHandler(config, manifest, importMap, options = {}) {
                 req[Config.REQUEST_META_KEY].error = undefined;
             }
         }
-        // prerender artifact requests bypass the normal document path so the cli
-        // gets structured JSON instead of a rendered html response
+        // prerender artifact requests bypass the normal document path so the
+        // prerenderer gets structured JSON instead of a rendered html response
         if (req.headers.get(`x-${Config.SLUG}-prerender`) === '1' &&
             req.headers.get(`x-${Config.SLUG}-prerender-artifact`) === '1') {
             try {
@@ -391,16 +391,9 @@ export function createHandler(config, manifest, importMap, options = {}) {
         // fast path
         if (method !== 'GET' && method !== 'HEAD')
             return httpRouter.fetch(req);
-        const routedPath = stripBasePath(url.pathname, BASE_PATH);
-        const canonicalPath = routedPath == null
-            ? null
-            : config.trailingSlash === 'ignore'
-                ? routedPath
-                : normaliseTrailingSlash(routedPath, config.trailingSlash);
-        const canonicalPathname = canonicalPath == null ? null : applyBasePath(canonicalPath, BASE_PATH);
+        const { routedPath, path: canonicalPath, pathname: canonicalPathname, } = resolveRequestPath(url.pathname, BASE_PATH, config.trailingSlash);
         if (canonicalPathname != null &&
             (method === 'GET' || method === 'HEAD') &&
-            config.trailingSlash !== 'ignore' &&
             canonicalPathname !== url.pathname) {
             url.pathname = canonicalPathname;
             return Response.redirect(url.toString(), 308);
@@ -426,7 +419,10 @@ export function createHandler(config, manifest, importMap, options = {}) {
                 return asset;
             return HttpRouter.serveStatic(assets, asset, req, config.precompress);
         }
-        return httpRouter.fetch(req);
+        // the path is already canonical here: a mismatched shape redirected above,
+        // so hand the resolved path to the router rather than letting it recompute
+        // the base path and trailing slash a second time
+        return httpRouter.fetch(req, canonicalPath);
     }
     // vite-plugin-rsc entrypoint
     return {

package/dist/internal/http-router/create-http-router.js

@@ -1,9 +1,9 @@
 import { HttpRouter } from './router.js';
 import { isRscRequest } from './utils.js';
 function callEndpoint(fn, req) {
-    // endpoint modules may export either a zero-arg handler or one that expects the request
-    if (fn.length === 0)
-        return fn();
+    // always pass the request; handlers that do not need it simply ignore the
+    // argument. relying on `fn.length` silently dropped the request for
+    // default/rest parameters and compiled handlers
     return fn(req);
 }
 function createHandlerGroups(manifest) {

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

@@ -62,7 +62,7 @@ export declare class HttpRouter {
     /**
      * Handle an incoming request.
      */
-    fetch(req: Request): Promise<Response>;
+    fetch(req: Request, resolvedPath?: string | null): Promise<Response>;
     /**
      * Serve a file with optional compression content negotiation.
      */

package/dist/internal/http-router/router.js

@@ -1,10 +1,10 @@
 import { match as createMatch } from 'path-to-regexp';
-import { applyBasePath, normaliseBasePath, stripBasePath } from '../../utils/base-path.js';
+import { normaliseBasePath } from '../../utils/base-path.js';
 import * as Config from '../../config.js';
 import { HttpException } from '../navigation/http-exception.js';
 import { maybeAction } from '../server/actions.js';
 import { enforce } from '../server/csrf.js';
-import { getAlternatePathname, normaliseTrailingSlash, toPathPattern } from './utils.js';
+import { getAlternatePathname, normaliseTrailingSlash, resolveRequestPath, toPathPattern, } from './utils.js';
 const BASE_PATH = normaliseBasePath(import.meta.env.BASE_URL);
 /**
  * Handle routing and matching for server requests.
@@ -162,20 +162,18 @@ export class HttpRouter {
     /**
      * Handle an incoming request.
      */
-    async fetch(req) {
-        const url = new URL(req.url);
-        const trailingSlash = this.opts.trailingSlash ?? 'never';
-        const routedPath = stripBasePath(url.pathname, BASE_PATH);
-        const path = routedPath == null
-            ? null
-            : trailingSlash === 'ignore'
-                ? routedPath
-                : normaliseTrailingSlash(routedPath, trailingSlash);
-        let match = null;
-        let action = false;
-        try {
+    async fetch(req, resolvedPath) {
+        // callers that have already applied the base-path and trailing-slash
+        // policy (the RSC dispatch layer) pass the resolved path in, so the
+        // request does not pay for that normalisation twice
+        let path = resolvedPath;
+        if (path === undefined) {
+            const url = new URL(req.url);
+            const trailingSlash = this.opts.trailingSlash ?? 'never';
+            const resolved = resolveRequestPath(url.pathname, BASE_PATH, trailingSlash);
+            path = resolved.path;
             const method = req.method.toUpperCase();
-            const canonicalPathname = path == null ? null : applyBasePath(path, BASE_PATH);
+            const canonicalPathname = resolved.pathname;
             if (canonicalPathname != null &&
                 (method === 'GET' || method === 'HEAD') &&
                 canonicalPathname !== url.pathname) {
@@ -187,6 +185,11 @@ export class HttpRouter {
                 url.pathname = canonicalPathname;
                 req = new Request(url.toString(), req);
             }
+        }
+        let match = null;
+        let action = false;
+        try {
+            const method = req.method.toUpperCase();
             const { action: isAction, formData: parsedFormData } = await maybeAction(req);
             action = isAction;
             // action requests stay on the same path, but we match them like GET so
@@ -265,7 +268,10 @@ export class HttpRouter {
                 }
             }
         }
-        if (!(await assets.exists(resolved))) {
+        // a precompressed variant is only emitted for an asset that existed, so a
+        // brotli hit above already proves the file is there. skipping the second
+        // lookup saves a round trip on stores where `exists` is a remote call
+        if (encoding === null && !(await assets.exists(resolved))) {
             return new Response('Not found', { status: 404 });
         }
         // get mime type from original path, not compressed variant

package/dist/internal/http-router/utils.d.ts

@@ -11,6 +11,20 @@ export type PathPattern = {
     path: string;
     wildcardNames: Set<string>;
 };
+/**
+ * Resolve an incoming request pathname against the base path and trailing-slash
+ * policy. Both the dispatch layer and the router use this so the two never
+ * disagree about what a canonical path looks like.
+ *
+ * `routedPath` is the raw app-relative path, `path` is what the router matches,
+ * and `pathname` is the canonical URL pathname including the base path, so the
+ * caller can tell whether a redirect is needed.
+ */
+export declare function resolveRequestPath(pathname: string, base: string | null | undefined, trailingSlash?: PluginConfig['trailingSlash']): {
+    routedPath: string | null;
+    path: string | null;
+    pathname: string | null;
+};
 /**
  * Convert an internal route string into a path-to-regexp pattern and collect
  * the wildcard param names used in that pattern.

package/dist/internal/http-router/utils.js

@@ -1,3 +1,4 @@
+import { applyBasePath, stripBasePath } from '../../utils/base-path.js';
 /**
  * Whether a request wants the RSC payload rather than a document.
  *
@@ -9,6 +10,28 @@ export function isRscRequest(req) {
     const accept = req.headers.get('accept') ?? '';
     return accept.includes('text/x-component') && !accept.includes('text/html');
 }
+/**
+ * Resolve an incoming request pathname against the base path and trailing-slash
+ * policy. Both the dispatch layer and the router use this so the two never
+ * disagree about what a canonical path looks like.
+ *
+ * `routedPath` is the raw app-relative path, `path` is what the router matches,
+ * and `pathname` is the canonical URL pathname including the base path, so the
+ * caller can tell whether a redirect is needed.
+ */
+export function resolveRequestPath(pathname, base, trailingSlash = 'never') {
+    const routedPath = stripBasePath(pathname, base);
+    const path = routedPath == null
+        ? null
+        : trailingSlash === 'ignore'
+            ? routedPath
+            : normaliseTrailingSlash(routedPath, trailingSlash);
+    return {
+        routedPath,
+        path,
+        pathname: path == null ? null : applyBasePath(path, base),
+    };
+}
 /**
  * Escape a literal path segment so it can be used safely in a
  * path-to-regexp pattern.

package/dist/internal/postbuild.js

@@ -114,6 +114,14 @@ export async function postbuild(cwd = process.cwd()) {
                     const staticPath = path.join(staticRoot, Prerender.staticRoutePath(route, staticMode));
                     await fs.mkdir(path.dirname(staticPath), { recursive: true });
                     await fs.writeFile(staticPath, artifact.html);
+                    // a static host has no server to answer an RSC navigation, so emit
+                    // the payload next to the HTML for the client router to fetch
+                    if (manifest.adapter === 'static') {
+                        await fs.writeFile(staticPath.replace(/\.html$/, '.rsc.txt'), await Prerender.getRscPayload(app, route, {
+                            origin: manifest.url,
+                            base: manifest.base,
+                        }));
+                    }
                     artfifactManifest[route] = {
                         mode: artifact.mode,
                         files: ['html'],

package/dist/internal/prerender.d.ts

@@ -122,6 +122,17 @@ export declare function get(app: {
     route: string;
     artifact: any;
 }>;
+/**
+ * Fetch the RSC payload for a route, the response a client would get for an RSC
+ * navigation. Written alongside a fully prerendered route's HTML so a static
+ * host can serve client-side navigation without a server.
+ */
+export declare function getRscPayload(app: {
+    fetch: (req: Request) => Promise<Response>;
+}, route: string, opts: {
+    origin?: string;
+    base?: string;
+}): Promise<string>;
 /**
  * Run the prerendering process for a list of routes with a specified concurrency limit,
  * by calling the 'get' function for each route and yielding the results as they become available.

package/dist/internal/prerender.js

@@ -331,6 +331,19 @@ export async function get(app, route, opts) {
         return { route, status: res.status };
     return { route, artifact: await res.json() };
 }
+/**
+ * Fetch the RSC payload for a route, the response a client would get for an RSC
+ * navigation. Written alongside a fully prerendered route's HTML so a static
+ * host can serve client-side navigation without a server.
+ */
+export async function getRscPayload(app, route, opts) {
+    const url = `${opts.origin ?? `http://${Config.SLUG}.local`}${applyBasePath(route, opts.base)}`;
+    const res = await app.fetch(new Request(url, { headers: { Accept: 'text/x-component' } }));
+    if (!(res instanceof Response) || !res.ok) {
+        throw new Error(`[prerender] RSC payload for ${route} was not served`);
+    }
+    return res.text();
+}
 /**
  * Run the prerendering process for a list of routes with a specified concurrency limit,
  * by calling the 'get' function for each route and yielding the results as they become available.

package/dist/types.d.ts

@@ -130,6 +130,7 @@ export type BuildManifest = {
     precompress: boolean;
     trailingSlash: (typeof Config.TRAILING_SLASH_MODES)[number];
     url?: string;
+    adapter?: string;
 };
 export declare namespace Route {
     type ParamsOf<TRoute> = TRoute extends {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jk2908/solas",
-	"version": "0.11.1",
+	"version": "0.13.0",
 	"description": "A Vite + React meta-framework exploring streaming, Server Components, and partial prerendering. Designed for simplicity and lightness",
 	"keywords": [
 		"framework",