@jk2908/solas 0.3.1 → 0.3.2

package/dist/internal/env/rsc.d.ts

@@ -2,7 +2,7 @@ import type { ReactFormState } from 'react-dom/client';
 import type { ImportMap, Manifest, RuntimeConfig } from '../../types.js';
 import { Metadata } from '../metadata.js';
 import { Prerender } from '../prerender.js';
-export type RSCPayload = {
+export type RscPayload = {
     returnValue?: {
         ok: boolean;
         data: unknown;

package/dist/internal/env/rsc.js

@@ -2,24 +2,24 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 import { renderToReadableStream } from '@vitejs/plugin-rsc/rsc';
 import { Logger } from '../../utils/logger.js';
 import { Solas } from '../../solas.js';
+import { createHttpRouter } from '../http-router/create-http-router.js';
+import { HttpRouter } from '../http-router/router.js';
+import { normalisePathname } from '../http-router/utils.js';
 import { Metadata } from '../metadata.js';
 import { HttpException, isHttpException } from '../navigation/http-exception.js';
 import { Prerender } from '../prerender.js';
 import { Tree } from '../render/tree.js';
-import { createRouter } from '../router/create-router.js';
-import { Resolver } from '../router/resolver.js';
-import { Router } from '../router/router.js';
-import { normalisePathname } from '../router/utils.js';
+import { Resolver } from '../resolver.js';
 import { processActionRequest } from '../server/actions.js';
 import DefaultErr from '../ui/defaults/error.js';
 import { RequestContext } from './request-context.js';
 import { getKnownDigest, isKnownError } from './utils.js';
 /**
- * Get the streamed RSC payload and response metadata for a single request.
+ * Create the streamed RSC payload and response metadata for a single request.
  * Resolves the route match, collects metadata, and returns the stream,
  * status code, and prerender mode needed by the response layer
  */
-async function getPayload(req, manifest, importMap, baseMetadata, returnValue, formState, temporaryReferences) {
+async function createPayload(req, manifest, importMap, baseMetadata, returnValue, formState, temporaryReferences) {
     const resolver = new Resolver(manifest, importMap);
     const logger = new Logger();
     const prerender = req.headers.get(`x-${Solas.Config.SLUG}-prerender`) === '1';
@@ -27,12 +27,12 @@ async function getPayload(req, manifest, importMap, baseMetadata, returnValue, f
     const pathname = url.pathname.endsWith('/') && url.pathname !== '/'
         ? url.pathname.slice(0, -1)
         : url.pathname;
-    const match = resolver.enhance(resolver.reconcile(pathname, req[Solas.Config.REQUEST_META].match, req[Solas.Config.REQUEST_META].error));
+    const match = resolver.enhance(resolver.reconcile(pathname, req[Solas.Config.REQUEST_META_KEY].match, req[Solas.Config.REQUEST_META_KEY].error));
     // if there's no match then no user supplied error boundary
     // has been found, and we should server render a default
     // error screen
     if (!match) {
-        const error = req[Solas.Config.REQUEST_META].error ?? new HttpException(404, 'Not found');
+        const error = req[Solas.Config.REQUEST_META_KEY].error ?? new HttpException(404, 'Not found');
         const title = `${'status' in error ? `${error.status} -` : ''}${error.message}`;
         const rscPayload = {
             root: (_jsxs("html", { lang: "en", children: [
@@ -174,9 +174,9 @@ export function createHandler(config, manifest, importMap, artifactManifest = nu
             temporaryReferences: undefined,
             returnValue: undefined,
         };
-        if (req[Solas.Config.REQUEST_META].action)
+        if (req[Solas.Config.REQUEST_META_KEY].action)
             opts = await processActionRequest(req);
-        const { stream: rscStream, status, ppr, } = await getPayload(req, manifest, importMap, config.metadata, opts.returnValue, opts.formState, opts.temporaryReferences);
+        const { stream: rscStream, status, ppr, } = await createPayload(req, manifest, importMap, config.metadata, opts.returnValue, opts.formState, opts.temporaryReferences);
         const stream = await rscStream;
         if (!req.headers.get('accept')?.includes('text/html')) {
             return new Response(stream, {
@@ -211,27 +211,20 @@ export function createHandler(config, manifest, importMap, artifactManifest = nu
             });
         }
         const artifactManifestEntry = runtimePpr
-            ? (artifactManifest?.routes[lookupPath] ?? null)
+            ? (artifactManifest?.[lookupPath] ?? null)
             : null;
-        let tryPrelude = false;
-        if (artifactManifestEntry) {
-            tryPrelude = artifactManifestEntry.mode === 'ppr';
-        }
-        else if (runtimePpr) {
-            const artifactMetadata = await Prerender.Artifact.loadMetadata(Solas.Config.OUT_DIR, lookupPath);
-            tryPrelude =
-                !!artifactMetadata &&
-                    Prerender.Artifact.isCompatible(artifactMetadata, lookupPath, 'ppr');
-        }
+        const tryPrelude = artifactManifestEntry?.mode === 'ppr';
         if (tryPrelude) {
             const postponedState = await Prerender.Artifact.loadPostponedState(Solas.Config.OUT_DIR, lookupPath);
             const prelude = await Prerender.Artifact.loadPrelude(Solas.Config.OUT_DIR, lookupPath);
             // resumable ppr responses splice fresh streamed content into the cached
             // prelude when postponed state is available for this route
             if (postponedState) {
+                // the cached prelude already carries the static payload, only needs to
+                // stream the html completions for postponed boundaries
                 const resumeStream = await mod.resume(stream, postponedState, {
                     nonce: undefined,
-                    injectPayload: true,
+                    injectPayload: false,
                 });
                 const body = prelude
                     ? Prerender.Artifact.composePreludeAndResume(prelude, resumeStream)
@@ -259,7 +252,8 @@ export function createHandler(config, manifest, importMap, artifactManifest = nu
             status,
         });
     }
-    const router = createRouter(config, manifest, importMap, createResponse);
+    const httpRouter = createHttpRouter(config, manifest, importMap, createResponse);
+    // vite-plugin-rsc entrypoint
     return {
         async fetch(req) {
             const url = new URL(req.url);
@@ -280,13 +274,14 @@ export function createHandler(config, manifest, importMap, artifactManifest = nu
             if (!import.meta.env.DEV &&
                 accept.includes('text/html') &&
                 req.headers.get(`x-${Solas.Config.SLUG}-prerender-artifact`) !== '1') {
+                // turn the request path into the normal route shape we use for artifact lookups
                 const lookupPath = normalisePathname(canonicalPath, prerenderPathMode);
-                const fullPrerenderFilename = artifactManifest?.routes[lookupPath]?.fullPrerenderFilename;
-                const prerenderPath = fullPrerenderFilename
-                    ? Prerender.Artifact.getFilePath(Solas.Config.OUT_DIR, lookupPath, fullPrerenderFilename)
+                // only full prerender routes have a saved html file we can serve directly
+                const prerenderPath = artifactManifest?.[lookupPath]?.mode === 'full'
+                    ? Prerender.Artifact.getFilePath(Solas.Config.OUT_DIR, lookupPath, Prerender.Artifact.FULL_PRERENDER_FILENAME)
                     : null;
                 if (prerenderPath) {
-                    const res = await Router.serve(prerenderPath, req, config.precompress, {
+                    const res = await HttpRouter.serve(prerenderPath, req, config.precompress, {
                         // avoid shared or proxy caching unless users opt into public caching later
                         'Cache-Control': 'private, no-store',
                         'Content-Type': 'text/html; charset=utf-8',
@@ -295,7 +290,7 @@ export function createHandler(config, manifest, importMap, artifactManifest = nu
                         return res;
                 }
             }
-            return router.fetch(req);
+            return httpRouter.fetch(req);
         },
     };
 }

package/dist/internal/env/ssr.d.ts

@@ -8,7 +8,7 @@ type Opts = {
 /**
  * SSR handler - returns a ReadableStream response for HTML requests
  */
-declare function ssr(rscStream: ReadableStream<Uint8Array>, opts?: Opts): Promise<ReadableStream<any>>;
+declare function ssr(rscStream: ReadableStream<Uint8Array>, opts?: Opts): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
 /**
  * Build-time prerender artifact generation
  * @description for PPR routes this returns static prelude HTML + opaque postponed state
@@ -33,7 +33,7 @@ declare function prerender(rscStream: ReadableStream<Uint8Array>, opts?: Opts):
  */
 declare function resume(rscStream: ReadableStream<Uint8Array>, postponedState: unknown, opts?: Pick<Opts, 'nonce'> & {
     injectPayload?: boolean;
-}): Promise<ReadableStream<any>>;
+}): Promise<import("react-dom/server").ReactDOMServerReadableStream | ReadableStream<Uint8Array<ArrayBufferLike>>>;
 export type SSRModule = {
     prerender: typeof prerender;
     resume: typeof resume;

package/dist/internal/env/ssr.js

@@ -3,19 +3,19 @@ import { Suspense, use } from 'react';
 import { resume as reactResume, renderToReadableStream } from 'react-dom/server.edge';
 import { prerender as reactPrerender } from 'react-dom/static.edge';
 import { createFromReadableStream } from '@vitejs/plugin-rsc/ssr';
-import { injectRSCPayload } from 'rsc-html-stream/server';
 import { Logger } from '../../utils/logger.js';
 import { Solas } from '../../solas.js';
+import { BrowserRouterProvider } from '../browser-router/router.js';
 import { RedirectBoundary } from '../navigation/redirect-boundary.js';
 import { Prerender } from '../prerender.js';
 import { Head } from '../render/head.js';
-import { RouterProvider } from '../router/router-provider.js';
 import { ErrorBoundary } from '../ui/error-boundary.js';
-import { getKnownDigest } from './utils.js';
+import { captureBuffered, injectPayload } from './flight.js';
+import { getKnownDigest, isKnownError } from './utils.js';
 const logger = new Logger();
 function A({ payloadPromise }) {
     const payload = use(payloadPromise);
-    return (_jsx(RedirectBoundary, { children: _jsxs(RouterProvider, { url: payload.url, children: [
+    return (_jsx(RedirectBoundary, { children: _jsxs(BrowserRouterProvider, { url: payload.url, children: [
                 _jsx(ErrorBoundary, { fallback: null, children: _jsx(Suspense, { fallback: null, children: _jsx(Head, { metadata: payload.metadata }) }) }), payload.root] }) }));
 }
 /**
@@ -36,10 +36,12 @@ async function ssr(rscStream, opts = {}) {
                 const digest = getKnownDigest(err);
                 if (digest)
                     return digest;
+                if (isKnownError(err))
+                    return;
                 logger.error('[ssr:ppr]', err);
             },
         });
-        return prelude.pipeThrough(injectRSCPayload(s2, { nonce }));
+        return prelude.pipeThrough(injectPayload(s2, { nonce }));
     }
     const htmlStream = await renderToReadableStream(_jsx(A, { payloadPromise: payloadPromise }), {
         bootstrapScriptContent,
@@ -49,10 +51,12 @@ async function ssr(rscStream, opts = {}) {
             const digest = getKnownDigest(err);
             if (digest)
                 return digest;
+            if (isKnownError(err))
+                return;
             logger.error('[ssr]', err);
         },
     });
-    return htmlStream.pipeThrough(injectRSCPayload(s2, { nonce }));
+    return htmlStream.pipeThrough(injectPayload(s2, { nonce }));
 }
 /**
  * Build-time prerender artifact generation
@@ -85,6 +89,8 @@ async function prerender(rscStream, opts = {}) {
                 const digest = getKnownDigest(err);
                 if (digest)
                     return digest;
+                if (isKnownError(err))
+                    return;
                 logger.error('[ssr:prerender:ppr]', err);
             },
         });
@@ -96,15 +102,18 @@ async function prerender(rscStream, opts = {}) {
                 route,
                 createdAt: Date.now(),
                 mode: 'full',
-                html: await new Response(prelude.pipeThrough(injectRSCPayload(s2, { nonce }))).text(),
+                html: await new Response(prelude.pipeThrough(injectPayload(s2, { nonce }))).text(),
             };
         }
+        // save the static payload rows in the cached prelude and leave the
+        // postponed work for the later resume response
+        const partialPayload = await captureBuffered(s2);
         return {
             schema,
             route,
             createdAt: Date.now(),
             mode: 'ppr',
-            html: await new Response(prelude).text(),
+            html: await new Response(prelude.pipeThrough(injectPayload(partialPayload, { nonce }))).text(),
             postponed,
         };
     }
@@ -114,6 +123,8 @@ async function prerender(rscStream, opts = {}) {
             const digest = getKnownDigest(err);
             if (digest)
                 return digest;
+            if (isKnownError(err))
+                return;
             logger.error('[ssr:prerender:full]', err);
         },
     });
@@ -123,27 +134,30 @@ async function prerender(rscStream, opts = {}) {
         route,
         createdAt: Date.now(),
         mode: 'full',
-        html: await new Response(stream.pipeThrough(injectRSCPayload(s2, { nonce }))).text(),
+        html: await new Response(stream.pipeThrough(injectPayload(s2, { nonce }))).text(),
     };
 }
 /**
  * Request-time resume for PPR routes
  */
 async function resume(rscStream, postponedState, opts = {}) {
-    const { nonce, injectPayload = true } = opts;
     const [s1, s2] = rscStream.tee();
     const payloadPromise = createFromReadableStream(s1);
     const htmlStream = await reactResume(_jsx(A, { payloadPromise: payloadPromise }), postponedState, {
-        nonce,
+        nonce: opts.nonce,
         onError(err) {
             const digest = getKnownDigest(err);
             if (digest)
                 return digest;
+            if (isKnownError(err))
+                return;
             logger.error('[ssr:resume]', err);
         },
     });
-    if (!injectPayload)
+    // cached ppr preludes already embed the static payload, so resume usually
+    // only needs to send the html completion scripts
+    if (opts.injectPayload === false)
         return htmlStream;
-    return htmlStream.pipeThrough(injectRSCPayload(s2, { nonce }));
+    return htmlStream.pipeThrough(injectPayload(s2, { nonce: opts.nonce }));
 }
 export { prerender, resume, ssr };

package/dist/internal/env/utils.js

@@ -1,6 +1,10 @@
 import { HTTP_EXCEPTION_DIGEST_PREFIX } from '../navigation/http-exception.js';
 import { REDIRECT_DIGEST_PREFIX } from '../navigation/redirect.js';
 const possibilities = [HTTP_EXCEPTION_DIGEST_PREFIX, REDIRECT_DIGEST_PREFIX];
+const RENDER_ABORT_MESSAGE = 'The render was aborted by the server without a reason';
+function isRenderAbortMessage(value) {
+    return typeof value === 'string' && value.includes(RENDER_ABORT_MESSAGE);
+}
 export function getKnownDigest(err) {
     if (typeof err === 'object' &&
         err !== null &&
@@ -17,10 +21,18 @@ export function getKnownDigest(err) {
 export function isKnownError(err) {
     if (getKnownDigest(err))
         return true;
+    if (isRenderAbortMessage(err))
+        return true;
+    if (typeof err === 'object' &&
+        err !== null &&
+        'message' in err &&
+        isRenderAbortMessage(err.message)) {
+        return true;
+    }
     if (err instanceof Error) {
         if (err.name === 'AbortError')
             return true;
-        if (err.message === 'The render was aborted by the server without a reason') {
+        if (isRenderAbortMessage(err.message)) {
             return true;
         }
     }

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

@@ -0,0 +1,6 @@
+import type { ImportMap, Manifest, PluginConfig, SolasRequest } from '../../types.js';
+import { HttpRouter } from './router.js';
+/**
+ * Create the HTTP router from the generated manifest and import map
+ */
+export declare function createHttpRouter(config: Pick<PluginConfig, 'precompress' | 'trailingSlash'>, manifest: Manifest, importMap: ImportMap, rsc: (req: SolasRequest) => Response | Promise<Response>): HttpRouter;

package/dist/internal/{router/create-router.js → http-router/create-http-router.js}

@@ -1,4 +1,4 @@
-import { Router } from './router.js';
+import { HttpRouter } from './router.js';
 function callEndpoint(fn, req) {
     // endpoint modules may export either a zero-arg handler or one that expects the request
     if (fn.length === 0)
@@ -44,14 +44,14 @@ function mergeMiddlewares(left, right) {
     return merged;
 }
 /**
- * Create the application router from the generated manifest and import map
+ * Create the HTTP router from the generated manifest and import map
  */
-export function createRouter(config, manifest, importMap, rsc) {
-    const router = new Router({
+export function createHttpRouter(config, manifest, importMap, rsc) {
+    const router = new HttpRouter({
         trailingSlash: config.trailingSlash,
     });
     // static assets stay outside route middleware conventions and are registered once
-    router.add('/assets/*', 'GET', Router.static(config));
+    router.add('/assets/*', 'GET', HttpRouter.static(config));
     for (const [, group] of createHandlerGroups(manifest)) {
         if (!Array.isArray(group)) {
             if ('paths' in group) {

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

@@ -1,5 +1,5 @@
 import type { HttpMethod, PluginConfig, SolasRequest } from '../../types.js';
-export declare namespace Router {
+export declare namespace HttpRouter {
     type Params = Record<string, string | string[]>;
     type Handler = (req: SolasRequest) => Response | Promise<Response>;
     type ErrorHandler = (err: Error, req: SolasRequest) => Response | Promise<Response>;
@@ -40,28 +40,28 @@ export declare namespace Router {
 /**
  * Handle routing and matching for server requests
  */
-export declare class Router {
+export declare class HttpRouter {
     #private;
-    opts: Router.Options;
-    constructor(opts?: Router.Options);
+    opts: HttpRouter.Options;
+    constructor(opts?: HttpRouter.Options);
     /**
      * Register middleware for all routes
      */
-    use(...middleware: Router.Middleware[]): this;
+    use(...middleware: HttpRouter.Middleware[]): this;
     /**
      * Register an error handler for routing failures
      */
-    error(handler: Router.ErrorHandler): this;
+    error(handler: HttpRouter.ErrorHandler): this;
     /**
      * Register a route handler
      */
-    add(path: string, method: string, handler: Router.Handler, params?: string[], middleware?: Router.Middleware[]): this;
+    add(path: string, method: string, handler: HttpRouter.Handler, params?: string[], middleware?: HttpRouter.Middleware[]): this;
     /**
      * Match a path and method, returning params and route
      */
     match(path: string, method: HttpMethod): {
-        route: Router.Route;
-        params: Router.Params;
+        route: HttpRouter.Route;
+        params: HttpRouter.Params;
     } | null;
     /**
      * Handle an incoming request

package/dist/internal/{router → http-router}/router.js

@@ -1,13 +1,13 @@
 import path from 'node:path';
 import { match as createMatch } from 'path-to-regexp';
 import { Solas } from '../../solas.js';
-import { getAlternatePathname, normalisePathname, toPathPattern } from './utils.js';
 import { HttpException } from '../navigation/http-exception.js';
 import { maybeAction } from '../server/actions.js';
+import { getAlternatePathname, normalisePathname, toPathPattern } from './utils.js';
 /**
  * Handle routing and matching for server requests
  */
-export class Router {
+export class HttpRouter {
     opts;
     static #matchers = new WeakMap();
     #routes = {
@@ -54,7 +54,7 @@ export class Router {
         const routePath = !path.includes(':') && !path.includes('*')
             ? normalisePathname(path, this.opts.trailingSlash ?? 'never')
             : path;
-        const segments = Router.#split(routePath);
+        const segments = HttpRouter.#split(routePath);
         const tokens = [];
         let score = 0;
         let wildcard = false;
@@ -122,7 +122,7 @@ export class Router {
      * Match a path and method, returning params and route
      */
     match(path, method) {
-        for (const candidate of Router.#candidates(path)) {
+        for (const candidate of HttpRouter.#candidates(path)) {
             const direct = this.#routes.static.get(`${method}:${candidate}`);
             if (direct)
                 return { route: direct, params: {} };
@@ -133,25 +133,25 @@ export class Router {
             }
         }
         // else dynamic/wildcard match
-        const segments = Router.#split(path);
+        const segments = HttpRouter.#split(path);
         // try the leading-static prefix bucket first
         const prefixed = this.#routes.dynamic.byPrefix.get(segments[0] ?? '');
-        const prefixedMatch = prefixed ? Router.#pick(prefixed, segments, method) : null;
+        const prefixedMatch = prefixed ? HttpRouter.#pick(prefixed, segments, method) : null;
         if (prefixedMatch)
             return prefixedMatch;
         // if the prefix bucket has no winner, fall back to all dynamic
         // routes with the same segment count
-        const dynamicMatch = Router.#pick(this.#routes.dynamic.byLength.get(segments.length) ?? [], segments, method);
+        const dynamicMatch = HttpRouter.#pick(this.#routes.dynamic.byLength.get(segments.length) ?? [], segments, method);
         if (dynamicMatch)
             return dynamicMatch;
         // finally check wildcard routes, prefixed first, then fully generic ones
         const wildcardPrefixed = this.#routes.wildcard.byPrefix.get(segments[0] ?? '');
         const wildcardMatch = wildcardPrefixed
-            ? Router.#pick(wildcardPrefixed, segments, method)
+            ? HttpRouter.#pick(wildcardPrefixed, segments, method)
             : null;
         if (wildcardMatch)
             return wildcardMatch;
-        const wildcardFallbackMatch = Router.#pick(this.#routes.wildcard.fallback, segments, method);
+        const wildcardFallbackMatch = HttpRouter.#pick(this.#routes.wildcard.fallback, segments, method);
         if (wildcardFallbackMatch)
             return wildcardFallbackMatch;
         // no match
@@ -192,14 +192,14 @@ export class Router {
                 // unmatched requests still pass through the shared error hook with the
                 // same request metadata shape as matched requests
                 return (this.#onError?.(error, Object.assign(req, {
-                    [Solas.Config.REQUEST_META]: { match: null, error, action },
+                    [Solas.Config.REQUEST_META_KEY]: { match: null, error, action },
                 })) ?? new Response(error.message, { status: error.status }));
             }
             const matched = match;
             // attach routing state to the request once so middleware and handlers can
             // read the same per-request metadata
             const request = Object.assign(req, {
-                [Solas.Config.REQUEST_META]: { match: matched, action, parsedFormData },
+                [Solas.Config.REQUEST_META_KEY]: { match: matched, action, parsedFormData },
             });
             // global middleware stays outside route middleware by preserving
             // registration order here before composition in #run
@@ -210,7 +210,7 @@ export class Router {
             // normalise unknown throwables so the error hook always receives an Error
             const error = err instanceof Error ? err : new Error(String(err), { cause: err });
             const request = Object.assign(req, {
-                [Solas.Config.REQUEST_META]: { match, error, action },
+                [Solas.Config.REQUEST_META_KEY]: { match, error, action },
             });
             if (this.#onError)
                 return this.#onError(error, request);
@@ -270,7 +270,7 @@ export class Router {
                 return new Response('Forbidden', { status: 403 });
             }
             // emitted assets are fingerprinted so they can be cached aggressively
-            return Router.serve(filePath, req, config.precompress, {
+            return HttpRouter.serve(filePath, req, config.precompress, {
                 'Cache-Control': 'public, immutable, max-age=31536000',
             });
         };
@@ -343,7 +343,7 @@ export class Router {
      * Get or create a path matcher for a route using path-to-regexp
      */
     static #getMatcher(route) {
-        const cached = Router.#matchers.get(route);
+        const cached = HttpRouter.#matchers.get(route);
         if (cached)
             return cached;
         // convert route tokens back into a path pattern for path-to-regexp to compile
@@ -352,7 +352,7 @@ export class Router {
         const matcher = createMatch(path, {
             decode: false,
         });
-        Router.#matchers.set(route, matcher);
+        HttpRouter.#matchers.set(route, matcher);
         return matcher;
     }
     /**
@@ -375,7 +375,8 @@ export class Router {
         for (let index = 0; index < length; index += 1) {
             // prefer static over dynamic and dynamic over wildcard at the
             // first segment position where the two routes differ
-            const diff = Router.#getTokenRank(a.tokens[index]) - Router.#getTokenRank(b.tokens[index]);
+            const diff = HttpRouter.#getTokenRank(a.tokens[index]) -
+                HttpRouter.#getTokenRank(b.tokens[index]);
             if (diff !== 0)
                 return diff;
         }
@@ -399,11 +400,11 @@ export class Router {
             }
             // skip routes that do not fit this path. Only compare specificity
             // across matched routes
-            const params = Router.#fit(route, segments);
+            const params = HttpRouter.#fit(route, segments);
             if (!params)
                 continue;
             // replace the winner only when this route is strictly more specific
-            if (!best || Router.#compare(route, best) > 0) {
+            if (!best || HttpRouter.#compare(route, best) > 0) {
                 best = route;
                 bestParams = params;
             }
@@ -426,7 +427,7 @@ export class Router {
         }
         // defer the actual param extraction to the cached path-to-regexp matcher so
         // dynamic and wildcard params stay consistent with registration
-        const matched = Router.#getMatcher(route)(segments.length ? `/${segments.join('/')}` : '/');
+        const matched = HttpRouter.#getMatcher(route)(segments.length ? `/${segments.join('/')}` : '/');
         if (!matched)
             return null;
         return matched.params;

package/dist/internal/{router → http-router}/utils.d.ts

@@ -1,4 +1,4 @@
-import type { Route } from '../../types.js';
+import type { PluginConfig } from '../../types.js';
 export type PathPattern = {
     path: string;
     wildcardNames: Set<string>;
@@ -14,8 +14,16 @@ export declare function toPathPattern(route: string, paramNames?: string[]): {
 /**
  * Apply the configured trailing-slash policy to a pathname
  */
-export declare function normalisePathname(pathname: string, trailingSlash?: Route.TrailingSlash): string;
+export declare function normalisePathname(pathname: string, trailingSlash?: PluginConfig['trailingSlash']): string;
 /**
- * Return the other pathname shape for a non-root route
+ * Return the other pathname shape for a non-root route. For use within
+ * trailingSlash logic to easily switch between shapes
+ *
+ * @example
+ * ```ts
+ * 	getAlternatePathname('/about') // '/about/'
+ * 	getAlternatePathname('/about/') // '/about'
+ * 	getAlternatePathname('/') // '/'
+ * ```
  */
 export declare function getAlternatePathname(pathname: string): string;

package/dist/internal/{router → http-router}/utils.js

@@ -53,7 +53,15 @@ export function normalisePathname(pathname, trailingSlash = 'never') {
     return pathname.endsWith('/') ? pathname.slice(0, -1) : pathname;
 }
 /**
- * Return the other pathname shape for a non-root route
+ * Return the other pathname shape for a non-root route. For use within
+ * trailingSlash logic to easily switch between shapes
+ *
+ * @example
+ * ```ts
+ * 	getAlternatePathname('/about') // '/about/'
+ * 	getAlternatePathname('/about/') // '/about'
+ * 	getAlternatePathname('/') // '/'
+ * ```
  */
 export function getAlternatePathname(pathname) {
     if (pathname === '/')

package/dist/internal/metadata.js

@@ -85,15 +85,6 @@ var Metadata;
             metadata.link = [...linkMap.values()];
             return metadata;
         }
-        /**
-         * Clones an object using structuredClone w/ JSON fallback
-         */
-        static #clone(obj) {
-            if (typeof structuredClone === 'function') {
-                return structuredClone(obj);
-            }
-            return JSON.parse(JSON.stringify(obj));
-        }
         /**
          * Gets a unique key for the meta tag
          */
@@ -123,6 +114,15 @@ var Metadata;
             }
             return this;
         }
+        /**
+         * Clones an object using structuredClone w/ JSON fallback
+         */
+        static #clone(obj) {
+            if (typeof structuredClone === 'function') {
+                return structuredClone(obj);
+            }
+            return JSON.parse(JSON.stringify(obj));
+        }
         /**
          * Merges metadata from all sources, sorted by priority
          */
@@ -130,7 +130,7 @@ var Metadata;
             const items = [...this.#collection].sort((a, b) => a.priority - b.priority);
             if (items.length === 0)
                 return Collection.#clone(this.#base);
-            let merged = Collection.#clone(this.#base);
+            let merged = this.#base;
             const res = await Promise.allSettled(items.map(item => item.task));
             const ok = res
                 .filter((result) => result.status === 'fulfilled')

package/dist/internal/prerender.d.ts

@@ -14,14 +14,9 @@ export declare namespace Prerender {
         type Metadata = Pick<Value, 'schema' | 'route' | 'createdAt' | 'mode'>;
         type ManifestEntry = {
             mode: Mode;
-            createdAt: number;
-            files?: File[];
-            fullPrerenderFilename?: string;
-        };
-        type Manifest = {
-            generatedAt: number;
-            routes: Record<string, ManifestEntry>;
+            files?: readonly File[];
         };
+        type Manifest = Record<string, ManifestEntry>;
         /**
          * Get the root directory path where prerender artifacts are stored,
          * based on the output directory specified in the configuration
@@ -41,9 +36,9 @@ export declare namespace Prerender {
          */
         function getFilePath(outDir: string, pathname: string, fileName: string): string;
         /**
-         * Build a deterministic file name for a full prerender html artifact
+         * File name used for saved full-prerender html inside each route artifact directory
          */
-        function getFullHtmlFileName(html: string): string;
+        const FULL_PRERENDER_FILENAME = "prerendered.html";
         /**
          * Load the prerender artifact manifest for faster runtime route mode checks
          */