@jk2908/solas 0.12.0 → 0.13.2

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 0.13.2
+
+### Changed
+
+- The Node adapter's response-stream loop and close handlers use declarations and `while (true)` for readability. No behaviour change.
+
+## 0.13.1
+
+### Fixes
+
+- The Node adapter now aborts `request.signal` when the client disconnects, so streaming endpoints such as SSE can stop their producers.
+- The Node adapter flushes response headers before streaming the body, so a delayed first chunk no longer leaves the client waiting with no response.
+- The Node adapter cancels the response stream when the client disconnects, instead of continuing to write into a dead socket.
+
+## 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

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`.
@@ -540,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({

package/dist/adapters/node.js

@@ -1,4 +1,3 @@
-import { once } from 'node:events';
 import http from 'node:http';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -38,26 +37,59 @@ function nodeToWeb(req) {
  */
 async function webToNode(stream, res) {
     const reader = stream.getReader();
+    let closed = false;
+    // a client that goes away leaves nothing to write to; cancel the source so
+    // its producer stops instead of buffering into a dead socket
+    function onClose() {
+        closed = true;
+        void reader.cancel().catch(() => { });
+    }
+    res.once('close', onClose);
     try {
         while (true) {
+            if (closed)
+                break;
             const { done, value } = await reader.read();
             if (done)
                 break;
-            // `write` returns false when the socket buffer is full. That is not an
-            // error: wait for the `'drain'` event before writing more, otherwise a
-            // fast producer and a slow client would buffer the whole body in memory
-            if (!res.write(value))
-                await once(res, 'drain');
+            if (closed || res.destroyed || res.writableEnded)
+                break;
+            try {
+                // `write` returns false when the socket buffer is full. That is not an
+                // error: wait for the `'drain'` event before writing more, otherwise a
+                // fast producer and a slow client would buffer the whole body in memory
+                if (!res.write(value)) {
+                    await new Promise(resolve => {
+                        function settle() {
+                            res.off('drain', settle);
+                            res.off('close', settle);
+                            resolve();
+                        }
+                        res.on('drain', settle);
+                        res.on('close', settle);
+                    });
+                }
+            }
+            catch {
+                // the socket died between the checks above
+                break;
+            }
         }
     }
     finally {
-        reader.releaseLock();
+        res.off('close', onClose);
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // a pending read can outlive a cancel by a tick
+        }
     }
 }
 /**
  * Convert a Node request into a fetch `Request`, streaming the body when present.
  */
-function toRequest(req) {
+function toRequest(req, signal) {
     const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
     const headers = new Headers();
     for (const [key, value] of Object.entries(req.headers)) {
@@ -77,6 +109,7 @@ function toRequest(req) {
         headers,
         body: hasBody ? nodeToWeb(req) : undefined,
         duplex: 'half',
+        signal,
     };
     return new Request(url, init);
 }
@@ -99,8 +132,12 @@ async function sendResponse(res, response) {
         res.end();
         return;
     }
+    // send headers now so a delayed first chunk (SSE, slow streams) does not
+    // leave the client waiting with no response
+    res.flushHeaders();
     await webToNode(response.body, res);
-    res.end();
+    if (!res.destroyed)
+        res.end();
 }
 /**
  * Start a production HTTP server for a Node (or Bun) deployment.
@@ -121,16 +158,31 @@ async function adapter(options = {}) {
     const host = options.host ?? '0.0.0.0';
     const handler = await loadHandler(entry);
     const server = http.createServer(async (req, res) => {
+        const abort = new AbortController();
+        // `close` before the response has finished means the client went away;
+        // surface that through `req.signal` so long-lived work can stop
+        function onClose() {
+            if (!res.writableEnded)
+                abort.abort(new Error('client disconnected'));
+        }
+        res.once('close', onClose);
         try {
-            const response = await handler.fetch(toRequest(req));
+            const response = await handler.fetch(toRequest(req, abort.signal));
             await sendResponse(res, response);
         }
         catch (err) {
             console.error('[solas] request failed', err);
+            if (res.headersSent) {
+                res.destroy();
+                return;
+            }
             res.statusCode = 500;
             res.setHeader('content-type', 'text/plain; charset=utf-8');
             res.end('Internal Server Error');
         }
+        finally {
+            res.off('close', onClose);
+        }
     });
     await new Promise(resolve => server.listen(port, host, resolve));
     options.onListen?.({ port, host });

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) {

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

@@ -47,6 +47,62 @@ function performNavigationFetch(path, init) {
         ? 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);
@@ -60,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;
@@ -81,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');
@@ -118,6 +178,7 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
                 history.current.replaceState(resolvedPath);
             }
             setPayload?.(payload);
+            applyScroll(scrollIntent, hash);
             window.dispatchEvent(new CustomEvent(Events.names.NAVIGATION, {
                 detail: { path: resolvedPath },
             }));
@@ -170,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);
@@ -189,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/package.json

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