@jk2908/solas 0.11.1 → 0.12.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.12.0
+
+### Features
+
+- The static adapter supports client-side navigation. The build emits each fully prerendered route's RSC payload as `<route>.rsc.txt` next to its HTML, and the browser router fetches it, so a static host needs no server to answer navigations.
+- The active adapter's name is exposed as `import.meta.env.SOLAS_ADAPTER`, so apps can branch on the platform.
+
 ## 0.11.1
 
 ### Fixes

package/README.md

@@ -229,6 +229,8 @@ Solas resolves the origin in this order:
 
 The resolved origin is exposed to your app as `import.meta.env.VITE_APP_URL` and is used for build-time prerender requests and `sitemap` URLs. When `url` is set, it is also used as a trusted origin for CSRF.
 
+The active adapter's name is exposed as `import.meta.env.SOLAS_ADAPTER`, so your app can branch on the platform it is deployed to.
+
 You usually only need `url` in production, where the Vite dev server origin is meaningless. For example, to generate a `sitemap.xml` with real URLs:
 
 ```ts
@@ -707,7 +709,9 @@ export default defineConfig({
 })
 ```
 
-`vite build` writes the site to `build/` (override with `outDir`): the client assets, each route as `<route>.html` (or `<route>/index.html` under `trailingSlash: 'always'`), plus `sitemap.xml` and `robots.txt`. Serve that directory with anything — `npx serve build`, GitHub Pages, Netlify, an S3 bucket, nginx.
+`vite build` writes the site to `build/` (override with `outDir`): the client assets, each route as `<route>.html` (or `<route>/index.html` under `trailingSlash: 'always'`), its RSC payload as `<route>.rsc.txt`, plus `sitemap.xml` and `robots.txt`. Serve that directory with anything — `npx serve build`, GitHub Pages, Netlify, an S3 bucket, nginx.
+
+Client-side navigation works with no server: the browser router fetches each route's `<route>.rsc.txt` payload instead of asking a server for `text/x-component`.
 
 Because it forces full prerendering, routes that need a server are not a fit: per-route PPR or SSR opt-ins and dynamic routes without `params()`.
 

package/dist/index.js

@@ -261,6 +261,7 @@ function solas(c) {
             viteConfig.define ??= {};
             viteConfig.define['import.meta.env.VITE_APP_URL'] = JSON.stringify(resolvedUrl);
             viteConfig.define['import.meta.env.SOLAS_VERSION'] = JSON.stringify(pkg.version);
+            viteConfig.define['import.meta.env.SOLAS_ADAPTER'] = JSON.stringify(config.adapter?.name ?? '');
             viteConfig.optimizeDeps ??= {};
             viteConfig.optimizeDeps.exclude = [
                 ...new Set([
@@ -335,6 +336,7 @@ function solas(c) {
                 precompress: config.precompress,
                 trailingSlash: config.trailingSlash,
                 url: resolvedUrl,
+                adapter: config.adapter?.name ?? '',
             }));
         },
         buildApp: {

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

@@ -28,6 +28,25 @@ const DEFAULT_GO_CONFIG = {
 };
 const logger = new Logger();
 const responseCache = new ResponseCache();
+const STATIC = import.meta.env.SOLAS_ADAPTER === 'static';
+/**
+ * The URL to fetch the response for a navigation. On a static host that is the
+ * pre-generated RSC payload; otherwise the path itself carries the RSC response
+ * for an `Accept: text/x-component` request.
+ */
+function getPayloadUrl(path) {
+    const url = new URL(path, window.location.origin);
+    url.pathname = url.pathname.endsWith('/')
+        ? `${url.pathname}index.rsc.txt`
+        : `${url.pathname}.rsc.txt`;
+    url.search = '';
+    return url;
+}
+function performNavigationFetch(path, init) {
+    return STATIC
+        ? fetch(getPayloadUrl(path), init)
+        : fetch(path, { ...init, headers: { ...init?.headers, accept: 'text/x-component' } });
+}
 export function BrowserRouterProvider({ children, setPayload, isNavigating = false, url, }) {
     const id = useRef(0);
     const controller = useRef(null);
@@ -79,10 +98,7 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
             if (!promise) {
                 const ctrl = new AbortController();
                 controller.current = ctrl;
-                promise = fetch(path, {
-                    headers: { accept: 'text/x-component' },
-                    signal: ctrl.signal,
-                });
+                promise = performNavigationFetch(path, { signal: ctrl.signal });
                 responseCache.set(path, promise);
             }
             if (navigationId !== id.current)
@@ -91,7 +107,11 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
                 promise,
                 createFromFetch(promise),
             ]);
-            const resolvedPath = ResponseCache.toCacheKey(res.url, window.location.origin) ?? path;
+            // on a static host the payload comes from `<path>.rsc.txt`, so the
+            // response URL is not the page path
+            const resolvedPath = STATIC
+                ? path
+                : (ResponseCache.toCacheKey(res.url, window.location.origin) ?? path);
             if (navigationId !== id.current)
                 return resolvedPath;
             if (resolvedPath !== path) {
@@ -136,7 +156,7 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
             return;
         if (responseCache.has(key))
             return;
-        responseCache.set(key, fetch(key, { headers: { Accept: 'text/x-component' } }));
+        responseCache.set(key, performNavigationFetch(key));
     }, []);
     /**
      * Refreshes the current page by re-fetching the RSC response for the current path and updating the

package/dist/internal/postbuild.js

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

package/dist/internal/prerender.d.ts

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

package/dist/internal/prerender.js

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

package/dist/types.d.ts

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

package/package.json

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