@jk2908/solas 0.5.4 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 0.7.0
+
+### Breaking
+
+- Removed the `runtime` config option and the Bun/Node runtime adapters. Solas now uses the Node standard library directly, which Bun runs natively, so there is no runtime selection to configure. Generated entries no longer call `createRuntime`.
+
+## 0.6.0
+
+### Breaking
+
+- Removed the `Solas` runtime namespace exports (`Solas.Config`, `Solas.Runtime`, `Solas.Events`) from the `@jk2908/solas` entry. Runtime constants now live in dedicated internal modules, and generated code no longer reaches through the namespace.
+- Removed the `@jk2908/solas/$` export path. Generated environment entries now import directly from `@jk2908/solas/env/rsc`.
+- Removed the `port` config option from `solas()`. The development port now comes from Vite's `server.port`. `url` remains available as an optional public origin and now resolves from the `url` option → `VITE_APP_URL` → the Vite dev server `host`/`port`.
+
+### Features
+
+- Generated `.solas` files are formatted with oxfmt before writing, and stale generated files are pruned when the codegen stops emitting them.
+- Added a Vitest test suite covering unit, integration, and browser (React Testing Library) tests.
+
+### Fixes
+
+- Generated `entry.rsc.tsx` now emits valid code (`loadManifest` from `env/rsc`) instead of referencing an undefined `Config` import.
+- Fixed the release pipeline by committing the postbuild measurement script.
+
+### Changed
+
+- Pinned `@vitejs/plugin-rsc` to `0.5.34`.
+- Removed the Playwright e2e suite, fixtures, and scripts for now; unit, integration, and browser tests run through Vitest.
+- Declared `engines.node` (`^20.19.0 || >=22.12.0`).
+
 ## 0.5.4 - 2026-06-08
 
 - Add a BrowserRouterHistory API to sync app back/forward navigation with browser navigation.

package/README.md

@@ -2,7 +2,7 @@
 
 Solas is a minimal React meta-framework powered by Vite, created for experimenting with routing, streaming, and prerendering with React Server Components.
 
-Solas is experimental and currently has no automated test suite, so expect rough edges.
+Solas is experimental and under active development, so expect rough edges.
 
 ## Install
 
@@ -201,118 +201,45 @@ That keeps your route params aligned across links, imperative navigation, metada
 
 All Solas options are passed to `solas()` inside `defineConfig`.
 
-## Runtime
-
-Solas uses a runtime for filesystem access, mime lookup, and hashing.
-
-This is not a deployment or packaging adapter. Platform adapters are not available yet.
-
-Use the `runtime` config key to select the runtime used by Solas server code.
-
-Supported values are `'auto'`, `'node'`, and `'bun'`.
-
-`solas()` defaults to `runtime: 'auto'`. In a Bun process, that selects Bun. Otherwise it falls back to Node.
-
-If you already run Vite through Bun, `runtime: 'auto'` is usually enough and Solas will detect Bun automatically.
-
-### Node runtime
-
-If you want to pin Node explicitly, set `runtime: 'node'`:
-
-```ts
-import { defineConfig } from 'vite'
-
-import solas from '@jk2908/solas'
-import react from '@vitejs/plugin-react'
-
-export default defineConfig({
-	plugins: [solas({ runtime: 'node' }), react()],
-})
-```
-
-Use the normal Vite commands with the Node runtime:
-
-```json
-{
-	"scripts": {
-		"dev": "vite dev",
-		"build": "vite build",
-		"preview": "vite preview"
-	}
-}
-```
-
-### Bun runtime
-
-If you want Solas runtime code to execute in Bun, set `runtime: 'bun'`:
-
-```ts
-import { defineConfig } from 'vite'
-
-import solas from '@jk2908/solas'
-import react from '@vitejs/plugin-react'
-
-export default defineConfig({
-	plugins: [solas({ runtime: 'bun' }), react()],
-})
-```
-
-When you use the Bun runtime, run Vite through Bun so the server/runtime code executes in a Bun process:
-
-```json
-{
-	"scripts": {
-		"dev": "bunx --bun vite dev",
-		"build": "bunx --bun vite build",
-		"preview": "bunx --bun vite preview"
-	}
-}
-```
-
 ### `url`
 
-`url` is optional. If you set it, Solas treats it as the public origin for your app.
+Use `url` to set the public origin for your app. It is optional.
 
-Solas resolves it in this order:
+Solas resolves the origin in this order:
 
 - the `url` option passed to `solas()`
 - `VITE_APP_URL`
+- the Vite dev server `host` and `port` (defaults to `http://localhost:8787`)
 
-Solas exposes the resolved value as `import.meta.env.VITE_APP_URL`. If `url` is set, prerender also uses it as the request origin for build-time renders.
-
-In practice, you only need `url` if your app reads `import.meta.env.VITE_APP_URL` or your prerendered output needs a real public origin.
+The resolved origin is exposed to your app as `import.meta.env.VITE_APP_URL` and is used for build-time prerender requests and `sitemap` URLs. When `url` is set, it is also used as a trusted origin for CSRF.
 
-If you do want to set it explicitly, this is the shape:
+You usually only need `url` in production, where the Vite dev server origin is meaningless. For example, to generate a `sitemap.xml` with real URLs:
 
 ```ts
 export default defineConfig(({ mode }) => ({
 	plugins: [
 		solas({
-			url: mode === 'production' ? 'https://example.com' : 'http://localhost:8787',
+			url: mode === 'production' ? 'https://example.com' : undefined,
+			sitemap: true,
 		}),
 	],
 }))
 ```
 
-If you prefer an environment variable, set this instead:
+If you prefer an environment variable, set `VITE_APP_URL` instead:
 
 ```sh
 VITE_APP_URL=https://example.com
 ```
 
-### `port`
-
-Use `port` to change the development server port.
-
-Default: `8787`
+Set the development port with Vite's `server.port`:
 
 ```ts
 export default defineConfig({
-	plugins: [
-		solas({
-			port: 4000,
-		}),
-	],
+	server: {
+		port: 4000,
+	},
+	plugins: [solas(), react()],
 })
 ```
 
@@ -510,13 +437,13 @@ 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`.
+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 the resolved origin (see Config > `url`).
 
 ```ts
 export default defineConfig(({ mode }) => ({
 	plugins: [
 		solas({
-			url: mode === 'production' ? 'https://example.com' : 'http://localhost:8787',
+			url: mode === 'production' ? 'https://example.com' : undefined,
 			sitemap: true,
 		}),
 	],
@@ -528,10 +455,9 @@ Routes with dynamic segments (`[id]`) or catch-all segments (`[...param]`) are o
 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 }) => ({
+export default defineConfig({
 	plugins: [
 		solas({
-			url: mode === 'production' ? 'https://example.com' : 'http://localhost:8787',
 			sitemap: {
 				async routes(existing) {
 					const posts = await getPosts()
@@ -540,7 +466,7 @@ export default defineConfig(({ mode }) => ({
 			},
 		}),
 	],
-}))
+})
 ```
 
 The `routes` function can be async. The callback also lets you filter routes:
@@ -581,6 +507,10 @@ export default defineConfig({
 })
 ```
 
+## Runtime
+
+This is not a deployment or packaging adapter. Platform adapters are not available yet.
+
 ## Scripts
 
 Add scripts to your app:
@@ -595,7 +525,17 @@ Add scripts to your app:
 }
 ```
 
-These defaults assume either `runtime: 'node'` or `runtime: 'auto'` while running Vite under Node. If you set `runtime: 'bun'`, or let `runtime: 'auto'` resolve to Bun by running Vite through Bun, use the Bun-backed commands shown in the runtime section above.
+If you run Vite through Bun, use the Bun-backed commands instead:
+
+```json
+{
+	"scripts": {
+		"dev": "bunx --bun vite dev",
+		"build": "bunx --bun vite build",
+		"preview": "bunx --bun vite preview"
+	}
+}
+```
 
 ## Commands
 
@@ -619,7 +559,7 @@ When available, Solas checks browser provenance using:
 - `Origin`
 - `Referer`
 
-Solas also considers the effective request origin when your app is behind a proxy by using `X-Forwarded-Host`, `X-Forwarded-Proto`, and `config.url` when present.
+Solas also considers the effective request origin when your app is behind a proxy by using `X-Forwarded-Host` and `X-Forwarded-Proto`.
 
 If you need to allow a trusted third-party browser POST source, configure it explicitly:
 

package/dist/config.d.ts

@@ -0,0 +1,24 @@
+import type { PluginConfig } from './types.js';
+export declare const NAME = "Solas";
+export declare const SLUG: string;
+export declare const PKG_NAME: string;
+export declare const OUT_DIR = "dist";
+export declare const APP_DIR = "app";
+export declare const GENERATED_DIR: string;
+export declare const ENTRY_RSC = "entry.rsc.tsx";
+export declare const ENTRY_SSR = "entry.ssr.tsx";
+export declare const ENTRY_BROWSER = "entry.browser.tsx";
+export declare const ASSETS_DIR: string;
+export declare const PUBLIC_DIR = "public";
+export declare const $: unique symbol;
+export declare const REQUEST_META_KEY: string;
+export declare const LOG_LEVELS: readonly ["debug", "info", "warn", "error", "fatal"];
+export declare const PRERENDER_MODES: readonly ["full", "ppr", false];
+export declare const TRAILING_SLASH_MODES: readonly ["always", "never", "ignore"];
+export declare const RUNTIME_MANIFEST = "runtime-manifest.json";
+/**
+ * Validate the plugin configuration object, throwing an error if invalid
+ * @param input - the unvalidated configuration object
+ * @return the typed and validated configuration object
+ */
+export declare function validate(input: unknown): PluginConfig;

package/dist/config.js

@@ -0,0 +1,143 @@
+export const NAME = 'Solas';
+export const SLUG = NAME.toLowerCase();
+export const PKG_NAME = `@jk2908/${SLUG}`;
+export const OUT_DIR = 'dist';
+export const APP_DIR = 'app';
+export const GENERATED_DIR = `.${SLUG}`;
+export const ENTRY_RSC = 'entry.rsc.tsx';
+export const ENTRY_SSR = 'entry.ssr.tsx';
+export const ENTRY_BROWSER = 'entry.browser.tsx';
+export const ASSETS_DIR = `_${SLUG}`;
+export const PUBLIC_DIR = 'public';
+export const $ = Symbol(SLUG);
+export const REQUEST_META_KEY = `__${SLUG.toUpperCase()}__`;
+export const LOG_LEVELS = ['debug', 'info', 'warn', 'error', 'fatal'];
+export const PRERENDER_MODES = ['full', 'ppr', false];
+export const TRAILING_SLASH_MODES = ['always', 'never', 'ignore'];
+export const RUNTIME_MANIFEST = 'runtime-manifest.json';
+const CONFIG_KEYS = new Set([
+    'logger',
+    'metadata',
+    'precompress',
+    'prerender',
+    'sitemap',
+    'trustedOrigins',
+    'trailingSlash',
+    'url',
+]);
+const LOGGER_KEYS = new Set(['level']);
+/**
+ * Validate the plugin configuration object, throwing an error if invalid
+ * @param input - the unvalidated configuration object
+ * @return the typed and validated configuration object
+ */
+export function validate(input) {
+    if (input === undefined)
+        return {};
+    const errors = [];
+    if (!isRecord(input)) {
+        throw new Error(`[${NAME}] Invalid config:\n- Expected plugin config to be an object`);
+    }
+    for (const key of Object.keys(input)) {
+        if (!CONFIG_KEYS.has(key)) {
+            errors.push(`Unknown config key: ${key}`);
+        }
+    }
+    if ('url' in input && input.url !== undefined) {
+        if (typeof input.url !== 'string') {
+            errors.push('url must be a string');
+        }
+        else {
+            try {
+                const url = new URL(input.url);
+                if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+                    errors.push('url must use http:// or https://');
+                }
+            }
+            catch {
+                errors.push('url must be a valid URL');
+            }
+        }
+    }
+    if ('precompress' in input && input.precompress !== undefined) {
+        if (typeof input.precompress !== 'boolean') {
+            errors.push('precompress must be a boolean');
+        }
+    }
+    if ('trustedOrigins' in input && input.trustedOrigins !== undefined) {
+        if (!Array.isArray(input.trustedOrigins)) {
+            errors.push('trustedOrigins must be an array of origins');
+        }
+        else {
+            for (const [index, value] of input.trustedOrigins.entries()) {
+                if (typeof value !== 'string') {
+                    errors.push(`trustedOrigins[${index}] must be a string`);
+                    continue;
+                }
+                try {
+                    const url = new URL(value);
+                    const canonical = value.replace(/\/$/, '');
+                    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+                        errors.push(`trustedOrigins[${index}] must use http:// or https://`);
+                        continue;
+                    }
+                    if (canonical !== url.origin) {
+                        errors.push(`trustedOrigins[${index}] must be an origin without a path, query, or hash`);
+                    }
+                }
+                catch {
+                    errors.push(`trustedOrigins[${index}] must be a valid URL origin`);
+                }
+            }
+        }
+    }
+    if ('sitemap' in input && input.sitemap !== undefined && input.sitemap !== false) {
+        if (typeof input.sitemap !== 'boolean' && typeof input.sitemap !== 'object') {
+            errors.push('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('sitemap.routes must be a function');
+        }
+    }
+    if ('prerender' in input && input.prerender !== undefined) {
+        if (!new Set(PRERENDER_MODES).has(input.prerender)) {
+            errors.push("prerender must be 'full', 'ppr', or false");
+        }
+    }
+    if ('trailingSlash' in input && input.trailingSlash !== undefined) {
+        if (typeof input.trailingSlash !== 'string' ||
+            !new Set(TRAILING_SLASH_MODES).has(input.trailingSlash)) {
+            errors.push("trailingSlash must be 'always', 'never', or 'ignore'");
+        }
+    }
+    if ('metadata' in input && input.metadata !== undefined && !isRecord(input.metadata)) {
+        errors.push('metadata must be an object when provided');
+    }
+    if ('logger' in input && input.logger !== undefined) {
+        if (!isRecord(input.logger)) {
+            errors.push('logger must be an object when provided');
+        }
+        else {
+            for (const key of Object.keys(input.logger)) {
+                if (!LOGGER_KEYS.has(key)) {
+                    errors.push(`Unknown logger key: ${key}`);
+                }
+            }
+            if ('level' in input.logger && input.logger.level !== undefined) {
+                if (typeof input.logger.level !== 'string' ||
+                    !new Set(LOG_LEVELS).has(input.logger.level)) {
+                    errors.push('logger.level must be one of: debug, info, warn, error, fatal');
+                }
+            }
+        }
+    }
+    if (errors.length > 0) {
+        throw new Error(`[${NAME}] Invalid config:\n- ${errors.join('\n- ')}`);
+    }
+    return input;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/events.d.ts

@@ -0,0 +1,4 @@
+export declare const names: {
+    readonly NAVIGATION: `${string}navigation`;
+    readonly NAVIGATION_ERROR: `${string}navigationerror`;
+};

package/dist/events.js

@@ -0,0 +1,5 @@
+import * as Config from './config.js';
+export const names = {
+    NAVIGATION: `${Config.SLUG}navigation`,
+    NAVIGATION_ERROR: `${Config.SLUG}navigationerror`,
+};

package/dist/index.d.ts

@@ -2,6 +2,5 @@ import { type PluginOption } from 'vite';
 import type { PluginConfig } from './types.js';
 declare function solas(c?: PluginConfig): PluginOption[];
 export default solas;
-export type * from './solas.d.ts';
-export { Solas } from './solas.js';
+export * as Solas from './solas.js';
 export type * from './types.js';

package/dist/index.js

@@ -5,36 +5,32 @@ import { createServer, loadConfigFromFile, } from 'vite';
 import rsc from '@vitejs/plugin-rsc';
 import { ExportReader } from './utils/export-reader.js';
 import { Logger } from './utils/logger.js';
-import { Time } from './utils/time.js';
-import { Build } from './internal/build.js';
+import { debounce } from './utils/time.js';
+import * as Config from './config.js';
+import * as Build from './internal/build.js';
 import { writeConfig } from './internal/codegen/config.js';
 import { writeBrowserEntry, writeRSCEntry, writeSSREntry, } from './internal/codegen/environments.js';
+import { format as formatSource } from './internal/codegen/format.js';
 import { writeManifest } from './internal/codegen/manifest.js';
 import { writeMaps } from './internal/codegen/maps.js';
 import { writeTypes } from './internal/codegen/types.js';
 import { postbuild } from './internal/postbuild.js';
 import { collect as collectPublicFiles } from './internal/public-files.js';
-import { createRuntime } from './internal/runtimes/create.js';
 import { Runtime } from './internal/runtimes/runtime.js';
-import { Solas } from './solas.js';
 const DEFAULT_CONFIG = {
-    runtime: 'auto',
     precompress: false,
     prerender: false,
     trustedOrigins: [],
     trailingSlash: 'never',
 };
 function solas(c) {
-    const validatedConfig = Solas.Config.validate({
-        ...c,
-        url: c?.url ?? process.env.VITE_APP_URL?.toString(),
-    });
+    const validatedConfig = Config.validate(c);
     const config = {
         ...DEFAULT_CONFIG,
         ...validatedConfig,
-        runtime: validatedConfig.runtime ?? DEFAULT_CONFIG.runtime,
     };
-    Runtime.runtime = createRuntime(config.runtime);
+    const envUrl = process.env.VITE_APP_URL?.toString();
+    let resolvedUrl = c?.url ?? (envUrl && envUrl.length > 0 ? envUrl : undefined);
     if (config.logger?.level)
         Logger.defaultLevel = config.logger.level;
     const logger = new Logger();
@@ -93,8 +89,8 @@ function solas(c) {
     }
     async function build() {
         const cwd = process.cwd();
-        const routesDir = path.join(cwd, Solas.Config.APP_DIR);
-        const generatedDir = path.join(cwd, Solas.Config.GENERATED_DIR);
+        const routesDir = path.join(cwd, Config.APP_DIR);
+        const generatedDir = path.join(cwd, Config.GENERATED_DIR);
         await Promise.all([
             fs.mkdir(routesDir, { recursive: true }),
             fs.mkdir(generatedDir, { recursive: true }),
@@ -107,12 +103,27 @@ function solas(c) {
             ['config.ts', writeConfig(config)],
             ['manifest.ts', writeManifest(manifest)],
             ['maps.ts', writeMaps(imports, modules)],
-            [`${Solas.Config.SLUG}.d.ts`, writeTypes(manifest)],
-            [Solas.Config.ENTRY_RSC, writeRSCEntry(config)],
-            [Solas.Config.ENTRY_SSR, writeSSREntry()],
-            [Solas.Config.ENTRY_BROWSER, writeBrowserEntry()],
+            [`${Config.SLUG}.d.ts`, writeTypes(manifest)],
+            [Config.ENTRY_RSC, writeRSCEntry(config)],
+            [Config.ENTRY_SSR, writeSSREntry()],
+            [Config.ENTRY_BROWSER, writeBrowserEntry()],
         ];
-        const writes = await Promise.all(files.map(([file, content]) => maybeWrite(path.join(generatedDir, file), content)));
+        // remove generated files no longer emitted by the current codegen, so
+        // old artifacts don't linger and break module resolution. keep
+        // closeBundle's build.json, which lives in the same directory
+        const currentFiles = new Set(files.map(([file]) => file));
+        const existing = await fs
+            .readdir(generatedDir, { withFileTypes: true })
+            .catch(() => []);
+        await Promise.all(existing
+            .filter(entry => entry.isFile() &&
+            entry.name !== 'build.json' &&
+            !currentFiles.has(entry.name))
+            .map(entry => fs.rm(path.join(generatedDir, entry.name), { force: true })));
+        const writes = await Promise.all(files.map(async ([file, content]) => {
+            const formatted = await formatSource(file, content);
+            return maybeWrite(path.join(generatedDir, file), formatted);
+        }));
         const changed = writes.filter(n => n !== null);
         // early return if nothing has changed
         if (!changed.length)
@@ -125,7 +136,7 @@ function solas(c) {
     // normalise all watcher paths to forward slashes so path checks behave the
     // same on Windows and POSIX
     const WATCH_CWD = process.cwd().replace(/\\/g, '/');
-    const WATCH_APP_ROOT = `${WATCH_CWD}/${Solas.Config.APP_DIR}/`;
+    const WATCH_APP_ROOT = `${WATCH_CWD}/${Config.APP_DIR}/`;
     // convert watcher paths to a consistent slash format before comparing them
     const normaliseWatchPath = (p) => p.replace(/\\/g, '/');
     // resolve relative watcher paths against the project root so prefix checks are reliable
@@ -136,7 +147,7 @@ function solas(c) {
     // edits needing special treatment because verb exports can change in-place
     const routeFile = /\/\+(layout|page|401|403|404|500|loading|middleware|endpoint)\.(t|j)sx?$/;
     const endpointFile = /\/\+endpoint\.(t|j)sx?$/;
-    const rebuild = Time.debounce((event, p) => {
+    const rebuild = debounce((event, p) => {
         const queue = () => {
             void (async () => {
                 // collapse bursts of file events into one active rebuild plus a single
@@ -197,9 +208,7 @@ function solas(c) {
                 return [];
             if (Array.isArray(plugin))
                 return plugin.flatMap(flatten);
-            if (typeof plugin === 'object' &&
-                'name' in plugin &&
-                plugin.name === Solas.Config.NAME) {
+            if (typeof plugin === 'object' && 'name' in plugin && plugin.name === Config.NAME) {
                 return [];
             }
             return [plugin];
@@ -219,26 +228,35 @@ function solas(c) {
         return utilityServer;
     }
     const plugin = {
-        name: Solas.Config.NAME,
+        name: Config.NAME,
         async config(viteConfig) {
             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`);
+                throw new Error(`Missing ${Config.NAME} package name`);
             }
             if (typeof pkg.version !== 'string' || pkg.version.length === 0) {
-                throw new Error(`Missing ${Solas.Config.NAME} package version`);
+                throw new Error(`Missing ${Config.NAME} package version`);
             }
             viteConfig.build ??= {};
-            viteConfig.build.outDir = Solas.Config.OUT_DIR;
+            viteConfig.build.outDir = Config.OUT_DIR;
             // keep framework files under one reserved url prefix
-            viteConfig.build.assetsDir = Solas.Config.ASSETS_DIR;
+            viteConfig.build.assetsDir = Config.ASSETS_DIR;
             viteConfig.build.emptyOutDir = true;
             // let users move the source public folder if they want
-            viteConfig.publicDir ??= Solas.Config.PUBLIC_DIR;
+            viteConfig.publicDir ??= Config.PUBLIC_DIR;
             viteConfig.server ??= {};
-            viteConfig.server.port = config.port ?? viteConfig.server.port ?? 8787;
+            viteConfig.server.port ??= 8787;
+            // derive the public url from vite's dev server settings when no
+            // origin was set explicitly via the url option or VITE_APP_URL
+            if (resolvedUrl === undefined) {
+                const { host, port } = viteConfig.server;
+                const hostname = typeof host === 'string' && host.length > 0 && host !== '0.0.0.0'
+                    ? host
+                    : 'localhost';
+                resolvedUrl = `http://${hostname}:${port}`;
+            }
             viteConfig.define ??= {};
-            viteConfig.define['import.meta.env.VITE_APP_URL'] = JSON.stringify(config.url);
+            viteConfig.define['import.meta.env.VITE_APP_URL'] = JSON.stringify(resolvedUrl);
             viteConfig.define['import.meta.env.SOLAS_VERSION'] = JSON.stringify(pkg.version);
             viteConfig.optimizeDeps ??= {};
             viteConfig.optimizeDeps.exclude = [
@@ -255,12 +273,12 @@ function solas(c) {
                     ...viteConfig.resolve.alias,
                     {
                         find: '.solas',
-                        replacement: path.resolve(process.cwd(), Solas.Config.GENERATED_DIR),
+                        replacement: path.resolve(process.cwd(), Config.GENERATED_DIR),
                     },
                 ]
                 : {
                     ...viteConfig.resolve.alias,
-                    '.solas': path.resolve(process.cwd(), Solas.Config.GENERATED_DIR),
+                    '.solas': path.resolve(process.cwd(), Config.GENERATED_DIR),
                 };
         },
         configResolved(resolvedConfig) {
@@ -268,7 +286,7 @@ function solas(c) {
             buildContext.command = resolvedConfig.command;
         },
         configureServer(server) {
-            logger.info('[configureServer]', `Watching for changes in ./${Solas.Config.APP_DIR}...`);
+            logger.info('[configureServer]', `Watching for changes in ./${Config.APP_DIR}...`);
             server.watcher
                 .on('add', (p) => rebuild('add', p))
                 .on('change', (p) => rebuild('change', p))
@@ -294,7 +312,7 @@ function solas(c) {
             }
             // resolve sitemap routes
             let sitemapRoutes = [];
-            if (config.sitemap && config.url) {
+            if (config.sitemap && resolvedUrl) {
                 const auto = [
                     ...new Set([...buildContext.knownRoutes, ...buildContext.prerenderRoutes]),
                 ];
@@ -306,7 +324,7 @@ function solas(c) {
                 }
             }
             // write build manifest
-            const generatedDir = path.join(process.cwd(), Solas.Config.GENERATED_DIR);
+            const generatedDir = path.join(process.cwd(), Config.GENERATED_DIR);
             await Runtime.write(path.join(generatedDir, 'build.json'), JSON.stringify({
                 base: resolvedViteConfig?.base ?? '/',
                 publicFiles: await collectPublicFiles(resolvedViteConfig?.publicDir),
@@ -314,7 +332,7 @@ function solas(c) {
                 sitemapRoutes,
                 precompress: config.precompress,
                 trailingSlash: config.trailingSlash,
-                url: config.url,
+                url: resolvedUrl,
             }));
         },
         buildApp: {
@@ -328,12 +346,12 @@ function solas(c) {
         plugin,
         rsc({
             entries: {
-                rsc: `./${Solas.Config.GENERATED_DIR}/${Solas.Config.ENTRY_RSC}`,
-                ssr: `./${Solas.Config.GENERATED_DIR}/${Solas.Config.ENTRY_SSR}`,
-                client: `./${Solas.Config.GENERATED_DIR}/${Solas.Config.ENTRY_BROWSER}`,
+                rsc: `./${Config.GENERATED_DIR}/${Config.ENTRY_RSC}`,
+                ssr: `./${Config.GENERATED_DIR}/${Config.ENTRY_SSR}`,
+                client: `./${Config.GENERATED_DIR}/${Config.ENTRY_BROWSER}`,
             },
         }),
     ];
 }
 export default solas;
-export { Solas } from './solas.js';
+export * as Solas from './solas.js';

package/dist/internal/boundary-error.d.ts

@@ -0,0 +1,4 @@
+export declare class BoundaryError extends Error {
+    digest?: string;
+    constructor(digest?: string);
+}