@jk2908/solas 0.4.4 → 0.5.1

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.5.1 - 2026-06-06
+
+- Fixed production app bundling by removing the `mime-types` package dependency from Solas runtime paths, preventing client bundles from resolving `/node_modules/mime-types/*` imports.
+- Added an internal `getMimeTypeFromPath(...)` helper for Node runtime MIME resolution with a safe `application/octet-stream` fallback for unknown extensions.
+- Removed obsolete `src/adapters/*` runtime adapter files so runtime selection now consistently uses the internal runtime implementations.
+
+## 0.5.0 - 2026-06-06
+
+- Added runtime selection via `runtime: 'auto' | 'node' | 'bun'`, with `auto` choosing Bun when available and falling back to Node otherwise.
+- Removed the default Bun runtime requirement from the documented workflow. Standard `vite dev`, `vite build`, and `vite preview` commands now work on the default Node path, while Bun-backed Vite commands remain available when you want to run Solas in Bun.
+- Added a dedicated `@jk2908/solas/$` runtime-safe export for generated/runtime code so preview and production server bundles no longer need to pull through the package root plugin entry.
+- Fixed prerender static param resolution to stop depending on host support for `Promise.try`, so build-time route processing now works correctly under Node-based Vite runs.
+
+## 0.4.5 - 2026-05-29
+
+- Documented concrete `href` and `router.go(...)` usage in the README, including how explicit `query` values merge with an existing query string and take precedence for duplicate keys.
+- Clarified in the README that `router.go(...)` and `router.refresh()` are awaitable, and that `router.refresh()` always refreshes the current browser location at call time.
+- Fixed browser-router typing so `refresh` is exposed as a promise-returning method, matching the runtime implementation.
+
 ## 0.4.4 - 2026-05-29
 
 - Added `router.refresh()` to the browser router, and made it clear that it clears the current route cache before fetching a fresh RSC payload.

package/README.md

@@ -4,8 +4,6 @@ Solas is a minimal React meta-framework powered by Vite, created for experimenti
 
 Solas is experimental and currently has no automated test suite, so expect rough edges.
 
-Solas currently requires Bun 1.2+ on your `PATH`. You can still manage dependencies with `npm`, `pnpm`, or `yarn`, but the Solas CLI and Vite plugin runtime use Bun APIs directly.
-
 ## Install
 
 ```sh
@@ -100,6 +98,24 @@ That gives you:
 - rejected params for static routes that do not accept them
 - typed query and navigation options on `router.go(...)`
 
+If you already have a concrete path, you can pass that directly instead of using route params:
+
+```tsx
+;<Link href={`/p/${post.id}`} />
+
+await router.go(`/p/${post.id}`)
+```
+
+In that form the path is already resolved, so `params` are not used. Typed `Link` and `router.go(...)` only allow `params` when you pass a route pattern like `/p/:id`.
+
+If the target already contains a query string and you also pass `query`, Solas merges them. Existing query entries are kept unless you override the same key in `query`, and explicit `query` values win:
+
+```tsx
+<Link href={`/p/${post.id}?tab=summary`} query={{ draft: true, tab: 'full' }} />
+```
+
+That resolves to `/p/${post.id}?tab=full&draft=true`.
+
 Use `Link` for same-origin app navigation. Prefetching is opt-in:
 
 ```tsx
@@ -123,7 +139,7 @@ export function Controls() {
 
 	return (
 		<>
-			<button type="button" onClick={() => void router.go('/posts')}>
+			<button type="button" onClick={() => router.go('/posts')}>
 				Go to posts
 			</button>
 
@@ -131,7 +147,7 @@ export function Controls() {
 				Prefetch posts
 			</button>
 
-			<button type="button" onClick={() => void router.refresh()}>
+			<button type="button" onClick={() => router.refresh()}>
 				Refresh current route
 			</button>
 		</>
@@ -139,6 +155,18 @@ export function Controls() {
 }
 ```
 
+`router.go(...)` and `router.refresh()` both return promises, so you can `await` either of them when you need to sequence work after navigation completes:
+
+```tsx
+const finalPath = await router.go('/posts')
+```
+
+```tsx
+await router.refresh()
+```
+
+`router.refresh()` always refreshes the current browser location at the moment you call it. If you call it after `await router.go('/posts')`, it refreshes `/posts` (or the final redirected path).
+
 `router.go(...)` accepts route params and query values using the same typed route rules as `Link`:
 
 ```tsx
@@ -173,6 +201,74 @@ 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.
@@ -492,18 +588,20 @@ Add scripts to your app:
 ```json
 {
 	"scripts": {
-		"dev": "bunx --bun vite dev",
-		"build": "bunx --bun vite build",
-		"preview": "bunx --bun vite preview"
+		"dev": "vite dev",
+		"build": "vite build",
+		"preview": "vite preview"
 	}
 }
 ```
 
+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.
+
 ## Commands
 
-- `bunx --bun vite dev` starts the development server.
-- `bunx --bun vite build` creates a production build. Solas finalizes that build by prerendering configured routes, writing the runtime manifest, generating `sitemap.xml` when enabled, and precompressing output when enabled.
-- `bunx --bun vite preview` serves the built app for local verification.
+- `vite dev` starts the development server.
+- `vite build` creates a production build. Solas finalizes that build by prerendering configured routes, writing the runtime manifest, generating `sitemap.xml` when enabled, and precompressing output when enabled.
+- `vite preview` serves the built app for local verification.
 
 ## Security
 

package/dist/index.js

@@ -14,19 +14,26 @@ 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 { 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 config = Solas.Config.validate({
-        ...DEFAULT_CONFIG,
+    const validatedConfig = Solas.Config.validate({
         ...c,
         url: c?.url ?? process.env.VITE_APP_URL?.toString(),
     });
+    const config = {
+        ...DEFAULT_CONFIG,
+        ...validatedConfig,
+        runtime: validatedConfig.runtime ?? DEFAULT_CONFIG.runtime,
+    };
+    Runtime.runtime = Solas.Runtime.create(config.runtime);
     if (config.logger?.level)
         Logger.defaultLevel = config.logger.level;
     const logger = new Logger();
@@ -43,11 +50,11 @@ function solas(c) {
             const cached = fileCache.get(filePath);
             if (cached === content) {
                 // if content is unchanged and file exists, skip write
-                if (await Bun.file(filePath).exists())
+                if (await Runtime.exists(filePath))
                     return null;
                 // else, file is missing but cached content is the same as
                 // last time we saw it, write it
-                await Bun.write(filePath, content);
+                await Runtime.write(filePath, content);
                 fileCache.set(filePath, content);
                 return path.relative(process.cwd(), filePath);
             }
@@ -57,7 +64,7 @@ function solas(c) {
             if (curr === content)
                 return null;
             try {
-                await Bun.write(filePath, content);
+                await Runtime.write(filePath, content);
                 fileCache.set(filePath, content);
                 return path.relative(process.cwd(), filePath);
             }
@@ -70,7 +77,7 @@ function solas(c) {
             // file doesn't exist, write it
             if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
                 try {
-                    await Bun.write(filePath, content);
+                    await Runtime.write(filePath, content);
                     fileCache.set(filePath, content);
                     return path.relative(process.cwd(), filePath);
                 }
@@ -100,7 +107,7 @@ function solas(c) {
             ['manifest.ts', writeManifest(manifest)],
             ['maps.ts', writeMaps(imports, modules)],
             [`${Solas.Config.SLUG}.d.ts`, writeTypes(manifest)],
-            [Solas.Config.ENTRY_RSC, writeRSCEntry()],
+            [Solas.Config.ENTRY_RSC, writeRSCEntry(config)],
             [Solas.Config.ENTRY_SSR, writeSSREntry()],
             [Solas.Config.ENTRY_BROWSER, writeBrowserEntry()],
         ];
@@ -299,7 +306,7 @@ function solas(c) {
             }
             // write build manifest
             const generatedDir = path.join(process.cwd(), Solas.Config.GENERATED_DIR);
-            await Bun.write(path.join(generatedDir, 'build.json'), JSON.stringify({
+            await Runtime.write(path.join(generatedDir, 'build.json'), JSON.stringify({
                 base: resolvedViteConfig?.base ?? '/',
                 publicFiles: await collectPublicFiles(resolvedViteConfig?.publicDir),
                 prerenderRoutes: Array.from(buildContext.prerenderRoutes),

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

@@ -4,7 +4,7 @@ export { BrowserRouter } from './shared.js';
 export declare const BrowserRouterContext: import("react").Context<{
     go: BrowserRouter.Go;
     prefetch: (path: string) => void;
-    refresh: () => void;
+    refresh: BrowserRouter.Refresh;
     isNavigating: boolean;
     url: {
         pathname?: string | undefined;

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

@@ -10,7 +10,7 @@ export { BrowserRouter } from './shared.js';
 export const BrowserRouterContext = createContext({
     go: async () => '',
     prefetch: () => { },
-    refresh: () => { },
+    refresh: async () => '',
     isNavigating: false,
     url: {},
 });
@@ -130,7 +130,7 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
         const currentPath = window.location.pathname + window.location.search;
         const key = ResponseCache.toCacheKey(currentPath, window.location.origin);
         if (!key)
-            return;
+            return Promise.resolve(currentPath);
         if (responseCache.has(key))
             responseCache.remove(key);
         return go(currentPath, {

package/dist/internal/browser-router/shared.d.ts

@@ -156,6 +156,7 @@ export declare namespace BrowserRouter {
         <TTo extends Target>(to: TTo, opts?: TargetConfig & Replace): Promise<string>;
         <TTo extends string>(to: string extends TTo ? TTo : never, opts?: GoOptions): Promise<string>;
     };
+    export type Refresh = () => Promise<string>;
     /**
      * Convert a route pattern and params into a real path string. This is used internally
      * to implement <Link /> and router.go

package/dist/internal/browser-router/use-router.d.ts

@@ -1,7 +1,7 @@
 export declare function useRouter(): {
     go: import("./shared.js").BrowserRouter.Go;
     prefetch: (path: string) => void;
-    refresh: () => void;
+    refresh: import("./shared.js").BrowserRouter.Refresh;
     isNavigating: boolean;
     url: {
         pathname?: string | undefined;

package/dist/internal/build.js

@@ -4,6 +4,7 @@ import { Logger } from '../utils/logger.js';
 import { Solas } from '../solas.js';
 import { normalisePathname } from './http-router/utils.js';
 import { Prerender } from './prerender.js';
+import { Runtime } from './runtimes/runtime.js';
 export { Build };
 /**
  * Types, constants, and the Finder class for route discovery and manifest generation.
@@ -345,7 +346,7 @@ var Build;
                         currentPrerenderMode = flag;
                     }
                     const shellImport = Finder.getImportPath(shellPath);
-                    const shellId = `${Build.EntryKind.SHELL}${Bun.hash(shellImport)}`;
+                    const shellId = `${Build.EntryKind.SHELL}${Runtime.hash(shellImport)}`;
                     const layoutIds = [];
                     const unauthorisedIds = [];
                     const forbiddenIds = [];
@@ -366,7 +367,7 @@ var Build;
                             continue;
                         }
                         const layoutImport = Finder.getImportPath(layoutPath);
-                        const layoutId = `${Build.EntryKind.LAYOUT}${Bun.hash(layoutImport)}`;
+                        const layoutId = `${Build.EntryKind.LAYOUT}${Runtime.hash(layoutImport)}`;
                         if (!processed.has(layoutPath)) {
                             prerenderCache.set(layoutPath, await Prerender.Build.getStaticFlag(layoutPath, this.buildContext));
                             imports.components.dynamic.set(layoutId, layoutImport);
@@ -381,7 +382,7 @@ var Build;
                             continue;
                         }
                         const unauthorisedImport = Finder.getImportPath(unauthorisedPath);
-                        const unauthorisedId = `${Build.EntryKind['401']}${Bun.hash(unauthorisedImport)}`;
+                        const unauthorisedId = `${Build.EntryKind['401']}${Runtime.hash(unauthorisedImport)}`;
                         unauthorisedIds.push(unauthorisedId);
                         if (!processed.has(unauthorisedPath)) {
                             imports.components.dynamic.set(unauthorisedId, unauthorisedImport);
@@ -394,7 +395,7 @@ var Build;
                             continue;
                         }
                         const forbiddenImport = Finder.getImportPath(forbiddenPath);
-                        const forbiddenId = `${Build.EntryKind['403']}${Bun.hash(forbiddenImport)}`;
+                        const forbiddenId = `${Build.EntryKind['403']}${Runtime.hash(forbiddenImport)}`;
                         forbiddenIds.push(forbiddenId);
                         if (!processed.has(forbiddenPath)) {
                             imports.components.dynamic.set(forbiddenId, forbiddenImport);
@@ -409,7 +410,7 @@ var Build;
                             continue;
                         }
                         const notFoundImport = Finder.getImportPath(notFoundPath);
-                        const notFoundId = `${Build.EntryKind['404']}${Bun.hash(notFoundImport)}`;
+                        const notFoundId = `${Build.EntryKind['404']}${Runtime.hash(notFoundImport)}`;
                         notFoundIds.push(notFoundId);
                         // dedupe imports but still assign the slot for this route
                         if (!processed.has(notFoundPath)) {
@@ -423,7 +424,7 @@ var Build;
                             continue;
                         }
                         const serverErrorImport = Finder.getImportPath(serverErrorPath);
-                        const serverErrorId = `${Build.EntryKind['500']}${Bun.hash(serverErrorImport)}`;
+                        const serverErrorId = `${Build.EntryKind['500']}${Runtime.hash(serverErrorImport)}`;
                         serverErrorIds.push(serverErrorId);
                         if (!processed.has(serverErrorPath)) {
                             imports.components.dynamic.set(serverErrorId, serverErrorImport);
@@ -438,7 +439,7 @@ var Build;
                             continue;
                         }
                         const loaderImport = Finder.getImportPath(loaderPath);
-                        const loaderId = `${Build.EntryKind.LOADING}${Bun.hash(loaderImport)}`;
+                        const loaderId = `${Build.EntryKind.LOADING}${Runtime.hash(loaderImport)}`;
                         loadingIds.push(loaderId);
                         // dedupe imports but still assign the slot for this route
                         if (!processed.has(loaderPath)) {
@@ -452,7 +453,7 @@ var Build;
                             continue;
                         }
                         const middlewareImport = Finder.getImportPath(middlewarePath);
-                        const middlewareId = `${Build.EntryKind.MIDDLEWARE}${Bun.hash(middlewareImport)}`;
+                        const middlewareId = `${Build.EntryKind.MIDDLEWARE}${Runtime.hash(middlewareImport)}`;
                         middlewareIds.push(middlewareId);
                         if (!processed.has(middlewarePath)) {
                             // route scanning only tells us this is a +middleware file path
@@ -466,8 +467,8 @@ var Build;
                     }
                     // generate entry id based on page if exists, otherwise dir
                     const entryId = pagePath
-                        ? `${Build.EntryKind.PAGE}${Bun.hash(Finder.getImportPath(pagePath))}`
-                        : `${Build.EntryKind.PAGE}${Bun.hash(route)}`;
+                        ? `${Build.EntryKind.PAGE}${Runtime.hash(Finder.getImportPath(pagePath))}`
+                        : `${Build.EntryKind.PAGE}${Runtime.hash(route)}`;
                     if (pagePath) {
                         const pagePrerender = await Prerender.Build.getStaticFlag(pagePath, this.buildContext);
                         applyPrerenderMode(pagePrerender);
@@ -568,12 +569,12 @@ var Build;
                             continue;
                         }
                         const m = method.toLowerCase();
-                        const endpointId = `${Build.EntryKind.ENDPOINT}${Bun.hash(Finder.getImportPath(endpointFilePath))}_${m}`;
+                        const endpointId = `${Build.EntryKind.ENDPOINT}${Runtime.hash(Finder.getImportPath(endpointFilePath))}_${m}`;
                         const middlewareIds = await Promise.all(endpointMiddlewarePaths.map(async middlewarePath => {
                             if (!middlewarePath)
                                 return null;
                             const middlewareImport = Finder.getImportPath(middlewarePath);
-                            const middlewareId = `${Build.EntryKind.MIDDLEWARE}${Bun.hash(middlewareImport)}`;
+                            const middlewareId = `${Build.EntryKind.MIDDLEWARE}${Runtime.hash(middlewareImport)}`;
                             if (!processed.has(middlewarePath)) {
                                 // endpoint middleware discovery gives us file paths, not proof
                                 // of the export so check the module shape first
@@ -605,7 +606,7 @@ var Build;
                         modules[route] = {
                             ...(modules[route] ?? {}),
                             middlewareIds: endpointMiddlewarePaths.map(middlewarePath => middlewarePath
-                                ? `${Build.EntryKind.MIDDLEWARE}${Bun.hash(Finder.getImportPath(middlewarePath))}`
+                                ? `${Build.EntryKind.MIDDLEWARE}${Runtime.hash(Finder.getImportPath(middlewarePath))}`
                                 : null),
                         };
                     }

package/dist/internal/codegen/config.js

@@ -4,14 +4,15 @@ import { AUTOGEN_MSG, source, toSourceLiteral } from './utils.js';
  * Generates the code to create an exported config object
  */
 export function writeConfig(config) {
+    const { runtime: _runtime, ...runtimeConfig } = config;
     const loggerLevel = config.logger?.level;
     const importLines = [
-        `import type { PluginConfig } from '${Solas.Config.PKG_NAME}'`,
+        `import type { RuntimeConfig } from '${Solas.Config.PKG_NAME}'`,
         loggerLevel ? `import { Logger } from '${Solas.Config.PKG_NAME}/utils/logger'` : '',
     ]
         .filter(Boolean)
         .join('\n');
-    const configStatement = `const config = ${toSourceLiteral(config)} as const satisfies PluginConfig`;
+    const configStatement = `const config = ${toSourceLiteral(runtimeConfig)} as const satisfies RuntimeConfig`;
     const loggerStatement = loggerLevel
         ? `Logger.defaultLevel = ${toSourceLiteral(loggerLevel)}`
         : '';

package/dist/internal/codegen/environments.d.ts

@@ -1,7 +1,8 @@
+import type { ConfiguredPluginConfig } from '../../types.js';
 /**
  * Generates the RSC entry code
  */
-export declare function writeRSCEntry(): string;
+export declare function writeRSCEntry(config: ConfiguredPluginConfig): string;
 /**
  * Generates the SSR entry code
  */

package/dist/internal/codegen/environments.js

@@ -1,19 +1,21 @@
 import { Solas } from '../../solas.js';
-import { AUTOGEN_MSG, source } from './utils.js';
+import { AUTOGEN_MSG, source, toStringLiteral } from './utils.js';
 /**
  * Generates the RSC entry code
  */
-export function writeRSCEntry() {
+export function writeRSCEntry(config) {
+    const runtime = toStringLiteral(config.runtime);
     return source `
 		${AUTOGEN_MSG}
 
-		import { createHandler } from '${Solas.Config.PKG_NAME}/env/rsc'
-		import { Solas } from '${Solas.Config.PKG_NAME}'
+		import { createHandler, Runtime } from '${Solas.Config.PKG_NAME}/env/rsc'
+		import { Solas } from '${Solas.Config.PKG_NAME}/$'
 
 		import { manifest } from './manifest.js'
 		import { importMap } from './maps.js'
 		import { config } from './config.js'
 
+		Runtime.runtime = Solas.Runtime.create(${runtime})
 		const runtimeManifest = await Solas.Runtime.loadManifest(Solas.Config.OUT_DIR)
 
 		export default createHandler(config, manifest, importMap, runtimeManifest)

package/dist/internal/env/rsc.d.ts

@@ -2,6 +2,7 @@ import type { ReactFormState } from 'react-dom/client';
 import type { ImportMap, Manifest, RuntimeConfig } from '../../types.js';
 import { Solas } from '../../solas.js';
 import { Metadata } from '../metadata.js';
+export { Runtime } from '../runtimes/runtime.js';
 export type RscPayload = {
     returnValue?: {
         ok: boolean;

package/dist/internal/env/rsc.js

@@ -17,6 +17,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';
+export { Runtime } from '../runtimes/runtime.js';
 const logger = new Logger();
 const BASE_PATH = BasePath.normalise(import.meta.env.BASE_URL);
 function resolveFilePath(root, relativePath) {

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

@@ -2,6 +2,7 @@ import { match as createMatch } from 'path-to-regexp';
 import { BasePath } from '../../utils/base-path.js';
 import { Solas } from '../../solas.js';
 import { HttpException } from '../navigation/http-exception.js';
+import { Runtime } from '../runtimes/runtime.js';
 import { maybeAction } from '../server/actions.js';
 import { enforce } from '../server/csrf.js';
 import { getAlternatePathname, normalisePathname, toPathPattern } from './utils.js';
@@ -253,24 +254,24 @@ export class HttpRouter {
      */
     static async serveStatic(filePath, req, precompress = false, headers = {}) {
         const accept = req.headers.get('accept-encoding') ?? '';
-        let file = Bun.file(filePath);
+        let resolvedPath = filePath;
         let encoding = null;
         if (precompress) {
             // prefer a precompressed variant when the client accepts it and one was emitted
             if (accept.includes('br')) {
-                const brotli = Bun.file(`${filePath}.br`);
-                if (await brotli.exists()) {
-                    file = brotli;
+                const brotliPath = `${filePath}.br`;
+                if (await Runtime.exists(brotliPath)) {
+                    resolvedPath = brotliPath;
                     encoding = 'br';
                 }
             }
         }
-        if (!(await file.exists())) {
+        if (!(await Runtime.exists(resolvedPath))) {
             return new Response('Not found', { status: 404 });
         }
         // get mime type from original path, not compressed variant
-        const mimeType = Bun.file(filePath).type;
-        const res = new Response(file, {
+        const mimeType = Runtime.mimeType(filePath);
+        const res = new Response(await Runtime.readBuffer(resolvedPath), {
             headers: {
                 'Content-Type': headers['Content-Type'] ?? mimeType,
             },

package/dist/internal/postbuild.js

@@ -4,6 +4,7 @@ import { Compress } from '../utils/compress.js';
 import { Logger } from '../utils/logger.js';
 import { Solas } from '../solas.js';
 import { Prerender } from './prerender.js';
+import { Runtime } from './runtimes/runtime.js';
 const logger = new Logger();
 export async function postbuild(cwd = process.cwd()) {
     const manifestPath = path.join(cwd, Solas.Config.GENERATED_DIR, 'build.json');
@@ -59,8 +60,8 @@ export async function postbuild(cwd = process.cwd()) {
                     if (artifact.mode === 'ppr') {
                         await fs.mkdir(artifactDir, { recursive: true });
                         const writes = [
-                            Bun.write(path.join(artifactDir, 'prelude.html'), artifact.html),
-                            Bun.write(path.join(artifactDir, 'metadata.json'), JSON.stringify({
+                            Runtime.write(path.join(artifactDir, 'prelude.html'), artifact.html),
+                            Runtime.write(path.join(artifactDir, 'metadata.json'), JSON.stringify({
                                 schema: artifact.schema,
                                 route: artifact.route,
                                 createdAt: artifact.createdAt,
@@ -68,7 +69,7 @@ export async function postbuild(cwd = process.cwd()) {
                             })),
                         ];
                         if (artifact.postponed !== undefined) {
-                            writes.push(Bun.write(path.join(artifactDir, 'postponed.json'), JSON.stringify(artifact.postponed)));
+                            writes.push(Runtime.write(path.join(artifactDir, 'postponed.json'), JSON.stringify(artifact.postponed)));
                         }
                         await Promise.all(writes);
                         artifactManifest[route] = {
@@ -82,13 +83,13 @@ export async function postbuild(cwd = process.cwd()) {
                     }
                     await fs.mkdir(artifactDir, { recursive: true });
                     await Promise.all([
-                        Bun.write(path.join(artifactDir, 'metadata.json'), JSON.stringify({
+                        Runtime.write(path.join(artifactDir, 'metadata.json'), JSON.stringify({
                             schema: artifact.schema,
                             route: artifact.route,
                             createdAt: artifact.createdAt,
                             mode: artifact.mode,
                         })),
-                        Bun.write(Prerender.Artifact.getFilePath(outDir, route, Prerender.Artifact.FULL_PRERENDER_FILENAME), artifact.html),
+                        Runtime.write(Prerender.Artifact.getFilePath(outDir, route, Prerender.Artifact.FULL_PRERENDER_FILENAME), artifact.html),
                     ]);
                     artifactManifest[route] = {
                         mode: artifact.mode,
@@ -108,7 +109,7 @@ export async function postbuild(cwd = process.cwd()) {
         artifacts: artifactManifest,
         publicFiles: manifest.publicFiles,
     };
-    await Bun.write(Solas.Runtime.getManifestPath(outDir), JSON.stringify(runtimeManifest));
+    await Runtime.write(Solas.Runtime.getManifestPath(outDir), JSON.stringify(runtimeManifest));
     if (manifest.sitemapRoutes.length > 0 && manifest.url) {
         const origin = manifest.url.replace(/\/$/, '');
         const urls = manifest.sitemapRoutes
@@ -120,7 +121,7 @@ export async function postbuild(cwd = process.cwd()) {
             urls,
             '</urlset>',
         ].join('\n');
-        await Bun.write(path.join(outDir, 'sitemap.xml'), sitemap);
+        await Runtime.write(path.join(outDir, 'sitemap.xml'), sitemap);
         logger.info('[sitemap]', `generated ${manifest.sitemapRoutes.length} urls`);
     }
     if (manifest.precompress) {
@@ -144,7 +145,7 @@ export async function postbuild(cwd = process.cwd()) {
                     normalisedPath.endsWith(`/${Prerender.Artifact.FULL_PRERENDER_FILENAME}`));
             },
         })) {
-            await Bun.write(`${input}.br`, compressed);
+            await Runtime.write(`${input}.br`, compressed);
             logger.info('[precompress]', `${path.basename(input)}.br`);
         }
     }