@jk2908/solas 0.1.0 → 0.2.0

package/README.md

@@ -72,23 +72,21 @@ All Solas options are passed to `solas()` inside `defineConfig`.
 
 ### `url`
 
-Use `url` to tell Solas what the public application origin is.
+`url` is optional. If you set it, Solas treats it as the public origin for your app.
 
-`url` is optional.
+Solas resolves it in this order:
 
-This happens inside `solas()` when the plugin builds its validated config object. Solas assigns `config.url` with this lookup order:
-
-- `config.url`
+- the `url` option passed to `solas()`
 - `VITE_APP_URL`
-- `APP_URL`
 
 Current behaviour:
 
 - Solas reads that value during plugin configuration.
-- Solas injects `APP_URL` and `VITE_APP_URL` into `import.meta.env`.
-- The current Solas runtime does not otherwise require `config.url` for routing, build, or prerender to work.
+- Solas exposes the resolved value as `import.meta.env.VITE_APP_URL`.
+- If `url` is set, prerender uses it as the request origin for build-time renders.
+- The runtime router does not otherwise require `config.url` for routing to work.
 
-In practice, that means you do not have to pass `url` unless your application code wants a canonical origin value, or you want to standardise that value in config rather than relying on environment variables.
+In practice, you only need `url` if your app code wants to read the public origin from `import.meta.env.VITE_APP_URL`, or if your prerendered output needs a real public origin.
 
 If you do want to set it explicitly, this is the shape:
 
@@ -102,11 +100,7 @@ export default defineConfig(({ mode }) => ({
 }))
 ```
 
-If you prefer environment variables, set one of these instead:
-
-```sh
-APP_URL=https://example.com
-```
+If you prefer an environment variable, set this instead:
 
 ```sh
 VITE_APP_URL=https://example.com
@@ -270,20 +264,77 @@ In that example, the final page title becomes `Routing - Solas`.
 
 ### `trailingSlash`
 
-Use `trailingSlash` when you want generated routes to end with `/`.
+Use `trailingSlash` to set the app-wide URL policy.
 
-Default: `false`
+Default: `never`
+
+- `never`: `/about/` redirects to `/about`
+- `always`: `/about` redirects to `/about/`
+- `ignore`: both forms resolve without a canonical redirect
+
+This is a global setting in `solas()`. Solas does not read `trailingSlash` from route files.
+
+Prerendered output follows the same policy. `always` writes route HTML as `about/index.html`, while `never` and `ignore` write it as `about.html`.
 
 ```ts
 export default defineConfig({
 	plugins: [
 		solas({
-			trailingSlash: true,
+			trailingSlash: 'always',
 		}),
 	],
 })
 ```
 
+### `sitemap`
+
+Use `sitemap` to generate a `sitemap.xml` at build time.
+
+Default: `false`
+
+When enabled, Solas writes a sitemap containing all routes with deterministic URLs: static routes, prerendered routes, and dynamic routes resolved via `params`. The origin for each URL comes from `config.url`.
+
+```ts
+export default defineConfig(({ mode }) => ({
+	plugins: [
+		solas({
+			url: mode === 'production' ? 'https://example.com' : 'http://localhost:8787',
+			sitemap: true,
+		}),
+	],
+}))
+```
+
+Routes with dynamic segments (`[id]`) or catch-all segments (`[...param]`) are only included if they export `params` and `prerender`.
+
+To add routes that Solas cannot discover automatically (for example, catch-all routes backed by a CMS), pass an object with a `routes` function. The function receives the auto-discovered routes and returns the final list:
+
+```ts
+export default defineConfig(({ mode }) => ({
+	plugins: [
+		solas({
+			url: mode === 'production' ? 'https://example.com' : 'http://localhost:8787',
+			sitemap: {
+				async routes(discovered) {
+					const posts = await fetchPostSlugs()
+					return [...discovered, ...posts.map(s => `/blog/${s}`)]
+				},
+			},
+		}),
+	],
+}))
+```
+
+The `routes` function can be async. The callback also lets you filter routes:
+
+```ts
+sitemap: {
+	routes: (r) => r.filter(route => !route.startsWith('/admin')),
+}
+```
+
+The sitemap is written to the build output directory as `sitemap.xml` after prerendering and before precompression.
+
 ### `logger.level`
 
 Use `logger.level` to control internal Solas logging.

package/dist/cli.js

@@ -7,7 +7,14 @@ import { Logger } from './utils/logger';
 import { Prerender } from './internal/prerender';
 const logger = new Logger();
 const DEFAULT_PREVIEW_PORT = 4173;
+/**
+ * The build command does more than just run vite build - it also handles prerendering and
+ * precompressing assets. This is because prerendering needs to run against the built
+ * server entry to ensure the same code paths as preview, and precompressing needs
+ * to include the prerendered html and json files
+ */
 async function build() {
+    // build and prerender should both run in production mode
     process.env.NODE_ENV = 'production';
     const cwd = process.cwd();
     const manifestPath = path.join(cwd, Solas.Config.GENERATED_DIR, 'build.json');
@@ -40,23 +47,24 @@ async function build() {
     // do not keep stale metadata from a previous build
     await fs.rm(artifactRoot, { recursive: true, force: true });
     // prerender routes
-    if (manifest.prerenderedRoutes.length > 0) {
+    if (manifest.prerenderRoutes.length > 0) {
         const timeout = Prerender.Build.getTimeout();
         const concurrency = Prerender.Build.getConcurrency();
+        // track the extra prerender files we write for preview
         const artifactManifestRoutes = {};
-        logger.info('[prerender]', `prerendering ${manifest.prerenderedRoutes.length} routes (timeout: ${timeout}ms, concurrency: ${concurrency})...`);
-        // ensure production mode for React
-        process.env.NODE_ENV = 'production';
+        logger.info('[prerender]', `prerendering ${manifest.prerenderRoutes.length} routes (timeout: ${timeout}ms, concurrency: ${concurrency})...`);
+        // load the built server entry and render each prerendered route through it
         const rscEntry = path.join(rscDir, 'index.js');
         const { default: app } = await import(/* @vite-ignore */ rscEntry);
-        for await (const result of Prerender.Build.run(app, manifest.prerenderedRoutes, {
+        // run prerender through the built app so build output uses the same path as preview
+        for await (const result of Prerender.Build.run(app, manifest.prerenderRoutes, {
             timeout,
             concurrency,
+            origin: manifest.url,
         })) {
             const route = result.route;
             try {
-                const routeDir = route === '/' ? '' : route.replace(/^\//, '');
-                // folder for this route's build notes/files
+                // store prerender metadata for this route under the framework folder
                 const artifactDir = Prerender.Artifact.getPath(outDir, route);
                 if ('error' in result)
                     throw result.error;
@@ -66,7 +74,7 @@ async function build() {
                 }
                 const artifact = result.artifact;
                 if (artifact.mode === 'ppr') {
-                    // for ppr we save the shell now, and the delayed part for later
+                    // for ppr save the shell now and keep the postponed state for later
                     await fs.mkdir(artifactDir, { recursive: true });
                     const writes = [
                         Bun.write(path.join(artifactDir, 'prelude.html'), artifact.html),
@@ -103,7 +111,7 @@ async function build() {
                     continue;
                 }
                 // @todo: hash files
-                // even for full pages, write metadata so preview/runtime knows to serve built html
+                // full prerender still keeps metadata so preview knows to serve saved html
                 await fs.mkdir(artifactDir, { recursive: true });
                 await Bun.write(path.join(artifactDir, 'metadata.json'), JSON.stringify({
                     schema: artifact.schema,
@@ -111,9 +119,29 @@ async function build() {
                     createdAt: artifact.createdAt,
                     mode: artifact.mode,
                 }));
+                const routePath = route.replace(/^\//, '').replace(/\/$/, '');
                 const outPath = route === '/'
                     ? path.join(outDir, 'index.html')
-                    : path.join(outDir, routeDir, 'index.html');
+                    : manifest.trailingSlash === 'always'
+                        ? path.join(outDir, routePath, 'index.html')
+                        : path.join(outDir, `${routePath}.html`);
+                // remove the old file shape for this route so switching trailingSlash mode does not leave
+                // both variants behind. we have to do this before writing the new file so that if the
+                // route shape changes, we still remove the old one instead of leaving in the output
+                const alternateOutPath = route === '/'
+                    ? null
+                    : manifest.trailingSlash === 'always'
+                        ? path.join(outDir, `${routePath}.html`)
+                        : path.join(outDir, routePath, 'index.html');
+                if (alternateOutPath) {
+                    // remove the old file shape so switching trailingSlash mode
+                    // does not leave both variants behind
+                    await Promise.all([
+                        fs.rm(alternateOutPath, { force: true }),
+                        fs.rm(`${alternateOutPath}.br`, { force: true }),
+                    ]);
+                    await fs.rmdir(path.dirname(alternateOutPath)).catch(() => { });
+                }
                 await fs.mkdir(path.dirname(outPath), { recursive: true });
                 await Bun.write(outPath, artifact.html);
                 artifactManifestRoutes[route] = {
@@ -127,15 +155,32 @@ async function build() {
                 logger.error('[prerender]', `failed ${route}: ${err}. This often means unresolved async work (for example external fetches or dynamic rendering in full mode).`);
             }
         }
+        // write one manifest for the saved prerender files after all routes finish
         await fs.mkdir(artifactRoot, { recursive: true });
         await Bun.write(Prerender.Artifact.getManifestPath(outDir), JSON.stringify({
             generatedAt: Date.now(),
             routes: artifactManifestRoutes,
         }));
     }
+    // sitemap
+    if (manifest.sitemapRoutes.length > 0 && manifest.url) {
+        const origin = manifest.url.replace(/\/$/, '');
+        const urls = manifest.sitemapRoutes
+            .map(route => `  <url><loc>${origin}${route}</loc></url>`)
+            .join('\n');
+        const sitemap = [
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+            urls,
+            '</urlset>',
+        ].join('\n');
+        await Bun.write(path.join(outDir, 'sitemap.xml'), sitemap);
+        logger.info('[sitemap]', `generated ${manifest.sitemapRoutes.length} urls`);
+    }
     // precompress
     if (manifest.precompress) {
         logger.info('[precompress]', 'compressing assets...');
+        // compress after prerender so generated html and json are included too
         for await (const { input, compressed } of Compress.run(outDir, {
             filter: f => /\.(js|css|html|svg|json|txt)$/.test(f),
         })) {
@@ -144,6 +189,7 @@ async function build() {
         }
     }
     // cleanup
+    // this file is only needed while the build command is running
     await fs.unlink(manifestPath).catch(() => { });
     logger.info('[build]', 'done');
 }
@@ -158,6 +204,7 @@ async function dev() {
     await proc.exited;
 }
 async function preview() {
+    // preview should behave like production, not like vite dev
     process.env.NODE_ENV = 'production';
     const cwd = process.cwd();
     const outDir = path.resolve(cwd, Solas.Config.OUT_DIR);
@@ -167,11 +214,12 @@ async function preview() {
     const parsedPort = portFlagIndex >= 0 && args[portFlagIndex + 1]
         ? Number(args[portFlagIndex + 1])
         : DEFAULT_PREVIEW_PORT;
+    // fail fast if the port is invalid
     if (!Number.isInteger(parsedPort) || parsedPort <= 0 || parsedPort > 65535) {
         logger.error(`[preview] invalid port: ${args[portFlagIndex + 1] ?? 'undefined'}`);
         process.exit(1);
     }
-    // import RSC server (handles prerendered HTML, static assets, and ssr)
+    // the built server entry handles routing, prerendered html, and ssr here
     try {
         await fs.access(rscEntry);
     }
@@ -181,6 +229,7 @@ async function preview() {
     }
     const { default: app } = await import(/* @vite-ignore */ rscEntry);
     try {
+        // keep the preview server thin and let the app handle requests
         Bun.serve({
             port: parsedPort,
             fetch: app.fetch,
@@ -191,10 +240,10 @@ async function preview() {
         process.exit(1);
     }
     logger.info('[preview]', `server running at http://localhost:${parsedPort}`);
-    // keep alive
+    // keep the process running after the server starts
     await new Promise(() => { });
 }
-// cli entry point
+// read the subcommand once and dispatch below
 const [, , command, ...args] = process.argv;
 switch (command) {
     case 'build':

package/dist/index.js

@@ -15,20 +15,21 @@ import { writeMaps } from './internal/codegen/maps';
 const DEFAULT_CONFIG = {
     precompress: true,
     prerender: false,
-    trailingSlash: false,
+    trailingSlash: 'never',
 };
 function solas(c) {
     const config = Solas.Config.validate({
         ...DEFAULT_CONFIG,
         ...c,
-        url: c.url ?? process.env.VITE_APP_URL?.toString() ?? process.env.APP_URL?.toString(),
+        url: c.url ?? process.env.VITE_APP_URL?.toString(),
     });
     if (config.logger?.level)
         Logger.defaultLevel = config.logger.level;
     const logger = new Logger();
     const exportReader = new ExportReader();
     const buildContext = {
-        prerenderedRoutes: new Set(),
+        prerenderRoutes: new Set(),
+        knownRoutes: new Set(),
         exportReader,
     };
     // cache for file contents to avoid unnecessary readFile invocations
@@ -87,9 +88,9 @@ function solas(c) {
             fs.mkdir(generatedDir, { recursive: true }),
         ]);
         const processor = new Build.Finder(buildContext, config);
-        const { manifest, prerenderedRoutes, imports, modules } = await processor.run();
-        // set prerenderable routes in context for use in closeBundle
-        buildContext.prerenderedRoutes = prerenderedRoutes;
+        const { manifest, prerenderRoutes, knownRoutes, imports, modules } = await processor.run();
+        buildContext.prerenderRoutes = prerenderRoutes;
+        buildContext.knownRoutes = knownRoutes;
         const files = [
             ['config.ts', writeConfig(config)],
             ['manifest.ts', writeManifest(manifest)],
@@ -183,8 +184,7 @@ function solas(c) {
             viteConfig.server ??= {};
             viteConfig.server.port = config.port ?? viteConfig.server.port ?? 8787;
             viteConfig.define ??= {};
-            viteConfig.define['import.meta.env.APP_URL'] = JSON.stringify(process.env.APP_URL);
-            viteConfig.define['import.meta.env.VITE_APP_URL'] = JSON.stringify(process.env.VITE_APP_URL);
+            viteConfig.define['import.meta.env.VITE_APP_URL'] = JSON.stringify(config.url);
             viteConfig.define['import.meta.env.SOLAS_VERSION'] = JSON.stringify(pkg.version);
             viteConfig.resolve ??= {};
             viteConfig.resolve.alias = {
@@ -211,11 +211,25 @@ function solas(c) {
         async closeBundle() {
             if (process.env.NODE_ENV === 'development')
                 return;
+            // resolve sitemap routes
+            let sitemapRoutes = [];
+            if (config.sitemap && config.url) {
+                const auto = [...new Set([...buildContext.knownRoutes, ...buildContext.prerenderRoutes])];
+                if (typeof config.sitemap === 'object' && config.sitemap.routes) {
+                    sitemapRoutes = await config.sitemap.routes(auto);
+                }
+                else {
+                    sitemapRoutes = auto;
+                }
+            }
             // write build manifest
             const generatedDir = path.join(process.cwd(), Solas.Config.GENERATED_DIR);
             await Bun.write(path.join(generatedDir, 'build.json'), JSON.stringify({
-                prerenderedRoutes: Array.from(buildContext.prerenderedRoutes),
+                prerenderRoutes: Array.from(buildContext.prerenderRoutes),
+                sitemapRoutes,
                 precompress: config.precompress,
+                trailingSlash: config.trailingSlash,
+                url: config.url,
             }));
             logger.info('[closeBundle]', 'vite build complete');
         },

package/dist/internal/build.d.ts

@@ -89,7 +89,8 @@ export declare namespace Build {
             manifest: Record<string, (Endpoint | Segment)[] | Endpoint | Segment>;
             imports: Imports;
             modules: Modules;
-            prerenderedRoutes: Set<string>;
+            prerenderRoutes: Set<string>;
+            knownRoutes: Set<string>;
         }>;
         /**
          * Process the scanned route data
@@ -98,7 +99,8 @@ export declare namespace Build {
             manifest: Record<string, (Endpoint | Segment)[] | Endpoint | Segment>;
             imports: Imports;
             modules: Modules;
-            prerenderedRoutes: Set<string>;
+            prerenderRoutes: Set<string>;
+            knownRoutes: Set<string>;
         }>;
     }
 }

package/dist/internal/build.js

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { Solas } from '../solas';
 import { Logger } from '../utils/logger';
+import { normalisePathname } from './router/utils';
 import { Prerender } from './prerender';
 export { Build };
 var Build;
@@ -317,7 +318,9 @@ var Build;
          */
         async process(res) {
             const processed = new Set();
-            const prerenderedRoutes = new Set();
+            const prerenderRoutes = new Set();
+            const knownRoutes = new Set();
+            const trailingSlash = this.config?.trailingSlash ?? 'never';
             const manifest = {};
             // imports for endpoints and components
             const imports = {
@@ -485,15 +488,18 @@ var Build;
                         : false;
                     if (shouldPrerender) {
                         if (!isDynamic && !isWildcard) {
-                            prerenderedRoutes.add(route);
+                            prerenderRoutes.add(normalisePathname(route, trailingSlash));
                         }
                         else if (pagePath) {
                             const staticParams = await Prerender.Build.getStaticParams(pagePath, this.buildContext);
                             for (const r of Prerender.Build.getDynamicRouteList(route, params, staticParams)) {
-                                prerenderedRoutes.add(r);
+                                prerenderRoutes.add(normalisePathname(r, trailingSlash));
                             }
                         }
                     }
+                    if (!isDynamic && !isWildcard) {
+                        knownRoutes.add(normalisePathname(route, trailingSlash));
+                    }
                     const entry = {
                         __id: entryId,
                         __path: route,
@@ -626,7 +632,7 @@ var Build;
                     logger.error('[Build:Finder:process]: failed to process route', err);
                 }
             }
-            return { manifest, imports, modules, prerenderedRoutes };
+            return { manifest, imports, modules, prerenderRoutes, knownRoutes };
         }
     }
     Build.Finder = Finder;

package/dist/internal/env/rsc.js

@@ -1,7 +1,9 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import path from 'node:path';
 import { createTemporaryReferenceSet, decodeAction, decodeFormState, decodeReply, loadServerAction, renderToReadableStream, } from '@vitejs/plugin-rsc/rsc';
 import { Solas } from '../../solas';
 import { Logger } from '../../utils/logger';
+import { normalisePathname } from '../router/utils';
 import { getKnownDigest, isKnownError } from './utils';
 import { Metadata } from '../metadata';
 import { HttpException, isHttpException } from '../navigation/http-exception';
@@ -214,10 +216,11 @@ export async function maybeActionWithParsedFormData(req) {
  * with a fetch method that handles requests
  */
 export function createHandler(config, manifest, importMap) {
+    const prerenderPathMode = config.trailingSlash === 'always' ? 'always' : 'never';
     const fullyPrerenderedRoutes = new Set(Object.values(manifest)
         .flat()
         .filter(entry => 'prerender' in entry && String(entry.prerender) === 'full')
-        .map(entry => entry.__path));
+        .map(entry => normalisePathname(entry.__path, prerenderPathMode)));
     /**
      * Create the HTTP response for a single incoming request. Runs actions when needed,
      * converts the payload into component, HTML, or prerender artifact responses, and
@@ -245,6 +248,7 @@ export function createHandler(config, manifest, importMap) {
         }
         const mod = await import.meta.viteRsc.loadModule('ssr', 'index');
         const pathname = new URL(req.url).pathname;
+        const lookupPath = normalisePathname(pathname, prerenderPathMode);
         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
@@ -267,20 +271,20 @@ export function createHandler(config, manifest, importMap) {
         const artifactManifest = runtimePpr
             ? await Prerender.Artifact.loadManifest(Solas.Config.OUT_DIR)
             : null;
-        const artifactManifestEntry = artifactManifest?.routes[pathname] ?? null;
+        const artifactManifestEntry = artifactManifest?.routes[lookupPath] ?? null;
         let tryPrelude = false;
         if (artifactManifestEntry) {
             tryPrelude = artifactManifestEntry.mode === 'ppr';
         }
         else if (runtimePpr) {
-            const artifactMetadata = await Prerender.Artifact.loadMetadata(Solas.Config.OUT_DIR, pathname);
+            const artifactMetadata = await Prerender.Artifact.loadMetadata(Solas.Config.OUT_DIR, lookupPath);
             tryPrelude =
                 !!artifactMetadata &&
-                    Prerender.Artifact.isCompatible(artifactMetadata, pathname, 'ppr');
+                    Prerender.Artifact.isCompatible(artifactMetadata, lookupPath, '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);
+            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) {
@@ -319,37 +323,45 @@ export function createHandler(config, manifest, importMap) {
         async fetch(req) {
             const url = new URL(req.url);
             const accept = req.headers.get('accept') ?? '';
+            const method = req.method.toUpperCase();
+            const canonicalPath = config.trailingSlash === 'ignore'
+                ? url.pathname
+                : normalisePathname(url.pathname, config.trailingSlash);
+            if ((method === 'GET' || method === 'HEAD') &&
+                config.trailingSlash !== 'ignore' &&
+                canonicalPath !== url.pathname) {
+                url.pathname = canonicalPath;
+                return Response.redirect(url.toString(), 308);
+            }
             // 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;
+                const pathname = canonicalPath;
+                const lookupPath = normalisePathname(pathname, prerenderPathMode);
+                const routePath = lookupPath.replace(/^\//, '').replace(/\/$/, '');
                 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';
+                const artifactManifestEntry = artifactManifest?.routes[lookupPath] ?? null;
+                const fullHtmlPath = lookupPath === '/'
+                    ? path.join(Solas.Config.OUT_DIR, 'index.html')
+                    : config.trailingSlash === 'always'
+                        ? path.join(Solas.Config.OUT_DIR, routePath, 'index.html')
+                        : path.join(Solas.Config.OUT_DIR, `${routePath}.html`);
+                if (fullyPrerenderedRoutes.has(lookupPath)) {
+                    prerenderPath = fullHtmlPath;
                 }
                 else if (artifactManifestEntry) {
                     if (artifactManifestEntry.mode === 'full') {
-                        prerenderPath =
-                            pathname === '/'
-                                ? Solas.Config.OUT_DIR + '/index.html'
-                                : Solas.Config.OUT_DIR + pathname + '/index.html';
+                        prerenderPath = fullHtmlPath;
                     }
                 }
                 else {
-                    const artifactMetadata = await Prerender.Artifact.loadMetadata(Solas.Config.OUT_DIR, pathname);
+                    const artifactMetadata = await Prerender.Artifact.loadMetadata(Solas.Config.OUT_DIR, lookupPath);
                     if (artifactMetadata &&
-                        Prerender.Artifact.isCompatible(artifactMetadata, pathname, 'full')) {
-                        prerenderPath =
-                            pathname === '/'
-                                ? Solas.Config.OUT_DIR + '/index.html'
-                                : Solas.Config.OUT_DIR + pathname + '/index.html';
+                        Prerender.Artifact.isCompatible(artifactMetadata, lookupPath, 'full')) {
+                        prerenderPath = fullHtmlPath;
                     }
                 }
                 if (prerenderPath) {

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

@@ -27,9 +27,9 @@ export function HttpExceptionBoundary({ components, children, }) {
             if (!isHttpException(err))
                 throw err;
             if ('digest' in err && typeof err.digest === 'string') {
-                const [type, ...rest] = err.digest.split(':');
+                // split with care, the message part may contain colons
+                const [type, code] = err.digest.split(':');
                 if (type === HTTP_EXCEPTION_DIGEST_PREFIX) {
-                    const [code] = rest;
                     const status = Number(code);
                     if (!isSupportedStatusCode(status))
                         throw err;

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

@@ -5,7 +5,7 @@ type Props = {
 /**
  * A link component that navigates to a given href
  * @param href - the href to navigate to
- * @param prefetch - when to prefetch the linked page, defaults to 'intent'
+ * @param prefetch - when to prefetch the linked page, defaults to 'none'
  * @param rest - other props to pass to the underlying anchor element
  * @returns a link element that navigates to the given href
  */

package/dist/internal/navigation/link.js

@@ -1,17 +1,32 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useRef } from 'react';
+import { useEffect, useRef } from 'react';
 import { useRouter } from '../router/use-router';
+function guard(path, prefetcher) {
+    const connection = window.navigator.connection;
+    if (document.visibilityState === 'hidden')
+        return;
+    if (connection?.saveData)
+        return;
+    if (['2g', 'slow-2g'].includes(connection?.effectiveType ?? ''))
+        return;
+    prefetcher(path);
+}
 /**
  * A link component that navigates to a given href
  * @param href - the href to navigate to
- * @param prefetch - when to prefetch the linked page, defaults to 'intent'
+ * @param prefetch - when to prefetch the linked page, defaults to 'none'
  * @param rest - other props to pass to the underlying anchor element
  * @returns a link element that navigates to the given href
  */
-export function Link({ children, href, prefetch = 'intent', ...rest }) {
+export function Link({ children, href, prefetch = 'none', ...rest }) {
     const { go, prefetch: prefetcher } = useRouter();
     const timer = useRef(null);
+    // clear any pending hover-prefetch timer on unmount
+    useEffect(() => () => {
+        if (timer.current)
+            clearTimeout(timer.current);
+    }, []);
     return (_jsx("a", { ...rest, href: href, onClick: e => {
             rest.onClick?.(e);
             if (e.defaultPrevented)
@@ -36,14 +51,14 @@ export function Link({ children, href, prefetch = 'intent', ...rest }) {
                 return;
             if (prefetch !== 'intent')
                 return;
-            prefetcher(href);
+            guard(href, prefetcher);
         }, onTouchStart: e => {
             rest.onTouchStart?.(e);
             if (e.defaultPrevented)
                 return;
             if (prefetch !== 'intent')
                 return;
-            prefetcher(href);
+            guard(href, prefetcher);
         }, onMouseEnter: e => {
             rest.onMouseEnter?.(e);
             if (e.defaultPrevented)
@@ -51,7 +66,7 @@ export function Link({ children, href, prefetch = 'intent', ...rest }) {
             if (prefetch !== 'hover')
                 return;
             timer.current = setTimeout(() => {
-                prefetcher(href);
+                guard(href, prefetcher);
             }, 100);
         }, onMouseLeave: e => {
             rest.onMouseLeave?.(e);

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

@@ -28,10 +28,12 @@ export function RedirectBoundary({ children }) {
             if (!isRedirect(err))
                 throw err;
             if ('digest' in err && typeof err.digest === 'string') {
-                const [type, ...rest] = err.digest.split(':');
+                // rejoin after status so urls with colons (https://...) stay intact
+                const [type, , ...parts] = err.digest.split(':');
                 if (type === REDIRECT_DIGEST_PREFIX) {
-                    const [, url] = rest;
-                    return _jsx("meta", { httpEquiv: "refresh", content: `0;url=${url}` });
+                    const url = parts.join(':');
+                    if (url)
+                        return _jsx("meta", { httpEquiv: "refresh", content: `0;url=${url}` });
                 }
             }
             return null;

package/dist/internal/navigation/redirect.js

@@ -7,6 +7,7 @@ export class Redirect extends Error {
     status;
     digest;
     constructor(url, status = 307) {
+        validate(url);
         super(`Redirecting to ${url} with status ${status}`);
         this.url = url;
         this.status = status;
@@ -58,6 +59,5 @@ export function isRedirect(err) {
  * @param status - the HTTP status code for the redirect, defaults to 307
  */
 export function redirect(url, status = 307) {
-    validate(url);
     throw new Redirect(url, status);
 }

package/dist/internal/prerender.js

@@ -3,7 +3,7 @@ import { compile } from 'path-to-regexp';
 import { Solas } from '../solas';
 import { Logger } from '../utils/logger';
 import { Time } from '../utils/time';
-import { toPathPattern } from './router/pattern';
+import { toPathPattern } from './router/utils';
 const logger = new Logger();
 export { Prerender };
 var Prerender;
@@ -211,20 +211,22 @@ var Prerender;
                 artifactMetadata.mode === mode);
         }
         Artifact.isCompatible = isCompatible;
+        // shared instances, both are stateless so one per module is fine
+        const encoder = new TextEncoder();
+        const decoder = new TextDecoder();
         /**
          * Compose the prelude HTML and the resume stream into a single HTML stream, by injecting the resume stream
          * into the prelude at the appropriate location (before </body> or </html>)
          */
         function composePreludeAndResume(prelude, resumeStream) {
-            const lower = prelude.toLowerCase();
-            const bodyClose = lower.lastIndexOf('</body>');
-            const htmlClose = lower.lastIndexOf('</html>');
-            const splitAt = bodyClose >= 0 && htmlClose > bodyClose ? bodyClose : prelude.length;
+            // search both cases to avoid duplicating the full string with toLowerCase
+            const bodyClose = Math.max(prelude.lastIndexOf('</body>'), prelude.lastIndexOf('</BODY>'));
+            const htmlClose = Math.max(prelude.lastIndexOf('</html>'), prelude.lastIndexOf('</HTML>'));
+            const splitAt = bodyClose >= 0 ? bodyClose : htmlClose >= 0 ? htmlClose : prelude.length;
             return new ReadableStream({
                 async start(controller) {
-                    const encoder = new TextEncoder();
-                    const decoder = new TextDecoder();
-                    controller.enqueue(new TextEncoder().encode(prelude.slice(0, splitAt)));
+                    // send everything before the closing tags so the resume stream can be injected
+                    controller.enqueue(encoder.encode(prelude.slice(0, splitAt)));
                     const reader = resumeStream.getReader();
                     let strippedLeadingClose = false;
                     try {

package/dist/internal/router/prefetcher.js

@@ -12,7 +12,8 @@ export class Prefetcher {
      */
     static key(path, base) {
         const url = new URL(path, base);
-        return url.pathname + url.search + url.hash;
+        // hash is client-only and never sent to the server, so exclude it
+        return url.pathname + url.search;
     }
     /**
      * Evicts the oldest entry from the cache

package/dist/internal/router/resolver.js

@@ -47,6 +47,21 @@ export class Resolver {
         }
         return 200;
     }
+    /**
+     * Find a manifest entry by path, trying both with and without a trailing slash
+     */
+    static #getEntryByPath(manifest, path) {
+        const direct = manifest[path];
+        if (direct)
+            return direct;
+        if (path !== '/' && path.endsWith('/')) {
+            return manifest[path.slice(0, -1)];
+        }
+        return manifest[`${path}/`];
+    }
+    /**
+     * Merge the cached enhanced match with the params and error from this request's match
+     */
     static #withRequestState(cached, match) {
         // the cached match only stores route structure, while params and errors
         // still belong to this request so merge them back in here
@@ -111,7 +126,7 @@ export class Resolver {
      */
     reconcile(path, match, error) {
         if (match) {
-            const entry = Resolver.narrow(this.#manifest[match.route.path]);
+            const entry = Resolver.narrow(Resolver.#getEntryByPath(this.#manifest, match.route.path));
             if (entry) {
                 // normal case, the router matched a page route so just attach request state
                 return {

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

@@ -54,21 +54,31 @@ export function RouterProvider({ children, setPayload, isNavigating = false, })
             // and return early
             if (navigationId !== id.current)
                 return path;
-            const res = await createFromFetch(promise);
+            // we need both the parsed payload and the final response url because
+            // redirects can change the canonical path we should store in history
+            const [res, payload] = await Promise.all([
+                promise,
+                createFromFetch(promise),
+            ]);
+            // use the final response url so client history matches server redirects
+            const resolvedPath = Prefetcher.key(res.url, window.location.origin);
             // check again if another navigation has started while we were awaiting
             // the response
             if (navigationId !== id.current)
-                return path;
+                return resolvedPath;
             // this state update is already wrapped in a
             // transition before being passed as props
-            setPayload?.(res);
+            setPayload?.(payload);
             if (replace) {
-                window.history.replaceState(null, '', path);
+                window.history.replaceState(null, '', resolvedPath);
             }
             else {
-                window.history.pushState(null, '', path);
+                window.history.pushState(null, '', resolvedPath);
             }
-            window.dispatchEvent(new CustomEvent(Solas.Events.names.NAVIGATION, { detail: { path } }));
+            window.dispatchEvent(new CustomEvent(Solas.Events.names.NAVIGATION, {
+                detail: { path: resolvedPath },
+            }));
+            return resolvedPath;
         }
         catch (err) {
             if (err instanceof Error && err.name === 'AbortError') {
@@ -96,18 +106,10 @@ export function RouterProvider({ children, setPayload, isNavigating = false, })
         return path;
     }, [setPayload]);
     /**
-     * Prefetch a route's assets by fetching the RSC payload
+     * Prefetch a route's RSC payload
      * @param path the route path to prefetch (absolute or relative to origin)
-     * @returns void
      */
     const prefetch = useCallback((path) => {
-        const connection = window.navigator.connection;
-        if (document.visibilityState === 'hidden')
-            return;
-        if (connection?.saveData)
-            return;
-        if (['2g', 'slow-2g'].includes(connection?.effectiveType ?? ''))
-            return;
         const key = Prefetcher.key(path, window.location.origin);
         if (prefetcher.has(key))
             return;

package/dist/internal/router/router.d.ts

@@ -23,7 +23,7 @@ export declare namespace Router {
         params: Params;
     };
     type Options = {
-        trailingSlash?: boolean;
+        trailingSlash?: NonNullable<PluginConfig['trailingSlash']>;
     };
     type Registry = {
         static: Map<string, Route>;

package/dist/internal/router/router.js

@@ -1,9 +1,9 @@
 import path from 'node:path';
 import { match as createMatch } from 'path-to-regexp';
 import { Solas } from '../../solas';
+import { getAlternatePathname, normalisePathname, toPathPattern } from './utils';
 import { maybeActionWithParsedFormData } from '../env/rsc';
 import { HttpException } from '../navigation/http-exception';
-import { toPathPattern } from './pattern';
 /**
  * Handle routing and matching for server requests
  */
@@ -49,7 +49,12 @@ export class Router {
      * Register a route handler
      */
     add(path, method, handler, params, middleware = []) {
-        const segments = Router.#split(path);
+        // normalise static routes up front so trailingSlash matching
+        // uses the same pathname shape
+        const routePath = !path.includes(':') && !path.includes('*')
+            ? normalisePathname(path, this.opts.trailingSlash ?? 'never')
+            : path;
+        const segments = Router.#split(routePath);
         const tokens = [];
         let score = 0;
         let wildcard = false;
@@ -70,7 +75,7 @@ export class Router {
             score += 2;
         }
         const route = {
-            path,
+            path: routePath,
             method: method.toUpperCase(),
             handler,
             middleware: [...middleware],
@@ -81,7 +86,7 @@ export class Router {
         };
         // static route, easy map set
         if (!path.includes(':') && !path.includes('*')) {
-            this.#routes.static.set(`${route.method}:${path}`, route);
+            this.#routes.static.set(`${route.method}:${route.path}`, route);
             return this;
         }
         // wildcard route, push to end of list
@@ -117,15 +122,15 @@ export class Router {
      * Match a path and method, returning params and route
      */
     match(path, method) {
-        const direct = this.#routes.static.get(`${method}:${path}`);
-        // direct match - quick return
-        if (direct)
-            return { route: direct, params: {} };
-        // HEAD falls back to GET when HEAD is not explicitly defined
-        if (method === 'HEAD') {
-            const directGet = this.#routes.static.get(`GET:${path}`);
-            if (directGet)
-                return { route: directGet, params: {} };
+        for (const candidate of Router.#candidates(path)) {
+            const direct = this.#routes.static.get(`${method}:${candidate}`);
+            if (direct)
+                return { route: direct, params: {} };
+            if (method === 'HEAD') {
+                const directGet = this.#routes.static.get(`GET:${candidate}`);
+                if (directGet)
+                    return { route: directGet, params: {} };
+            }
         }
         // else dynamic/wildcard match
         const segments = Router.#split(path);
@@ -157,10 +162,18 @@ export class Router {
      */
     async fetch(req) {
         const url = new URL(req.url);
-        const path = Router.#normalise(url.pathname, this.opts.trailingSlash);
+        const trailingSlash = this.opts.trailingSlash ?? 'never';
+        const path = trailingSlash === 'ignore'
+            ? url.pathname
+            : normalisePathname(url.pathname, trailingSlash);
         let match = null;
         let action = false;
         try {
+            const method = req.method.toUpperCase();
+            if ((method === 'GET' || method === 'HEAD') && path !== url.pathname) {
+                url.pathname = path;
+                return Response.redirect(url.toString(), 308);
+            }
             if (path !== url.pathname) {
                 // rebuild the request with the canonical pathname so downstream code
                 // sees the same url the router matched against
@@ -169,7 +182,6 @@ export class Router {
             }
             const { action: isAction, formData: parsedFormData } = await maybeActionWithParsedFormData(req);
             action = isAction;
-            const method = req.method.toUpperCase();
             // action requests stay on the same pathname only the method is
             // normalised to GET this lets page/layout routes match for
             // rerender action execution still reads POST body and
@@ -218,7 +230,17 @@ export class Router {
         for (let i = stack.length - 1; i >= 0; i -= 1) {
             const handler = stack[i];
             const prev = run;
-            run = () => Promise.resolve(handler(req, prev));
+            run = () => {
+                let called = false;
+                return Promise.resolve(handler(req, () => {
+                    // guard against double invocation so handlers/inner middleware
+                    // only execute once per request
+                    if (called)
+                        throw new Error('next() called more than once');
+                    called = true;
+                    return prev();
+                }));
+            };
         }
         // run composed middleware stack
         return run();
@@ -292,15 +314,10 @@ export class Router {
     /**
      * Normalise a path based on router options
      */
-    static #normalise(path, trailingSlash = true) {
-        if (!trailingSlash) {
-            // collapse non-root trailing slashes when the router runs in slashless mode
-            return path.endsWith('/') && path !== '/' ? path.slice(0, -1) : path;
-        }
+    static #candidates(path) {
         if (path === '/')
-            return path;
-        // otherwise make non-root paths canonical with a trailing slash
-        return path.endsWith('/') ? path : `${path}/`;
+            return ['/'];
+        return [path, getAlternatePathname(path)];
     }
     /**
      * Split a path into segments

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

@@ -0,0 +1,21 @@
+import type { Route } from '../../types';
+export type PathPattern = {
+    path: string;
+    wildcardNames: Set<string>;
+};
+/**
+ * Convert an internal route string into a path-to-regexp pattern and collect
+ * the wildcard param names used in that pattern
+ */
+export declare function toPathPattern(route: string, paramNames?: string[]): {
+    path: string;
+    wildcardNames: Set<string>;
+};
+/**
+ * Apply the configured trailing-slash policy to a pathname
+ */
+export declare function normalisePathname(pathname: string, trailingSlash?: Route.TrailingSlash): string;
+/**
+ * Return the other pathname shape for a non-root route
+ */
+export declare function getAlternatePathname(pathname: string): string;

package/dist/internal/router/utils.js

@@ -0,0 +1,62 @@
+/**
+ * Escape a literal path segment so it can be used safely in a
+ * path-to-regexp pattern
+ */
+function escapePathSegment(value) {
+    return value.replace(/[\\.+*?^${}()[\]|!:]/g, '\\$&');
+}
+/**
+ * Convert an internal route string into a path-to-regexp pattern and collect
+ * the wildcard param names used in that pattern
+ */
+export function toPathPattern(route, paramNames = []) {
+    if (route === '/') {
+        return { path: route, wildcardNames: new Set() };
+    }
+    let paramIndex = 0;
+    let wildcardIndex = 0;
+    const wildcardNames = new Set();
+    const path = route
+        .split('/')
+        .filter(Boolean)
+        .map(segment => {
+        if (segment.startsWith(':')) {
+            paramIndex += 1;
+            return `/${segment}`;
+        }
+        if (segment === '*') {
+            // reuse the discovered param name when we have one so wildcard params
+            // line up with the generated route pattern
+            const value = paramNames[paramIndex];
+            const name = value && value !== '*' ? value : `wildcard${wildcardIndex}`;
+            paramIndex += 1;
+            wildcardIndex += 1;
+            wildcardNames.add(name);
+            return `/*${name}`;
+        }
+        return `/${escapePathSegment(segment)}`;
+    })
+        .join('');
+    return { path: path || '/', wildcardNames };
+}
+/**
+ * Apply the configured trailing-slash policy to a pathname
+ */
+export function normalisePathname(pathname, trailingSlash = 'never') {
+    if (pathname === '/')
+        return pathname;
+    // ignore mode keeps the incoming pathname shape as-is
+    if (trailingSlash === 'ignore')
+        return pathname;
+    if (trailingSlash === 'always')
+        return pathname.endsWith('/') ? pathname : `${pathname}/`;
+    return pathname.endsWith('/') ? pathname.slice(0, -1) : pathname;
+}
+/**
+ * Return the other pathname shape for a non-root route
+ */
+export function getAlternatePathname(pathname) {
+    if (pathname === '/')
+        return pathname;
+    return pathname.endsWith('/') ? pathname.slice(0, -1) : `${pathname}/`;
+}

package/dist/internal/server/url.js

@@ -7,10 +7,11 @@ import { dynamic } from './dynamic';
 export function url() {
     dynamic();
     const { req, cache } = RequestContext.use();
-    // use request cache if possible
+    // always return a clone so consumers can mutate (e.g. searchParams.set)
+    // without corrupting the cached instance shared across the request
     if (cache.url)
-        return cache.url;
+        return new URL(cache.url);
     const parsed = new URL(req.url);
     cache.url = parsed;
-    return parsed;
+    return new URL(parsed);
 }

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

@@ -2,5 +2,5 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 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 }), error?.stack && _jsx("pre", { children: error.stack })] }));
+            _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/solas.d.ts

@@ -15,6 +15,7 @@ export declare namespace Solas {
         const REQUEST_META: string;
         const LOG_LEVELS: readonly ["debug", "info", "warn", "error", "fatal"];
         const PRERENDER_MODES: readonly ["full", "ppr", false];
+        const TRAILING_SLASH_MODES: readonly ["always", "never", "ignore"];
         /**
          * Validate the plugin configuration object, throwing an error if invalid
          * @param input - the unvalidated configuration object

package/dist/solas.js

@@ -17,11 +17,13 @@ var Solas;
         Config.REQUEST_META = `__${Config.SLUG.toUpperCase()}__`;
         Config.LOG_LEVELS = ['debug', 'info', 'warn', 'error', 'fatal'];
         Config.PRERENDER_MODES = ['full', 'ppr', false];
+        Config.TRAILING_SLASH_MODES = ['always', 'never', 'ignore'];
         const CONFIG_KEYS = new Set([
             'logger',
             'metadata',
             'precompress',
             'prerender',
+            'sitemap',
             'trailingSlash',
             'url',
         ]);
@@ -64,14 +66,28 @@ var Solas;
                     errors.push('config.precompress must be a boolean');
                 }
             }
+            if ('sitemap' in input && input.sitemap !== undefined && input.sitemap !== false) {
+                if (typeof input.sitemap !== 'boolean' && typeof input.sitemap !== 'object') {
+                    errors.push('config.sitemap must be a boolean or an object with a routes function');
+                }
+                if (typeof input.sitemap === 'object' &&
+                    input.sitemap !== null &&
+                    typeof input.sitemap.routes !== 'function') {
+                    errors.push('config.sitemap.routes must be a function');
+                }
+                if (!input.url) {
+                    errors.push('config.url is required when sitemap is enabled');
+                }
+            }
             if ('prerender' in input && input.prerender !== undefined) {
                 if (!new Set(Config.PRERENDER_MODES).has(input.prerender)) {
                     errors.push("config.prerender must be 'full', 'ppr', or false");
                 }
             }
             if ('trailingSlash' in input && input.trailingSlash !== undefined) {
-                if (typeof input.trailingSlash !== 'boolean') {
-                    errors.push('config.trailingSlash must be a boolean');
+                if (typeof input.trailingSlash !== 'string' ||
+                    !new Set(Config.TRAILING_SLASH_MODES).has(input.trailingSlash)) {
+                    errors.push("config.trailingSlash must be 'always', 'never', or 'ignore'");
                 }
             }
             if ('metadata' in input &&

package/dist/types.d.ts

@@ -8,23 +8,32 @@ import type { Metadata } from './internal/metadata';
 import type { HttpException } from './internal/navigation/http-exception';
 import type { Router } from './internal/router/router';
 export type LogLevel = (typeof Solas.Config.LOG_LEVELS)[number];
-export type PluginConfig = {
-    url?: `http://${string}` | `https://${string}`;
+type PluginConfigBase = {
     port?: number;
     precompress?: boolean;
     prerender?: Route.Prerender;
     metadata?: Metadata.Item;
-    trailingSlash?: boolean;
+    trailingSlash?: Route.TrailingSlash;
     readonly logger?: {
         level?: LogLevel;
     };
 };
+export type PluginConfig = PluginConfigBase & ({
+    url: `http://${string}` | `https://${string}`;
+    sitemap: true | {
+        routes: (existing: string[]) => string[] | Promise<string[]>;
+    };
+} | {
+    url?: `http://${string}` | `https://${string}`;
+    sitemap?: false;
+});
 export type RuntimeConfig = PluginConfig & {
     precompress: NonNullable<PluginConfig['precompress']>;
     trailingSlash: NonNullable<PluginConfig['trailingSlash']>;
 };
 export type BuildContext = {
-    prerenderedRoutes: Set<string>;
+    prerenderRoutes: Set<string>;
+    knownRoutes: Set<string>;
     exportReader: ExportReader;
 };
 export type SolasRequest = Request & {};
@@ -80,12 +89,16 @@ export type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' |
 export type Primitive = string | number | boolean | bigint | symbol | null | undefined;
 export type LooseNumber<T extends number> = T | (number & {});
 export type BuildManifest = {
-    prerenderedRoutes: string[];
+    prerenderRoutes: string[];
+    sitemapRoutes: string[];
     precompress: boolean;
+    trailingSlash: Route.TrailingSlash;
+    url?: PluginConfig['url'];
 };
 export declare namespace Route {
     type Metadata = Metadata.Item | ((input: Metadata.Input<Router.Params>) => Promise<Metadata.Item> | Metadata.Item);
     type Prerender = (typeof Solas.Config.PRERENDER_MODES)[number];
+    type TrailingSlash = (typeof Solas.Config.TRAILING_SLASH_MODES)[number];
 }
 export type BoundaryError = Error & {
     digest?: string;

package/dist/utils/logger.js

@@ -35,8 +35,17 @@ export class Logger {
         if (err instanceof Error || err instanceof HttpException) {
             return err.message + (err.stack ? `\n${err.stack}` : '');
         }
+        // for plain objects, attempt to stringify with indentation
+        // for readability
         if (typeof err === 'object' && err !== null) {
-            return JSON.stringify(err, null, 2);
+            try {
+                return JSON.stringify(err, null, 2);
+            }
+            catch {
+                // if stringify fails (e.g. circular reference), fall back
+                // to basic string conversion
+                return String(err);
+            }
         }
         return String(err);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jk2908/solas",
-	"version": "0.1.0",
+	"version": "0.2.0",
 	"description": "A React Server Components meta-framework powered by Vite",
 	"keywords": [
 		"framework",
@@ -61,6 +61,10 @@
 			"types": "./dist/server.d.ts",
 			"import": "./dist/server.js"
 		},
+		"./utils/logger": {
+			"types": "./dist/utils/logger.d.ts",
+			"import": "./dist/utils/logger.js"
+		},
 		"./error-boundary": {
 			"types": "./dist/error-boundary.d.ts",
 			"import": "./dist/error-boundary.js"

package/dist/internal/router/pattern.d.ts

@@ -1,8 +0,0 @@
-export type PathPattern = {
-    path: string;
-    wildcardNames: Set<string>;
-};
-export declare function toPathPattern(route: string, paramNames?: string[]): {
-    path: string;
-    wildcardNames: Set<string>;
-};

package/dist/internal/router/pattern.js

@@ -1,31 +0,0 @@
-function escapePathSegment(value) {
-    return value.replace(/[\\.+*?^${}()[\]|!:]/g, '\\$&');
-}
-export function toPathPattern(route, paramNames = []) {
-    if (route === '/') {
-        return { path: route, wildcardNames: new Set() };
-    }
-    let paramIndex = 0;
-    let wildcardIndex = 0;
-    const wildcardNames = new Set();
-    const path = route
-        .split('/')
-        .filter(Boolean)
-        .map(segment => {
-        if (segment.startsWith(':')) {
-            paramIndex += 1;
-            return `/${segment}`;
-        }
-        if (segment === '*') {
-            const value = paramNames[paramIndex];
-            const name = value && value !== '*' ? value : `wildcard${wildcardIndex}`;
-            paramIndex += 1;
-            wildcardIndex += 1;
-            wildcardNames.add(name);
-            return `/*${name}`;
-        }
-        return `/${escapePathSegment(segment)}`;
-    })
-        .join('');
-    return { path: path || '/', wildcardNames };
-}