@jk2908/solas 0.4.0 → 0.4.2

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.4.2 - 2026-05-22
+
+- Changed `precompress` to default to `false`, so Solas no longer emits precompressed build output unless you opt in.
+- Narrowed precompression to browser-served client assets and full prerendered HTML, so enabling `precompress` no longer writes `.br` files for internal `.solas` support artifacts.
+
+## 0.4.1 - 2026-05-22
+
+- Fixed redirect recovery during prerender and production HTML rendering, so redirecting routes now resolve as redirects instead of failing as generic Server Components render errors.
+- Fixed build-time route export detection to ignore commented-out exports and transpile-only syntax before reading literal values, so stale commented `prerender` exports no longer change prerender mode.
+
 ## 0.4.0 - 2026-05-11
 
 - Added CSRF protection for server actions and `+endpoint` handlers, plus a new `trustedOrigins` config option for tightly scoped cross-origin browser submissions. The checks are proxy-aware and use browser request headers when available.

package/dist/index.js

@@ -16,7 +16,7 @@ import { postbuild } from './internal/postbuild.js';
 import { collect as collectPublicFiles } from './internal/public-files.js';
 import { Solas } from './solas.js';
 const DEFAULT_CONFIG = {
-    precompress: true,
+    precompress: false,
     prerender: false,
     trustedOrigins: [],
     trailingSlash: 'never',

package/dist/internal/env/rsc.js

@@ -9,6 +9,7 @@ import { HttpRouter } from '../http-router/router.js';
 import { normalisePathname } from '../http-router/utils.js';
 import { Metadata } from '../metadata.js';
 import { HttpException, isHttpException, toHttpException, toHttpExceptionLike, } from '../navigation/http-exception.js';
+import { isRedirect, toRedirect } from '../navigation/redirect.js';
 import { Prerender } from '../prerender.js';
 import { Tree } from '../render/tree.js';
 import { Resolver } from '../resolver.js';
@@ -198,23 +199,72 @@ export function createHandler(config, manifest, importMap, runtimeManifest = nul
         const pathname = new URL(req.url).pathname;
         const lookupPath = normalisePathname(pathname, prerenderPathMode);
         const runtimePpr = !import.meta.env.DEV && ppr;
+        async function tryErrorRecovery(err) {
+            if (isRedirect(err)) {
+                const redirect = toRedirect(err);
+                const location = redirect.url.startsWith('/')
+                    ? new URL(BasePath.apply(redirect.url, BASE_PATH), req.url).toString()
+                    : redirect.url;
+                return Response.redirect(location, redirect.status);
+            }
+            if (req[Solas.Config.REQUEST_META_KEY].error || !isHttpException(err)) {
+                return null;
+            }
+            // retry once with the surfaced HttpException attached so createPayload can
+            // rebuild the route through the nearest matching status boundary
+            req[Solas.Config.REQUEST_META_KEY].error = toHttpException(err);
+            try {
+                const { stream: retriedRscStream, status: retriedStatus } = await createPayload(req, manifest, importMap, config.metadata, opts.returnValue, opts.formState, opts.temporaryReferences);
+                const retriedStream = await retriedRscStream;
+                return {
+                    retriedStatus,
+                    retriedStream,
+                };
+            }
+            finally {
+                req[Solas.Config.REQUEST_META_KEY].error = undefined;
+            }
+        }
         // prerender artifact requests bypass the normal document path so the cli
         // gets structured JSON instead of a rendered html response
         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,
-            });
+            try {
+                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,
+                });
+            }
+            catch (err) {
+                const recovered = await tryErrorRecovery(err);
+                if (recovered instanceof Response)
+                    return recovered;
+                if (recovered) {
+                    const artifact = await mod.prerender(recovered.retriedStream, {
+                        formState: opts.formState,
+                        ppr: false,
+                        route: pathname,
+                    });
+                    return new Response(JSON.stringify(artifact), {
+                        headers: {
+                            'Cache-Control': 'private, no-store',
+                            'Content-Type': 'application/json; charset=utf-8',
+                            Vary: 'accept',
+                        },
+                        status: recovered.retriedStatus,
+                    });
+                }
+                throw err;
+            }
         }
         try {
             const artifactEntry = runtimePpr
@@ -260,35 +310,22 @@ export function createHandler(config, manifest, importMap, runtimeManifest = nul
             });
         }
         catch (err) {
-            // resume/ssr can be the first place React surfaces an HttpException from abort(...),
-            // after the initial RSC pass was streamed without request error state. Rerun once
-            // with that error attached so createPayload rebuilds the same route through its
-            // nearest matching HttpExceptionBoundary. If request meta already has an error
-            // or the error is not an HttpException, then this is a real failure
-            if (!req[Solas.Config.REQUEST_META_KEY].error && isHttpException(err)) {
-                // normalise the surfaced digest error before attaching it, since tree/boundary lookup
-                // relies on error.status - the guard above only tells us this came back with an
-                // HttpException digest
-                req[Solas.Config.REQUEST_META_KEY].error = toHttpException(err);
-                try {
-                    const { stream: retriedRscStream, status: retriedStatus } = await createPayload(req, manifest, importMap, config.metadata, opts.returnValue, opts.formState, opts.temporaryReferences);
-                    const retriedStream = await retriedRscStream;
-                    const retriedHtmlStream = await mod.ssr(retriedStream, {
-                        formState: opts.formState,
-                        ppr: false,
-                    });
-                    return new Response(retriedHtmlStream, {
-                        headers: {
-                            'Cache-Control': 'private, no-store',
-                            'Content-Type': 'text/html',
-                            Vary: 'accept',
-                        },
-                        status: retriedStatus,
-                    });
-                }
-                finally {
-                    req[Solas.Config.REQUEST_META_KEY].error = undefined;
-                }
+            const recovered = await tryErrorRecovery(err);
+            if (recovered instanceof Response)
+                return recovered;
+            if (recovered) {
+                const retriedHtmlStream = await mod.ssr(recovered.retriedStream, {
+                    formState: opts.formState,
+                    ppr: false,
+                });
+                return new Response(retriedHtmlStream, {
+                    headers: {
+                        'Cache-Control': 'private, no-store',
+                        'Content-Type': 'text/html',
+                        Vary: 'accept',
+                    },
+                    status: recovered.retriedStatus,
+                });
             }
             throw err;
         }

package/dist/internal/navigation/redirect-boundary.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Component } from 'react';
-import { isRedirect, REDIRECT_DIGEST_PREFIX } from './redirect.js';
+import { isRedirect, toRedirect } from './redirect.js';
 class Boundary extends Component {
     constructor(props) {
         super(props);
@@ -27,15 +27,6 @@ export function RedirectBoundary({ children }) {
     return (_jsx(Boundary, { fallback: err => {
             if (!isRedirect(err))
                 throw err;
-            if ('digest' in err && typeof err.digest === 'string') {
-                // rejoin after status so urls with colons (https://...) stay intact
-                const [type, , ...parts] = err.digest.split(':');
-                if (type === REDIRECT_DIGEST_PREFIX) {
-                    const url = parts.join(':');
-                    if (url)
-                        return _jsx("meta", { httpEquiv: "refresh", content: `0;url=${url}` });
-                }
-            }
-            return null;
+            return _jsx("meta", { httpEquiv: "refresh", content: `0;url=${toRedirect(err).url}` });
         }, children: children }));
 }

package/dist/internal/navigation/redirect.d.ts

@@ -1,4 +1,5 @@
 export type RedirectStatusCode = 301 | 302 | 307 | 308;
+export type RedirectLike = Pick<Error, 'name' | 'message' | 'stack'> & Partial<Pick<Redirect, 'digest' | 'status' | 'url'>>;
 /**
  * Redirect exception class to signal a redirect
  */
@@ -13,6 +14,8 @@ export declare const REDIRECT_DIGEST_PREFIX = "REDIRECT";
  * Check if an error is a Redirect error
  */
 export declare function isRedirect(err: unknown): err is Redirect;
+export declare function toRedirect(err: unknown): Redirect;
+export declare function toRedirectLike(error: Redirect | Error): RedirectLike;
 /**
  * Throws a Redirect exc`eption to signal a redirect
  * @param url - the application-relative URL or absolute http/https URL to redirect to

package/dist/internal/navigation/redirect.js

@@ -1,4 +1,7 @@
 import { Solas } from '../../solas.js';
+function isRedirectStatusCode(value) {
+    return value === 301 || value === 302 || value === 307 || value === 308;
+}
 /**
  * Redirect exception class to signal a redirect
  */
@@ -53,6 +56,54 @@ export function isRedirect(err) {
         typeof err.digest === 'string' &&
         err.digest.startsWith(REDIRECT_DIGEST_PREFIX));
 }
+export function toRedirect(err) {
+    if (err instanceof Redirect)
+        return err;
+    let digestStatus;
+    let digestUrl;
+    if (typeof err === 'object' &&
+        err !== null &&
+        'digest' in err &&
+        typeof err.digest === 'string') {
+        const [type, rawStatus, ...rawUrlParts] = err.digest.split(':');
+        const status = Number(rawStatus);
+        if (type === REDIRECT_DIGEST_PREFIX && isRedirectStatusCode(status)) {
+            digestStatus = status;
+            digestUrl = rawUrlParts.join(':');
+        }
+    }
+    const status = digestStatus ??
+        (typeof err === 'object' &&
+            err !== null &&
+            'status' in err &&
+            isRedirectStatusCode(err.status)
+            ? err.status
+            : 307);
+    const url = digestUrl ||
+        (typeof err === 'object' &&
+            err !== null &&
+            'url' in err &&
+            typeof err.url === 'string'
+            ? err.url
+            : undefined);
+    if (!url) {
+        throw new TypeError(`[${Solas.Config.NAME}] failed to reconstruct redirect`);
+    }
+    return new Redirect(url, status);
+}
+export function toRedirectLike(error) {
+    return {
+        name: error.name,
+        message: error.message,
+        ...('digest' in error && typeof error.digest === 'string'
+            ? { digest: error.digest }
+            : {}),
+        ...('url' in error && typeof error.url === 'string' ? { url: error.url } : {}),
+        ...('status' in error && isRedirectStatusCode(error.status)
+            ? { status: error.status }
+            : {}),
+    };
+}
 /**
  * Throws a Redirect exc`eption to signal a redirect
  * @param url - the application-relative URL or absolute http/https URL to redirect to

package/dist/internal/postbuild.js

@@ -77,17 +77,6 @@ export async function postbuild(cwd = process.cwd()) {
                                 ? ['metadata', 'prelude', 'postponed']
                                 : ['metadata', 'prelude'],
                         };
-                        logger.info('[prerender:artifacts]', JSON.stringify({
-                            route,
-                            prelude: artifact.html,
-                            postponed: artifact.postponed ?? null,
-                            metadata: {
-                                schema: artifact.schema,
-                                route: artifact.route,
-                                createdAt: artifact.createdAt,
-                                mode: artifact.mode,
-                            },
-                        }));
                         logger.info('[prerender]', `${route} (ppr)`);
                         return;
                     }
@@ -137,7 +126,23 @@ export async function postbuild(cwd = process.cwd()) {
     if (manifest.precompress) {
         logger.info('[precompress]', 'compressing assets...');
         for await (const { input, compressed } of Compress.run(outDir, {
-            filter: f => /\.(js|css|html|svg|json|txt)$/.test(f),
+            filter: filePath => {
+                const relativePath = path.relative(outDir, filePath);
+                if (relativePath.length === 0 ||
+                    relativePath.startsWith('..') ||
+                    path.isAbsolute(relativePath)) {
+                    return false;
+                }
+                const normalisedPath = relativePath.split(path.sep).join('/');
+                // only browser-served client/public files benefit from generic precompression
+                if (normalisedPath.startsWith('client/')) {
+                    return /\.(js|css|html|svg|json|txt)$/.test(normalisedPath);
+                }
+                // full prerendered html is served straight from disk, but internal ppr
+                // support files like prelude/metadata/postponed are read by the server
+                return (normalisedPath.startsWith(`${Solas.Config.GENERATED_DIR}/ppr/`) &&
+                    normalisedPath.endsWith(`/${Prerender.Artifact.FULL_PRERENDER_FILENAME}`));
+            },
         })) {
             await Bun.write(`${input}.br`, compressed);
             logger.info('[precompress]', `${path.basename(input)}.br`);

package/dist/utils/export-reader.js

@@ -84,17 +84,23 @@ export class ExportReader {
      * The export must be in the form of `export const|let|var name = <literal>`
      */
     async literal(filePath, name, validate) {
-        const code = await this.raw(filePath);
+        if (!(await this.has(filePath, name)))
+            return;
+        // transpile first so comments and type-only syntax do not confuse the
+        // literal matcher with exports that do not actually exist at runtime
+        const code = this.#getTranspiler(filePath).transformSync(await this.raw(filePath));
         // build the matcher from escaped plain-text pieces so arbitrary export names
         // cannot change the regex shape
         const source = 
-        // match: `export const|let|var `
-        '\\bexport\\s+(?:const|let|var)\\s+' +
+        // match: `export const|let|var ` at statement boundaries
+        '(?:^|[;\\n])\\s*export\\s+(?:const|let|var)\\s+' +
             // treat export name as plain text in regex
             name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
             // capture one supported literal value (string, number, boolean, null)
             '\\s*=\\s*(?<value>(?:"(?:[^"\\\\]|\\\\.)*"|\'(?:[^\'\\\\]|\\\\.)*\'|\\x60(?:[^\\x60\\\\]|\\\\.)*\\x60|true|false|null|-?\\d+(?:\\.\\d+)?))(?=\\s|;|$)';
-        const text = code.match(new RegExp(source))?.groups?.value;
+        // multiline mode lets ^ match the start of each transpiled line, so the
+        // export regex stays anchored to a real statement boundary instead of the file start
+        const text = code.match(new RegExp(source, 'm'))?.groups?.value;
         if (!text)
             return;
         // only support cheap literal parsing here. Anything richer should go through

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jk2908/solas",
-	"version": "0.4.0",
+	"version": "0.4.2",
 	"description": "A Vite + React meta-framework exploring streaming, Server Components, and partial prerendering. Designed for simplicity and lightness",
 	"keywords": [
 		"framework",
@@ -17,7 +17,7 @@
 	"license": "MIT",
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/jk2908/solas.git"
+		"url": "git+https://github.com/jk2908/solas.git"
 	},
 	"files": [
 		"dist",