@jk2908/solas 0.3.7 → 0.3.8

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.3.8 - 2026-04-30
+
+- Improved route module type safety for params, metadata, and static params, and ensured HTTP error boundaries receive route params too.
+- Moved initial route-graph generation to Vite's `buildStart()` hook for more reliable build setup.
+- Exported `HttpExceptionLike` from the public navigation api for typing serialised HTTP-style errors.
+- Improved tree-shaking by keeping HMR-only browser runtime code out of non-HMR builds.
+- Switched build-time export loading to Vite's module loader, so route exports resolve through Vite transforms and aliasing during builds.
+- Fixed `abort(...)` during rendering so surfaced HTTP exceptions again resolve through the nearest matching boundary instead of failing as generic production render errors. This fixes a regression introduced in `0.3.7` when the outer `Suspense` was removed, while keeping that `Suspense` removed.
+
 ## 0.3.7 - 2026-04-25
 
 - Fixed shell rendering so routes without a root `+loading` fallback no longer wrap the entire document in `Suspense`, which removes misplaced `<!--html-->`, `<!--head-->`, and `<!--body-->` markers from streamed HTML.

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { PluginOption } from 'vite';
+import { type PluginOption } from 'vite';
 import type { PluginConfig } from './types.js';
 declare function solas(c: PluginConfig): PluginOption[];
 export default solas;

package/dist/index.js

@@ -1,6 +1,7 @@
 import fsSync from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { createServer, loadConfigFromFile, } from 'vite';
 import rsc from '@vitejs/plugin-rsc';
 import { ExportReader } from './utils/export-reader.js';
 import { Logger } from './utils/logger.js';
@@ -167,11 +168,48 @@ function solas(c) {
         rebuildReason = `${event}: ${path.relative(WATCH_CWD, file)}`;
         queue();
     }, 75);
+    let resolvedViteConfig = null;
+    let utilityServer = null;
+    async function getUtilityServer() {
+        if (utilityServer)
+            return utilityServer;
+        if (!resolvedViteConfig)
+            throw new Error('Vite config not resolved yet');
+        const loaded = await loadConfigFromFile({
+            command: resolvedViteConfig.command,
+            mode: resolvedViteConfig.mode,
+        }, resolvedViteConfig.configFile, resolvedViteConfig.root);
+        const config = loaded?.config ?? {};
+        // recursively flatten and remove any instances of this plugin
+        const plugins = (config.plugins ?? []).flatMap(function flatten(plugin) {
+            if (!plugin)
+                return [];
+            if (Array.isArray(plugin))
+                return plugin.flatMap(flatten);
+            if (typeof plugin === 'object' &&
+                'name' in plugin &&
+                plugin.name === Solas.Config.NAME) {
+                return [];
+            }
+            return [plugin];
+        });
+        utilityServer = await createServer({
+            ...config,
+            configFile: false,
+            root: resolvedViteConfig.root,
+            mode: resolvedViteConfig.mode,
+            server: {
+                ...config.server,
+                middlewareMode: true,
+            },
+            plugins,
+            appType: 'custom',
+        });
+        return utilityServer;
+    }
     const plugin = {
         name: Solas.Config.NAME,
-        enforce: 'pre',
         async config(viteConfig) {
-            await build();
             const pkg = JSON.parse(fsSync.readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
             if (typeof pkg.name !== 'string' || pkg.name.length === 0) {
                 throw new Error(`Missing ${Solas.Config.NAME} package name`);
@@ -210,6 +248,10 @@ function solas(c) {
                     '.solas': path.resolve(process.cwd(), Solas.Config.GENERATED_DIR),
                 };
         },
+        configResolved(resolvedConfig) {
+            resolvedViteConfig = resolvedConfig;
+            buildContext.command = resolvedConfig.command;
+        },
         configureServer(server) {
             logger.info('[configureServer]', `Watching for changes in ./${Solas.Config.APP_DIR}...`);
             server.watcher
@@ -219,9 +261,22 @@ function solas(c) {
                 .on('addDir', (p) => rebuild('addDir', p))
                 .on('unlinkDir', (p) => rebuild('unlinkDir', p));
         },
+        async buildStart() {
+            logger.info('[buildStart]', 'building route graph...');
+            // create and attach server instance for ExportReader.value to use when
+            // loading modules
+            if (buildContext.command === 'build') {
+                const server = await getUtilityServer();
+                buildContext.exportReader.loadModule = server.ssrLoadModule.bind(server);
+            }
+            await build();
+        },
         async closeBundle() {
-            if (process.env.NODE_ENV === 'development')
-                return;
+            if (utilityServer) {
+                const server = utilityServer;
+                utilityServer = null;
+                await server.close();
+            }
             // resolve sitemap routes
             let sitemapRoutes = [];
             if (config.sitemap && config.url) {

package/dist/internal/build.js

@@ -324,7 +324,7 @@ var Build;
                 try {
                     if (!this.buildContext || !this.config)
                         continue;
-                    const { shell: shellPath, layouts: layoutPaths, '401s': unauthorizedPaths, '403s': forbiddenPaths, page: pagePath, '404s': notFoundPaths, '500s': serverErrorPaths, loaders: loaderPaths, middlewares: middlewarePaths, dir, } = segment;
+                    const { shell: shellPath, layouts: layoutPaths, '401s': unauthorisedPaths, '403s': forbiddenPaths, page: pagePath, '404s': notFoundPaths, '500s': serverErrorPaths, loaders: loaderPaths, middlewares: middlewarePaths, dir, } = segment;
                     // derive the route pattern from the directory path, falling
                     // back to a synthetic +page.tsx when this is
                     // a layout-only segment
@@ -347,7 +347,7 @@ var Build;
                     const shellImport = Finder.getImportPath(shellPath);
                     const shellId = `${Build.EntryKind.SHELL}${Bun.hash(shellImport)}`;
                     const layoutIds = [];
-                    const unauthorizedIds = [];
+                    const unauthorisedIds = [];
                     const forbiddenIds = [];
                     const notFoundIds = [];
                     const serverErrorIds = [];
@@ -375,17 +375,17 @@ var Build;
                         applyPrerenderMode(prerenderCache.get(layoutPath));
                         layoutIds.push(layoutId);
                     }
-                    for (const unauthorizedPath of unauthorizedPaths) {
-                        if (!unauthorizedPath) {
-                            unauthorizedIds.push(null);
+                    for (const unauthorisedPath of unauthorisedPaths) {
+                        if (!unauthorisedPath) {
+                            unauthorisedIds.push(null);
                             continue;
                         }
-                        const unauthorizedImport = Finder.getImportPath(unauthorizedPath);
-                        const unauthorizedId = `${Build.EntryKind['401']}${Bun.hash(unauthorizedImport)}`;
-                        unauthorizedIds.push(unauthorizedId);
-                        if (!processed.has(unauthorizedPath)) {
-                            imports.components.dynamic.set(unauthorizedId, unauthorizedImport);
-                            processed.add(unauthorizedPath);
+                        const unauthorisedImport = Finder.getImportPath(unauthorisedPath);
+                        const unauthorisedId = `${Build.EntryKind['401']}${Bun.hash(unauthorisedImport)}`;
+                        unauthorisedIds.push(unauthorisedId);
+                        if (!processed.has(unauthorisedPath)) {
+                            imports.components.dynamic.set(unauthorisedId, unauthorisedImport);
+                            processed.add(unauthorisedPath);
                         }
                     }
                     for (const forbiddenPath of forbiddenPaths) {
@@ -475,7 +475,7 @@ var Build;
                         processed.add(pagePath);
                     }
                     // resolve final prerender mode after shell → layout → page overrides
-                    const shouldPrerender = currentPrerenderMode !== false;
+                    const shouldPrerender = currentPrerenderMode !== false && this.buildContext.command === 'build';
                     const prerenderMode = shouldPrerender
                         ? currentPrerenderMode
                         : false;
@@ -506,7 +506,7 @@ var Build;
                         method: 'get',
                         paths: {
                             layouts: [shellPath, ...layoutPaths].map(layout => layout ? Finder.getImportPath(layout) : null),
-                            '401s': unauthorizedPaths.map(unauthorized => unauthorized ? Finder.getImportPath(unauthorized) : null),
+                            '401s': unauthorisedPaths.map(unauthorised => unauthorised ? Finder.getImportPath(unauthorised) : null),
                             '403s': forbiddenPaths.map(forbidden => forbidden ? Finder.getImportPath(forbidden) : null),
                             '404s': notFoundPaths.map(notFound => notFound ? Finder.getImportPath(notFound) : null),
                             '500s': serverErrorPaths.map(serverError => serverError ? Finder.getImportPath(serverError) : null),
@@ -533,7 +533,7 @@ var Build;
                         shellId,
                         layoutIds,
                         pageId: pagePath ? entryId : undefined,
-                        '401Ids': unauthorizedIds,
+                        '401Ids': unauthorisedIds,
                         '403Ids': forbiddenIds,
                         '404Ids': notFoundIds,
                         '500Ids': serverErrorIds,

package/dist/internal/env/browser.js

@@ -50,13 +50,15 @@ export async function browser() {
     hydrateRoot(document, _jsx(StrictMode, { children: _jsx(A, {}) }), {
         formState: payload.formState,
     });
-    import.meta.hot?.on?.('rsc:update', async () => {
-        try {
-            const p = await createFromFetch(fetch(window.location.href, { headers: { Accept: 'text/x-component' } }));
-            payloadSetter.current(p);
-        }
-        catch (err) {
-            console.error('[hmr] failed to refresh rsc payload', err);
-        }
-    });
+    if (import.meta.hot) {
+        import.meta.hot.on?.('rsc:update', async () => {
+            try {
+                const p = await createFromFetch(fetch(window.location.href, { headers: { Accept: 'text/x-component' } }));
+                payloadSetter.current(p);
+            }
+            catch (err) {
+                console.error('[hmr] failed to refresh rsc payload', err);
+            }
+        });
+    }
 }

package/dist/internal/env/rsc.js

@@ -6,7 +6,7 @@ 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, toHttpExceptionLike, } from '../navigation/http-exception.js';
+import { HttpException, isHttpException, toHttpException, toHttpExceptionLike, } from '../navigation/http-exception.js';
 import { Prerender } from '../prerender.js';
 import { Tree } from '../render/tree.js';
 import { Resolver } from '../resolver.js';
@@ -14,6 +14,7 @@ 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';
+const logger = new Logger();
 /**
  * Create the streamed RSC payload and response metadata for a single request.
  * Resolves the route match, collects metadata, and returns the stream,
@@ -21,7 +22,6 @@ import { getKnownDigest, isKnownError } from './utils.js';
  */
 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';
     const url = new URL(req.url);
     const pathname = url.pathname.endsWith('/') && url.pathname !== '/'
@@ -59,16 +59,7 @@ async function createPayload(req, manifest, importMap, baseMetadata, returnValue
                 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);
-                },
+                onError,
             })),
             status: 404,
             ppr: false,
@@ -78,7 +69,10 @@ async function createPayload(req, manifest, importMap, baseMetadata, returnValue
     const ppr = match.prerender === 'ppr';
     const collection = new Metadata.Collection(baseMetadata);
     const metadata = collection
-        .add(...(match.metadata?.({ params: match.params, error: match.error }) ?? []))
+        .add(...(match.metadata?.({
+        params: match.params,
+        error: match.error,
+    }) ?? []))
         .run();
     const error = match.error ? toHttpExceptionLike(match.error) : undefined;
     const rscPayload = {
@@ -91,35 +85,20 @@ async function createPayload(req, manifest, importMap, baseMetadata, returnValue
             search: url.search,
         },
     };
-    // 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);
-            },
+            onError,
         }));
         return { stream, status, ppr };
     }
     catch (err) {
-        // shell failed to render - return minimal fallback
-        logger.error('rsc shell', err);
+        logger.error('[rsc:render]', err);
         const title = err instanceof Error
             ? 'status' in err
                 ? `${err.status} - ${err.message}`
@@ -211,47 +190,82 @@ export function createHandler(config, manifest, importMap, artifactManifest = nu
                 status,
             });
         }
-        const artifactManifestEntry = runtimePpr
-            ? (artifactManifest?.[lookupPath] ?? null)
-            : null;
-        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: false,
-                });
-                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,
-                });
+        try {
+            const artifactManifestEntry = runtimePpr
+                ? (artifactManifest?.[lookupPath] ?? null)
+                : null;
+            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: false,
+                    });
+                    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,
+            });
+        }
+        catch (err) {
+            // resume/ssr can be the first place react surfaces an http exception 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;
+                }
+            }
+            throw err;
         }
-        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 httpRouter = createHttpRouter(config, manifest, importMap, createResponse);
     // vite-plugin-rsc entrypoint
@@ -295,3 +309,13 @@ export function createHandler(config, manifest, importMap, artifactManifest = nu
         },
     };
 }
+function onError(err) {
+    if (err == null)
+        return;
+    const digest = getKnownDigest(err);
+    if (digest)
+        return digest;
+    if (isKnownError(err))
+        return;
+    logger.error('[rsc]', err);
+}

package/dist/internal/navigation/http-exception.d.ts

@@ -24,6 +24,10 @@ export declare const HTTP_EXCEPTION_DIGEST_PREFIX = "HTTP_EXCEPTION";
  * Check if an error is an HTTPException
  */
 export declare function isHttpException(err: unknown): err is HttpException;
+/**
+ * Convert any error into an HttpException
+ */
+export declare function toHttpException(err: unknown): HttpException;
 /**
  * Convert an HttpException or any Error into a plain object that can be
  * safely serialised

package/dist/internal/navigation/http-exception.js

@@ -23,6 +23,12 @@ export class HttpException extends Error {
     }
 }
 export const HTTP_EXCEPTION_DIGEST_PREFIX = 'HTTP_EXCEPTION';
+/**
+ * Status type predicate
+ */
+function isStatusCode(value) {
+    return value === 401 || value === 403 || value === 404 || value === 500;
+}
 /**
  * Check if an error is an HTTPException
  */
@@ -33,6 +39,41 @@ export function isHttpException(err) {
         typeof err.digest === 'string' &&
         err.digest.startsWith(HTTP_EXCEPTION_DIGEST_PREFIX));
 }
+/**
+ * Convert any error into an HttpException
+ */
+export function toHttpException(err) {
+    if (err instanceof HttpException)
+        return err;
+    let digestStatus;
+    let digestMessage;
+    if (typeof err === 'object' &&
+        err !== null &&
+        'digest' in err &&
+        typeof err.digest === 'string') {
+        const [type, rawStatus, ...rawMessageParts] = err.digest.split(':');
+        const status = Number(rawStatus);
+        if (type === HTTP_EXCEPTION_DIGEST_PREFIX && isStatusCode(status)) {
+            digestStatus = status;
+            digestMessage = rawMessageParts.join(':');
+        }
+    }
+    const status = digestStatus ??
+        (typeof err === 'object' &&
+            err !== null &&
+            'status' in err &&
+            isStatusCode(err.status)
+            ? err.status
+            : 500);
+    const message = digestMessage ||
+        (typeof err === 'object' &&
+            err !== null &&
+            'message' in err &&
+            typeof err.message === 'string'
+            ? err.message
+            : 'Internal Server Error');
+    return new HttpException(status, message, { cause: err });
+}
 /**
  * Convert an HttpException or any Error into a plain object that can be
  * safely serialised
@@ -48,7 +89,7 @@ export function toHttpExceptionLike(error) {
         ...('payload' in error && error.payload !== undefined
             ? { payload: error.payload }
             : {}),
-        ...('status' in error ? { status: error.status } : {}),
+        ...('status' in error && isStatusCode(error.status) ? { status: error.status } : {}),
     };
 }
 /**

package/dist/internal/render/tree.d.ts

@@ -11,9 +11,6 @@ type Match = NonNullable<Resolver.EnhancedMatch>;
  * 2. `Suspense` with that segment's loading fallback
  * 3. `HttpExceptionBoundary` with that segment's status boundaries
  *
- * The shell level is applied last using the same outer wrapper order:
- * `HttpExceptionBoundary` -> `Suspense` -> `Shell`
- *
  * @example
  * ```tsx
  *   <HttpExceptionBoundary shell>

package/dist/internal/render/tree.js

@@ -17,9 +17,6 @@ const SERVER_ERROR = new HttpException(500, 'Internal Server Error');
  * 2. `Suspense` with that segment's loading fallback
  * 3. `HttpExceptionBoundary` with that segment's status boundaries
  *
- * The shell level is applied last using the same outer wrapper order:
- * `HttpExceptionBoundary` -> `Suspense` -> `Shell`
- *
  * @example
  * ```tsx
  *   <HttpExceptionBoundary shell>
@@ -63,7 +60,7 @@ export function Tree({ depth, params, error, ui, }) {
         const Exception = httpExceptionMap[error.status].slice(0, depth + 1).findLast(e => e !== null) ??
             DefaultErr;
         inner = (_jsxs(_Fragment, { children: [
-                _jsx("meta", { name: "robots", content: "noindex,nofollow" }), _jsx(Exception, { error: error })
+                _jsx("meta", { name: "robots", content: "noindex,nofollow" }), _jsx(Exception, { error: error, params: params })
             ] }));
     }
     else if (Page) {
@@ -96,8 +93,6 @@ export function Tree({ depth, params, error, ui, }) {
             inner = (_jsx(HttpExceptionBoundary, { components: errorBoundaries, children: inner }));
         }
     }
-    // now wrap with shell structure: shell renders immediately,
-    // inner streams inside Suspense
     const ShellLoading = loaders[0];
     const ShellUnauthorised = unauthorised[0];
     const ShellForbidden = forbidden[0];

package/dist/internal/resolver.d.ts

@@ -17,18 +17,22 @@ export declare namespace Resolver {
             }> | null;
             '401s': (View<{
                 children?: React.ReactNode;
+                params?: HttpRouter.Params;
                 error?: HttpException;
             }> | null)[];
             '403s': (View<{
                 children?: React.ReactNode;
+                params?: HttpRouter.Params;
                 error?: HttpException;
             }> | null)[];
             '404s': (View<{
                 children?: React.ReactNode;
+                params?: HttpRouter.Params;
                 error?: HttpException;
             }> | null)[];
             '500s': (View<{
                 children?: React.ReactNode;
+                params?: HttpRouter.Params;
                 error?: HttpException;
             }> | null)[];
             loaders: (View<{
@@ -123,18 +127,22 @@ export declare class Resolver {
             }> | null;
             '401s': (View<{
                 children?: import("react").ReactNode;
+                params?: HttpRouter.Params | undefined;
                 error?: HttpException | undefined;
             }> | null)[];
             '403s': (View<{
                 children?: import("react").ReactNode;
+                params?: HttpRouter.Params | undefined;
                 error?: HttpException | undefined;
             }> | null)[];
             '404s': (View<{
                 children?: import("react").ReactNode;
+                params?: HttpRouter.Params | undefined;
                 error?: HttpException | undefined;
             }> | null)[];
             '500s': (View<{
                 children?: import("react").ReactNode;
+                params?: HttpRouter.Params | undefined;
                 error?: HttpException | undefined;
             }> | null)[];
             loaders: (View<{

package/dist/internal/ui/defaults/error.d.ts

@@ -1,4 +1,6 @@
+import type { HttpRouter } from '../../http-router/router.js';
 import type { HttpExceptionLike } from '../../navigation/http-exception.js';
 export default function Err({ error }: {
     error: HttpExceptionLike;
+    params?: HttpRouter.Params;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/internal/ui/defaults/error.js

@@ -1,5 +1,5 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-export default function Err({ error }) {
+export default function Err({ error, }) {
     const title = 'status' in error ? `${error.status} - ${error.message}` : error.message;
     return (_jsxs(_Fragment, { children: [
             _jsx("meta", { name: "robots", content: "noindex,nofollow" }), _jsx("title", { children: title }), _jsx("h1", { children: title }), _jsx("p", { children: error.message }), process.env.NODE_ENV === 'development' && error?.stack && _jsx("pre", { children: error.stack })] }));

package/dist/navigation.d.ts

@@ -1,4 +1,4 @@
 export { HttpExceptionBoundary } from './internal/navigation/http-exception-boundary.js';
-export { HttpException, abort, isHttpException, } from './internal/navigation/http-exception.js';
+export { HttpException, HttpExceptionLike, abort, isHttpException, } from './internal/navigation/http-exception.js';
 export { RedirectBoundary } from './internal/navigation/redirect-boundary.js';
 export { Redirect, isRedirect, redirect } from './internal/navigation/redirect.js';

package/dist/types.d.ts

@@ -36,6 +36,7 @@ export type BuildContext = {
     prerenderRoutes: Set<string>;
     knownRoutes: Set<string>;
     exportReader: ExportReader;
+    command?: 'build' | 'serve';
 };
 export type RequestMeta = {
     error?: HttpException | Error;
@@ -105,8 +106,24 @@ export type BuildManifest = {
     url?: PluginConfig['url'];
 };
 export declare namespace Route {
-    type Metadata = Metadata.Item | ((input: Metadata.Input<BrowserRouter.Params>) => Promise<Metadata.Item> | Metadata.Item);
-    type Prerender = (typeof Solas.Config.PRERENDER_MODES)[number];
+    type ParamsOf<TRoute> = TRoute extends {
+        params?: infer TParams extends BrowserRouter.Params;
+    } ? TParams : never;
+    type ErrorPropsOf<TError> = [TError] extends [never] ? {} : {
+        error?: TError;
+    };
+    export type Params<TRoute> = ParamsOf<TRoute>;
+    export type Metadata<TRoute = {
+        params?: BrowserRouter.Params;
+    }, TError = never> = Metadata.Item | ((input: Metadata.Input<ParamsOf<TRoute>, TError>) => Promise<Metadata.Item> | Metadata.Item);
+    export type StaticParams<TRoute> = [ParamsOf<TRoute>] extends [never] ? never : () => readonly ParamsOf<TRoute>[] | Promise<readonly ParamsOf<TRoute>[]>;
+    export type Props<TRoute, TError = never> = ([ParamsOf<TRoute>] extends [never] ? {
+        params?: never;
+    } : {
+        params: ParamsOf<TRoute>;
+    }) & ErrorPropsOf<TError>;
+    export type Prerender = (typeof Solas.Config.PRERENDER_MODES)[number];
+    export {};
 }
 export type BoundaryError = Error & {
     digest?: string;

package/dist/utils/export-reader.d.ts

@@ -1,5 +1,10 @@
+import type { ViteDevServer } from 'vite';
 export declare class ExportReader {
     #private;
+    /**
+     * Set the Vite server's SSR module loader so we can execute modules
+     */
+    set loadModule(l: ViteDevServer['ssrLoadModule']);
     /**
      * Read the raw text content of a file
      */
@@ -24,6 +29,6 @@ export declare class ExportReader {
     value<T>(filePath: string, name: string, validate?: ExportReader.Validator<T>): Promise<T | undefined>;
 }
 export declare namespace ExportReader {
-    type Loader = 'js' | 'jsx' | 'ts' | 'tsx';
+    type LoaderType = 'js' | 'jsx' | 'ts' | 'tsx';
     type Validator<T> = (value: unknown) => value is T;
 }

package/dist/utils/export-reader.js

@@ -1,10 +1,11 @@
 import path from 'node:path';
 export class ExportReader {
     #transpilers = new Map();
+    #loadModule = null;
     /**
-     * Pick the Bun loader that matches the source file extension
+     * Pick the Bun loader type that matches the source file extension
      */
-    static #getLoader(filePath) {
+    static #getLoaderType(filePath) {
         const ext = path.extname(filePath).toLowerCase();
         if (ext === '.js' || ext === '.mjs' || ext === '.cjs')
             return 'js';
@@ -16,18 +17,6 @@ export class ExportReader {
             return 'tsx';
         throw new Error(`Unsupported module extension: ${ext || '(none)'} in ${filePath}`);
     }
-    /**
-     * Reuse one transpiler per supported loader so scans match the module syntax
-     */
-    #getTranspiler(filePath) {
-        const loader = ExportReader.#getLoader(filePath);
-        const cached = this.#transpilers.get(loader);
-        if (cached)
-            return cached;
-        const transpiler = new Bun.Transpiler({ loader });
-        this.#transpilers.set(loader, transpiler);
-        return transpiler;
-    }
     /**
      * Parse a literal value from a string
      */
@@ -50,6 +39,24 @@ export class ExportReader {
         if (Number.isFinite(n))
             return n;
     }
+    /**
+     * Set the Vite server's SSR module loader so we can execute modules
+     */
+    set loadModule(l) {
+        this.#loadModule = l;
+    }
+    /**
+     * Reuse one transpiler per supported loader so scans match the module syntax
+     */
+    #getTranspiler(filePath) {
+        const type = ExportReader.#getLoaderType(filePath);
+        const cached = this.#transpilers.get(type);
+        if (cached)
+            return cached;
+        const transpiler = new Bun.Transpiler({ loader: type });
+        this.#transpilers.set(type, transpiler);
+        return transpiler;
+    }
     /**
      * Read the raw text content of a file
      */
@@ -107,7 +114,9 @@ export class ExportReader {
         // resolve from the project root so generated/build-time callers can pass the
         // same workspace-relative paths used elsewhere in the route graph
         const abs = path.resolve(process.cwd(), filePath);
-        const mod = (await import(/* @vite-ignore */ abs));
+        const mod = this.#loadModule
+            ? await this.#loadModule(abs)
+            : await import(/* @vite-ignore */ abs);
         const value = mod[name];
         if (value === undefined)
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jk2908/solas",
-	"version": "0.3.7",
+	"version": "0.3.8",
 	"description": "A React Server Components meta-framework powered by Vite",
 	"keywords": [
 		"framework",