@jk2908/solas 0.3.0 → 0.3.2

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

@@ -0,0 +1,29 @@
+type Chunk = string | Uint8Array;
+type Opts = {
+    nonce?: string;
+};
+declare global {
+    interface Window {
+        __FLIGHT_DATA?: Chunk[];
+    }
+}
+/**
+ * Capture only the payload rows that are already buffered in a stream.
+ * Used by ppr prerender so the cached prelude carries the static
+ * payload, while postponed work is left for request-time resume
+ */
+export declare function captureBuffered(stream: ReadableStream<Uint8Array>): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+/**
+ * Read the inline payload rows written into the html document. Stays open
+ * for the lifetime of the document so ppr resume can keep appending rows
+ * without tripping React's connection-closed path
+ */
+export declare const rscStream: ReadableStream<Uint8Array<ArrayBufferLike>>;
+/**
+ * Inject the payload into the outgoing HTML as small inline script pushes. This keeps
+ * hydration on the first document load instead of doing a follow-up fetch. HTML still
+ * streams through, but the closing body/html tags are held back until the payload
+ * is written
+ */
+export declare function injectPayload(payload: ReadableStream<Uint8Array>, opts?: Opts): TransformStream<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+export {};

package/dist/internal/env/flight.js

@@ -0,0 +1,187 @@
+const encoder = new TextEncoder();
+const HTML_TRAIL = '</body></html>';
+/**
+ * Capture only the payload rows that are already buffered in a stream.
+ * Used by ppr prerender so the cached prelude carries the static
+ * payload, while postponed work is left for request-time resume
+ */
+export async function captureBuffered(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    try {
+        while (true) {
+            // only take what is already queued. anything still pending belongs
+            // to the later resume step, not the cached prelude
+            const result = await Promise.race([
+                reader.read(),
+                new Promise(r => setTimeout(r, 0, null)),
+            ]);
+            if (result === null || result.done)
+                break;
+            if (result.value)
+                chunks.push(result.value);
+        }
+    }
+    finally {
+        reader.cancel();
+    }
+    return new ReadableStream({
+        start(controller) {
+            for (const chunk of chunks)
+                controller.enqueue(chunk);
+            controller.close();
+        },
+    });
+}
+/**
+ * Read the inline payload rows written into the html document. Stays open
+ * for the lifetime of the document so ppr resume can keep appending rows
+ * without tripping React's connection-closed path
+ */
+export const rscStream = new ReadableStream({
+    start(controller) {
+        if (typeof window === 'undefined')
+            return;
+        // start with any rows already written into the page. Later resume
+        // work keeps adding to this same array
+        const flightData = (window.__FLIGHT_DATA ??= []);
+        // save the real array push before we replace it. We still want
+        // __FLIGHT_DATA to behave like a normal array
+        const push = flightData.push.bind(flightData);
+        // each row can be plain text or binary. normalise both into bytes
+        // before handing them to the browser-side RSC reader
+        function handle(entry) {
+            controller.enqueue(typeof entry === 'string' ? encoder.encode(entry) : entry);
+        }
+        // replay anything the page already wrote before this stream started.
+        // That lets hydration read the early rows first
+        for (const entry of flightData)
+            handle(entry);
+        // clear the array to release memory
+        window.__FLIGHT_DATA.length = 0;
+        // later inline scripts call __FLIGHT_DATA.push(...). Forward each new row
+        // into the open stream, then clear the array so old rows do not pile up
+        // in memory
+        flightData.push = (...entries) => {
+            const length = push(...entries);
+            for (const entry of entries)
+                handle(entry);
+            // once React has the row, we no longer need to keep it in the array
+            if (typeof window !== 'undefined' && window.__FLIGHT_DATA) {
+                window.__FLIGHT_DATA.length = 0;
+            }
+            // return the new length so the array behaves as expected
+            return length;
+        };
+    },
+});
+/**
+ * Inject the payload into the outgoing HTML as small inline script pushes. This keeps
+ * hydration on the first document load instead of doing a follow-up fetch. HTML still
+ * streams through, but the closing body/html tags are held back until the payload
+ * is written
+ */
+export function injectPayload(payload, opts = {}) {
+    const decoder = new TextDecoder();
+    let payloadWrite;
+    let buffered = [];
+    let timeout;
+    function flush(controller) {
+        for (const chunk of buffered) {
+            let html = decoder.decode(chunk, { stream: true });
+            // hold the final closing tags back so payload scripts land inside the document,
+            // not after it
+            if (html.endsWith(HTML_TRAIL)) {
+                html = html.slice(0, -HTML_TRAIL.length);
+            }
+            if (html)
+                controller.enqueue(encoder.encode(html));
+        }
+        // flush any decoder state left over from split utf-8/html chunks
+        let remaining = decoder.decode();
+        if (remaining.endsWith(HTML_TRAIL)) {
+            remaining = remaining.slice(0, -HTML_TRAIL.length);
+        }
+        if (remaining)
+            controller.enqueue(encoder.encode(remaining));
+        buffered = [];
+        timeout = undefined;
+    }
+    function start(controller) {
+        // only start writing payload rows once, even if html keeps arriving
+        payloadWrite ??= writePayload(payload, controller, opts.nonce);
+        return payloadWrite;
+    }
+    return new TransformStream({
+        transform(chunk, controller) {
+            // collect html first so we can decide where the payload scripts belong
+            buffered.push(chunk);
+            if (timeout != null)
+                return;
+            // html can arrive split in awkward places, so wait one tick before flushing.
+            // That gives the next chunk a chance to join up and keeps scripts out of
+            // half a tag
+            timeout = setTimeout(() => {
+                try {
+                    // once the buffered html is safe to write, start the payload writer too
+                    flush(controller);
+                }
+                catch (err) {
+                    controller.error(err);
+                    return;
+                }
+                start(controller).catch(err => controller.error(err));
+            }, 0);
+        },
+        async flush(controller) {
+            if (timeout != null) {
+                clearTimeout(timeout);
+                flush(controller);
+            }
+            // finish every payload row before restoring the closing html tags
+            await start(controller);
+            controller.enqueue(encoder.encode(HTML_TRAIL));
+        },
+    });
+}
+/**
+ * Turn each payload row into a tiny inline script that pushes into __FLIGHT_DATA.
+ * Text rows stay as strings when possible, and binary rows fall back to base64.
+ * The browser-side patched push then forwards those rows into the open stream
+ */
+async function writePayload(payload, controller, nonce) {
+    const decoder = new TextDecoder('utf-8', { fatal: true });
+    for await (const chunk of payload) {
+        try {
+            // most payload rows are plain text, so write the simplest script we can
+            writePayloadScript(JSON.stringify(decoder.decode(chunk, { stream: true })), controller, nonce);
+        }
+        catch {
+            // most rows are text, but keep binary chunks intact when a payload
+            // row cannot be decoded as utf-8
+            const base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
+            writePayloadScript(`Uint8Array.from(atob(${base64}), value => value.codePointAt(0))`, controller, nonce);
+        }
+    }
+    // flush any trailing decoder state after the stream ends
+    const remaining = decoder.decode();
+    if (remaining) {
+        writePayloadScript(JSON.stringify(remaining), controller, nonce);
+    }
+}
+/**
+ * Wrap one payload row in a script tag that appends into the shared browser queue.
+ * The script stays deliberately small: just push the row and let the patched push
+ * do the rest
+ */
+function writePayloadScript(chunk, controller, nonce) {
+    // each script only does a normal __FLIGHT_DATA.push(...). The patched push
+    // above forwards that row into the open stream. Escape the inline JS first
+    // so HTML parsing cannot break the script body
+    const script = `<script${nonce ? ` nonce="${nonce}"` : ''}>${escapeInlineScript(`(self.__FLIGHT_DATA||=[]).push(${chunk})`)}</script>`;
+    controller.enqueue(encoder.encode(script));
+}
+// Escape closing script tags and HTML comments inside inline JS
+function escapeInlineScript(script) {
+    return script.replace(/<!--/g, '<\\!--').replace(/<\/(script)/gi, '</\\$1');
+}

package/dist/internal/env/request-context.d.ts

@@ -1,5 +1,5 @@
-import type { SolasRequest } from '../../types.js';
 import type { Cookies } from '../../utils/cookies.js';
+import type { SolasRequest } from '../../types.js';
 export type RequestCache = {
     cookies?: Readonly<ReturnType<typeof Cookies.parse>>;
     headers?: ReadonlyMap<string, string>;

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