@jk2908/solas 0.1.0

package/dist/internal/codegen/environments.js

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

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

@@ -0,0 +1,5 @@
+import type { Manifest } from '../../types';
+/**
+ * Generates the code to create an exported manifest object
+ */
+export declare function writeManifest(manifest: Manifest): string;

package/dist/internal/codegen/manifest.js

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

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

@@ -0,0 +1,5 @@
+import type { Build } from '../build';
+/**
+ * Generates the import map for all route components, endpoints, layouts, shells, and middlewares
+ */
+export declare function writeMaps(imports: Build.Imports, modules: Build.Modules): string;

package/dist/internal/codegen/maps.js

@@ -0,0 +1,75 @@
+import { Solas } from '../../solas';
+import { AUTOGEN_MSG } from './utils';
+/**
+ * Generates the import map for all route components, endpoints, layouts, shells, and middlewares
+ */
+export function writeMaps(imports, modules) {
+    const statics = [
+        ...imports.endpoints.static.entries().map(([k, v]) => {
+            const [, method] = k.split('_');
+            return `import { ${method.toUpperCase()} as ${k}} from ${JSON.stringify(v)}`.trim();
+        }),
+        ...imports.components.static
+            .entries()
+            .map(([k, v]) => `import * as ${k} from ${JSON.stringify(v)}`.trim()),
+        ...imports.middlewares.static
+            .entries()
+            .map(([k, v]) => `import { middleware as ${k} } from ${JSON.stringify(v)}`.trim()),
+    ];
+    const dynamics = [
+        ...imports.components.dynamic
+            .entries()
+            .map(([k, v]) => `export const ${k} = () => import(${JSON.stringify(v)})`.trim()),
+    ];
+    const map = Object.entries(modules).map(([id, m]) => {
+        const parts = [];
+        if (m.shellId)
+            parts.push(`shell: ${m.shellId}`);
+        if (m.layoutIds?.length) {
+            const layouts = m.layoutIds.map(id => (id === null ? 'null' : id)).join(', ');
+            parts.push(`layouts: [${layouts}]`);
+        }
+        if (m.pageId)
+            parts.push(`page: ${m.pageId}`);
+        if (m.endpointId)
+            parts.push(`endpoint: ${m.endpointId}`);
+        if (m['401Ids']?.length) {
+            const unauthorized = m['401Ids'].map(id => (id === null ? 'null' : id)).join(', ');
+            parts.push(`'401s': [${unauthorized}]`);
+        }
+        if (m['403Ids']?.length) {
+            const forbidden = m['403Ids'].map(id => (id === null ? 'null' : id)).join(', ');
+            parts.push(`'403s': [${forbidden}]`);
+        }
+        if (m['404Ids']?.length) {
+            const notFounds = m['404Ids'].map(id => (id === null ? 'null' : id)).join(', ');
+            parts.push(`'404s': [${notFounds}]`);
+        }
+        if (m['500Ids']?.length) {
+            const serverErrors = m['500Ids'].map(id => (id === null ? 'null' : id)).join(', ');
+            parts.push(`'500s': [${serverErrors}]`);
+        }
+        if (m.loadingIds?.length) {
+            const loaders = m.loadingIds.map(id => (id === null ? 'null' : id)).join(', ');
+            parts.push(`loaders: [${loaders}]`);
+        }
+        if (m.middlewareIds?.length) {
+            const middleware = m.middlewareIds.map(id => (id === null ? 'null' : id)).join(', ');
+            parts.push(`middlewares: [${middleware}]`);
+        }
+        return `${JSON.stringify(id)}: { ${parts.join(', ')} }`;
+    });
+    return `
+	  ${AUTOGEN_MSG}
+
+		import type { ImportMap } from '${Solas.Config.PKG_NAME}'
+
+	  ${statics.join('\n')}
+		
+	  ${dynamics.join('\n')}
+
+		export const importMap = {
+			${map.join(',\n')}
+		} as const satisfies ImportMap
+	`;
+}

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

@@ -0,0 +1 @@
+export declare const AUTOGEN_MSG = "// auto-generated by Solas";

package/dist/internal/codegen/utils.js

@@ -0,0 +1,2 @@
+import { Solas } from '../../solas';
+export const AUTOGEN_MSG = `// auto-generated by ${Solas.Config.NAME}`;

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

@@ -0,0 +1,4 @@
+/**
+ * Browser RSC hydration entry point
+ */
+export declare function browser(): Promise<void>;

package/dist/internal/env/browser.js

@@ -0,0 +1,58 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { StrictMode, Suspense, useCallback, useEffect, useState, useTransition, } from 'react';
+import { hydrateRoot } from 'react-dom/client';
+import { createFromFetch, createFromReadableStream, createTemporaryReferenceSet, encodeReply, setServerCallback, } from '@vitejs/plugin-rsc/browser';
+import { rscStream } from 'rsc-html-stream/client';
+import { RedirectBoundary } from '../navigation/redirect-boundary';
+import { Head } from '../render/head';
+import { RouterProvider } from '../router/router-provider';
+import { ErrorBoundary } from '../ui/error-boundary';
+/**
+ * Browser RSC hydration entry point
+ */
+export async function browser() {
+    const payload = await createFromReadableStream(rscStream, {
+        unstable_allowPartialStream: true,
+    });
+    let setPayload = () => { };
+    function A() {
+        const [p, setP] = useState(payload);
+        const [isPending, startTransition] = useTransition();
+        const setPayloadInTransition = useCallback((payload) => {
+            startTransition(() => {
+                setP(payload);
+            });
+        }, []);
+        useEffect(() => {
+            // expose external setPayload - used inside
+            // server callback to update payload after
+            // action execution
+            setPayload = setPayloadInTransition;
+        }, [setPayloadInTransition]);
+        return (_jsx(RedirectBoundary, { children: _jsxs(RouterProvider, { setPayload: setPayloadInTransition, isNavigating: isPending, children: [
+                    _jsx(ErrorBoundary, { fallback: null, children: _jsx(Suspense, { fallback: null, children: _jsx(Head, { metadata: p.metadata }) }) }), p.root] }) }));
+    }
+    setServerCallback(async (id, args) => {
+        const url = new URL(window.location.href);
+        const temporaryReferences = createTemporaryReferenceSet();
+        const payload = await createFromFetch(fetch(url, {
+            method: 'POST',
+            body: await encodeReply(args, { temporaryReferences }),
+            headers: {
+                'x-rsc-action-id': id,
+            },
+        }), { temporaryReferences });
+        setPayload(payload);
+        const { ok, data } = payload.returnValue ?? {};
+        if (!ok)
+            throw data;
+        return data;
+    });
+    hydrateRoot(document, _jsx(StrictMode, { children: _jsx(A, {}) }), {
+        formState: payload.formState,
+    });
+    import.meta.hot?.on?.('rsc:update', async () => {
+        const p = await createFromFetch(fetch(window.location.href, { headers: { Accept: 'text/x-component' } }));
+        setPayload(p);
+    });
+}

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

@@ -0,0 +1,19 @@
+import type { SolasRequest } from '../../types';
+import type { Cookies } from '../../utils/cookies';
+export type RequestCache = {
+    cookies?: Readonly<ReturnType<typeof Cookies.parse>>;
+    headers?: ReadonlyMap<string, string>;
+    url?: URL;
+};
+export declare const RequestContext: {
+    use(): {
+        req: SolasRequest;
+        prerender: "full" | "ppr" | null;
+        cache: RequestCache;
+    };
+    write<R>(value: {
+        req: SolasRequest;
+        prerender: "full" | "ppr" | null;
+        cache: RequestCache;
+    }, fn: () => R | Promise<R>): R | Promise<R>;
+};

package/dist/internal/env/request-context.js

@@ -0,0 +1,2 @@
+import { Context } from '../../utils/context';
+export const RequestContext = Context.create('request');

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

@@ -0,0 +1,39 @@
+import type { ReactFormState } from 'react-dom/client';
+import type { ImportMap, Manifest, RuntimeConfig, SolasRequest } from '../../types';
+import { Metadata } from '../metadata';
+export type RSCPayload = {
+    returnValue?: {
+        ok: boolean;
+        data: unknown;
+    };
+    formState?: ReactFormState;
+    root: React.ReactNode;
+    metadata?: Promise<Metadata.Item>;
+};
+export declare function action(req: SolasRequest): Promise<{
+    returnValue: {
+        ok: boolean;
+        data: unknown;
+    } | undefined;
+    formState: ReactFormState | undefined;
+    temporaryReferences: unknown;
+}>;
+/**
+ * Check if a request is an action request and reuse parsed FormData
+ * when multipart action detection already had to inspect the body
+ */
+export declare function maybeActionWithParsedFormData(req: Request): Promise<{
+    action: boolean;
+    formData: null;
+} | {
+    action: boolean;
+    formData: FormData;
+}>;
+/**
+ * Create the object exported by the generated RSC entry. Uses the generated config,
+ * route manifest, and import map to build the router once, then returns an object
+ * with a fetch method that handles requests
+ */
+export declare function createHandler(config: RuntimeConfig, manifest: Manifest, importMap: ImportMap): {
+    fetch(req: Request): Promise<Response>;
+};

package/dist/internal/env/rsc.js

@@ -0,0 +1,368 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createTemporaryReferenceSet, decodeAction, decodeFormState, decodeReply, loadServerAction, renderToReadableStream, } from '@vitejs/plugin-rsc/rsc';
+import { Solas } from '../../solas';
+import { Logger } from '../../utils/logger';
+import { getKnownDigest, isKnownError } from './utils';
+import { Metadata } from '../metadata';
+import { HttpException, isHttpException } from '../navigation/http-exception';
+import { Prerender } from '../prerender';
+import { Tree } from '../render/tree';
+import { createRouter } from '../router/create-router';
+import { Resolver } from '../router/resolver';
+import { Router } from '../router/router';
+import DefaultErr from '../ui/defaults/error';
+import { RequestContext } from './request-context';
+/**
+ * Get 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) {
+    const resolver = new Resolver(manifest, importMap);
+    const logger = new Logger();
+    const prerender = req.headers.get(`x-${Solas.Config.SLUG}-prerender`) === '1';
+    const url = new URL(req.url);
+    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));
+    // 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 title = `${'status' in error ? `${error.status} -` : ''}${error.message}`;
+        const rscPayload = {
+            root: (_jsxs("html", { lang: "en", children: [
+                    _jsxs("head", { children: [
+                            _jsx("meta", { charSet: "UTF-8" }), _jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1.0" }), _jsx("meta", { name: "robots", content: "noindex,nofollow" }), _jsx("title", { children: title })
+                        ] }), _jsx("body", { children: _jsx(DefaultErr, { error: error }) })
+                ] })),
+            returnValue,
+            formState,
+        };
+        return {
+            // this path is a safety fallback when a prerender request
+            // hits an unmatched route. In build prerender we force
+            // mode to 'full' so the 404/error shell resolves
+            // immediately. In normal request-time rendering
+            // we keep mode as null (obvi)
+            stream: RequestContext.write({
+                req,
+                prerender: prerender ? 'full' : null,
+                cache: {},
+            }, () => renderToReadableStream(rscPayload, {
+                temporaryReferences,
+                onError(err) {
+                    if (err == null)
+                        return;
+                    const digest = getKnownDigest(err);
+                    if (digest)
+                        return digest;
+                    if (isKnownError(err))
+                        return;
+                    logger.error('[rsc]', err);
+                },
+            })),
+            status: 404,
+            ppr: false,
+        };
+    }
+    // check if this route is a candidate for ppr
+    const ppr = match.prerender === 'ppr';
+    const collection = new Metadata.Collection(baseMetadata);
+    const metadata = collection
+        .add(...(match.metadata?.({ params: match.params, error: match.error }) ?? []))
+        .run();
+    const rscPayload = {
+        root: (_jsx(_Fragment, { children: _jsx(Tree, { depth: match.__depth, params: match.params, error: match.error, ui: match.ui }) })),
+        returnValue,
+        formState,
+        metadata,
+    };
+    // status code comes from route match error if any
+    const status = isHttpException(match.error) ? match.error.status : 200;
+    try {
+        // this is the main matched route render pass for page/layout
+        // tree output. Mode is null for normal ssr, 'full' for full
+        // prerender, and 'ppr' for ppr prerender. dynamic() only
+        // suspends when mode is 'ppr'
+        const stream = RequestContext.write({
+            req,
+            prerender: prerender ? (ppr ? 'ppr' : 'full') : null,
+            cache: {},
+        }, () => renderToReadableStream(rscPayload, {
+            temporaryReferences,
+            onError(err) {
+                if (err == null)
+                    return;
+                const digest = getKnownDigest(err);
+                if (digest)
+                    return digest;
+                if (isKnownError(err))
+                    return;
+                logger.error('[rsc]', err);
+            },
+        }));
+        return { stream, status, ppr };
+    }
+    catch (err) {
+        // shell failed to render - return minimal fallback
+        logger.error('rsc shell', err);
+        const title = err instanceof Error
+            ? 'status' in err
+                ? `${err.status} - ${err.message}`
+                : `500 - ${err.message}`
+            : '500 - Unknown server error';
+        const error = new Error(err instanceof Error ? err.message : 'Unknown server error', {
+            cause: err,
+        });
+        return {
+            // this branch renders the minimal error shell after the
+            // main tree throws. We keep the same mode as the
+            // request so helpers see consistent state
+            // prevents mode drift on error paths
+            stream: RequestContext.write({
+                req,
+                prerender: prerender ? 'full' : null,
+                cache: {},
+            }, () => renderToReadableStream({
+                root: (_jsxs("html", { lang: "en", children: [
+                        _jsxs("head", { children: [
+                                _jsx("meta", { charSet: "UTF-8" }), _jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1.0" }), _jsx("meta", { name: "robots", content: "noindex,nofollow" }), _jsx("title", { children: title })
+                            ] }), _jsx("body", { children: _jsx(DefaultErr, { error: error }) })
+                    ] })),
+                returnValue,
+                formState,
+            }, {
+                temporaryReferences,
+            })),
+            status: 500,
+            ppr: false,
+        };
+    }
+}
+export async function action(req) {
+    let returnValue;
+    let formState;
+    let temporaryReferences;
+    const id = req.headers.get('x-rsc-action-id');
+    if (id) {
+        // x-rsc-action-id header exists when action is
+        // called via ReactClient.setServerCallback
+        const body = req.headers.get('content-type')?.startsWith('multipart/form-data')
+            ? await req.formData()
+            : await req.text();
+        temporaryReferences = createTemporaryReferenceSet();
+        const args = await decodeReply(body, {
+            temporaryReferences,
+        });
+        const action = await loadServerAction(id);
+        try {
+            const data = await action.apply(null, args);
+            returnValue = { ok: true, data };
+        }
+        catch (err) {
+            returnValue = { ok: false, data: err };
+        }
+    }
+    else {
+        // otherwise server function is called via
+        // <form action={...}>
+        // we might have already parsed FormData in the router for multipart action
+        // detection should be attached to the SolasRequest, so we can reuse that
+        // to avoid parsing twice
+        const parsedFormData = req[Solas.Config.REQUEST_META]?.parsedFormData;
+        const formData = parsedFormData ?? (await req.formData());
+        const decodedAction = await decodeAction(formData);
+        const result = await decodedAction();
+        formState = await decodeFormState(result, formData);
+    }
+    return { returnValue, formState, temporaryReferences };
+}
+/**
+ * Check if a request is an action request and reuse parsed FormData
+ * when multipart action detection already had to inspect the body
+ */
+export async function maybeActionWithParsedFormData(req) {
+    if (req.method !== 'POST')
+        return { action: false, formData: null };
+    if (req.headers.has('x-rsc-action-id'))
+        return { action: true, formData: null };
+    const contentType = req.headers.get('content-type') ?? '';
+    if (!contentType.startsWith('multipart/form-data')) {
+        return { action: false, formData: null };
+    }
+    try {
+        const formData = await req.clone().formData();
+        for (const key of formData.keys()) {
+            if (key === '$ACTION_KEY' ||
+                key.startsWith('$ACTION_') ||
+                key.startsWith('$ACTION_REF_')) {
+                return { action: true, formData };
+            }
+        }
+    }
+    catch {
+        return { action: false, formData: null };
+    }
+    return { action: false, formData: null };
+}
+/**
+ * Create the object exported by the generated RSC entry. Uses the generated config,
+ * route manifest, and import map to build the router once, then returns an object
+ * with a fetch method that handles requests
+ */
+export function createHandler(config, manifest, importMap) {
+    const fullyPrerenderedRoutes = new Set(Object.values(manifest)
+        .flat()
+        .filter(entry => 'prerender' in entry && String(entry.prerender) === 'full')
+        .map(entry => entry.__path));
+    /**
+     * Create the HTTP response for a single incoming request. Runs actions when needed,
+     * converts the payload into component, HTML, or prerender artifact responses, and
+     * applies the final status and headers
+     */
+    async function createResponse(req) {
+        let opts = {
+            formState: undefined,
+            temporaryReferences: undefined,
+            returnValue: undefined,
+        };
+        if (req[Solas.Config.REQUEST_META].action)
+            opts = await action(req);
+        const { stream: rscStream, status, ppr, } = await getPayload(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, {
+                headers: {
+                    'Cache-Control': 'private, no-store',
+                    'Content-Type': 'text/x-component; charset=utf-8',
+                    Vary: 'accept',
+                },
+                status,
+            });
+        }
+        const mod = await import.meta.viteRsc.loadModule('ssr', 'index');
+        const pathname = new URL(req.url).pathname;
+        const runtimePpr = !import.meta.env.DEV && ppr;
+        // prerender artifact requests bypass the normal document path so the cli
+        // gets structured JSON instead of a rendered html response
+        if (req.headers.get(`x-${Solas.Config.SLUG}-prerender`) === '1' &&
+            req.headers.get(`x-${Solas.Config.SLUG}-prerender-artifact`) === '1') {
+            const artifact = await mod.prerender(stream, {
+                formState: opts.formState,
+                ppr: runtimePpr,
+                route: pathname,
+            });
+            return new Response(JSON.stringify(artifact), {
+                headers: {
+                    'Cache-Control': 'private, no-store',
+                    'Content-Type': 'application/json; charset=utf-8',
+                    Vary: 'accept',
+                },
+                status,
+            });
+        }
+        const artifactManifest = runtimePpr
+            ? await Prerender.Artifact.loadManifest(Solas.Config.OUT_DIR)
+            : null;
+        const artifactManifestEntry = artifactManifest?.routes[pathname] ?? null;
+        let tryPrelude = false;
+        if (artifactManifestEntry) {
+            tryPrelude = artifactManifestEntry.mode === 'ppr';
+        }
+        else if (runtimePpr) {
+            const artifactMetadata = await Prerender.Artifact.loadMetadata(Solas.Config.OUT_DIR, pathname);
+            tryPrelude =
+                !!artifactMetadata &&
+                    Prerender.Artifact.isCompatible(artifactMetadata, pathname, 'ppr');
+        }
+        if (tryPrelude) {
+            const postponedState = await Prerender.Artifact.loadPostponedState(Solas.Config.OUT_DIR, pathname);
+            const prelude = await Prerender.Artifact.loadPrelude(Solas.Config.OUT_DIR, pathname);
+            // resumable ppr responses splice fresh streamed content into the cached
+            // prelude when postponed state is available for this route
+            if (postponedState) {
+                const resumeStream = await mod.resume(stream, postponedState, {
+                    nonce: undefined,
+                    injectPayload: true,
+                });
+                const body = prelude
+                    ? Prerender.Artifact.composePreludeAndResume(prelude, resumeStream)
+                    : resumeStream;
+                return new Response(body, {
+                    headers: {
+                        'Cache-Control': 'private, no-store',
+                        'Content-Type': 'text/html',
+                        Vary: 'accept',
+                    },
+                    status,
+                });
+            }
+        }
+        const htmlStream = await mod.ssr(stream, {
+            formState: opts.formState,
+            ppr: runtimePpr,
+        });
+        return new Response(htmlStream, {
+            headers: {
+                'Cache-Control': 'private, no-store',
+                'Content-Type': 'text/html',
+                Vary: 'accept',
+            },
+            status,
+        });
+    }
+    const router = createRouter(config, manifest, importMap, createResponse);
+    return {
+        async fetch(req) {
+            const url = new URL(req.url);
+            const accept = req.headers.get('accept') ?? '';
+            // fully prerendered html can be served straight from disk for normal
+            // document requests, but artifact generation must still hit the runtime path
+            if (!import.meta.env.DEV &&
+                accept.includes('text/html') &&
+                req.headers.get(`x-${Solas.Config.SLUG}-prerender-artifact`) !== '1') {
+                const pathname = url.pathname;
+                let prerenderPath = null;
+                const artifactManifest = await Prerender.Artifact.loadManifest(Solas.Config.OUT_DIR);
+                const artifactManifestEntry = artifactManifest?.routes[pathname] ?? null;
+                if (fullyPrerenderedRoutes.has(pathname)) {
+                    prerenderPath =
+                        pathname === '/'
+                            ? Solas.Config.OUT_DIR + '/index.html'
+                            : Solas.Config.OUT_DIR + pathname + '/index.html';
+                }
+                else if (artifactManifestEntry) {
+                    if (artifactManifestEntry.mode === 'full') {
+                        prerenderPath =
+                            pathname === '/'
+                                ? Solas.Config.OUT_DIR + '/index.html'
+                                : Solas.Config.OUT_DIR + pathname + '/index.html';
+                    }
+                }
+                else {
+                    const artifactMetadata = await Prerender.Artifact.loadMetadata(Solas.Config.OUT_DIR, pathname);
+                    if (artifactMetadata &&
+                        Prerender.Artifact.isCompatible(artifactMetadata, pathname, 'full')) {
+                        prerenderPath =
+                            pathname === '/'
+                                ? Solas.Config.OUT_DIR + '/index.html'
+                                : Solas.Config.OUT_DIR + pathname + '/index.html';
+                    }
+                }
+                if (prerenderPath) {
+                    const res = await Router.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',
+                    });
+                    if (res.status !== 404)
+                        return res;
+                }
+            }
+            return router.fetch(req);
+        },
+    };
+}