@jk2908/solas 0.4.3 → 0.5.0

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

@@ -24,6 +24,7 @@ var BrowserRouter;
      */
     function toTarget(path, params, query) {
         const used = new Set();
+        // first, replace all the :param parts with the corresponding params
         let to = path.replaceAll(/:([A-Za-z0-9_]+)/g, (_, key) => {
             const value = params?.[key];
             if (value == null) {

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

@@ -1,6 +1,7 @@
 export declare function useRouter(): {
     go: import("./shared.js").BrowserRouter.Go;
     prefetch: (path: string) => 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/codegen/maps.js

@@ -37,8 +37,8 @@ export function writeMaps(imports, modules) {
             parts.push(`endpoint: ${toIdentifier(m.endpointId, `endpoint id for ${moduleId}`)}`);
         }
         if (m['401Ids']?.length) {
-            const unauthorized = toIdentifierList(m['401Ids'], `401s for ${moduleId}`);
-            parts.push(`'401s': [${unauthorized}]`);
+            const unauthorised = toIdentifierList(m['401Ids'], `401s for ${moduleId}`);
+            parts.push(`'401s': [${unauthorised}]`);
         }
         if (m['403Ids']?.length) {
             const forbidden = toIdentifierList(m['403Ids'], `403s for ${moduleId}`);
@@ -70,13 +70,15 @@ export function writeMaps(imports, modules) {
 		${AUTOGEN_MSG}
 
 		import type { ImportMap } from '${Solas.Config.PKG_NAME}'
-${importLines
+		
+		${importLines
         ? `
-${importLines}`
+			${importLines}
+		`
         : ''}
 
 		export const importMap = {
-${entries}
+			${entries}
 		} as const satisfies ImportMap
 	`;
 }

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`);
         }
     }

package/dist/internal/prerender.js

@@ -4,6 +4,7 @@ import { BasePath } from '../utils/base-path.js';
 import { Logger } from '../utils/logger.js';
 import { Solas } from '../solas.js';
 import { toPathPattern } from './http-router/utils.js';
+import { Runtime as AdapterRuntime } from './runtimes/runtime.js';
 const logger = new Logger();
 export { Prerender };
 var Prerender;
@@ -60,18 +61,18 @@ var Prerender;
          * Load the postponed state for a given route from the file system, if it exists
          */
         async function loadPostponedState(outDir, pathname) {
-            let file;
+            let filePath;
             try {
-                file = Bun.file(path.join(getPath(outDir, pathname), 'postponed.json'));
+                filePath = path.join(getPath(outDir, pathname), 'postponed.json');
             }
             catch (err) {
                 logger.warn(`[prerender:artifacts] rejected postponed state path for ${pathname}`, Logger.print(err));
                 return null;
             }
-            if (!(await file.exists()))
+            if (!(await AdapterRuntime.exists(filePath)))
                 return null;
             try {
-                return JSON.parse(await file.text());
+                return JSON.parse(await AdapterRuntime.readText(filePath));
             }
             catch {
                 return null;
@@ -82,18 +83,18 @@ var Prerender;
          * Load the prelude HTML for a given route from the file system, if it exists
          */
         async function loadPrelude(outDir, pathname) {
-            let file;
+            let filePath;
             try {
-                file = Bun.file(path.join(getPath(outDir, pathname), 'prelude.html'));
+                filePath = path.join(getPath(outDir, pathname), 'prelude.html');
             }
             catch (err) {
                 logger.warn(`[prerender:artifacts] rejected prelude path for ${pathname}`, Logger.print(err));
                 return null;
             }
-            if (!(await file.exists()))
+            if (!(await AdapterRuntime.exists(filePath)))
                 return null;
             try {
-                return await file.text();
+                return await AdapterRuntime.readText(filePath);
             }
             catch {
                 return null;
@@ -104,18 +105,18 @@ var Prerender;
          * Load the prerender artifact metadata for a given route from the file system, if it exists and is valid
          */
         async function loadMetadata(outDir, pathname) {
-            let file;
+            let filePath;
             try {
-                file = Bun.file(path.join(getPath(outDir, pathname), 'metadata.json'));
+                filePath = path.join(getPath(outDir, pathname), 'metadata.json');
             }
             catch (err) {
                 logger.warn(`[prerender:artifacts] rejected metadata path for ${pathname}`, Logger.print(err));
                 return null;
             }
-            if (!(await file.exists()))
+            if (!(await AdapterRuntime.exists(filePath)))
                 return null;
             try {
-                const value = JSON.parse(await file.text());
+                const value = JSON.parse(await AdapterRuntime.readText(filePath));
                 if (!value || typeof value !== 'object')
                     return null;
                 const schema = value.schema;
@@ -270,7 +271,7 @@ var Prerender;
             const params = await buildContext.exportReader.value(filePath, 'params', (v) => typeof v === 'function');
             if (!params)
                 return [];
-            const resolved = await Promise.try(() => params());
+            const resolved = await Promise.resolve().then(() => params());
             if (!Array.isArray(resolved))
                 return [];
             return resolved;

package/dist/internal/runtimes/bun.d.ts

@@ -0,0 +1,9 @@
+import { RuntimeBase } from './runtime.js';
+export declare class RuntimeBun extends RuntimeBase {
+    exists(filePath: string): Promise<boolean>;
+    readText(filePath: string): Promise<string>;
+    readBuffer(filePath: string): Promise<ArrayBuffer>;
+    mimeType(filePath: string): string;
+    write(filePath: string, content: string | NodeJS.ArrayBufferView): Promise<void>;
+    hash(value: string): string;
+}

package/dist/internal/runtimes/bun.js

@@ -0,0 +1,33 @@
+import { RuntimeBase } from './runtime.js';
+export class RuntimeBun extends RuntimeBase {
+    async exists(filePath) {
+        return Bun.file(filePath).exists();
+    }
+    readText(filePath) {
+        return Bun.file(filePath).text();
+    }
+    readBuffer(filePath) {
+        return Bun.file(filePath).arrayBuffer();
+    }
+    mimeType(filePath) {
+        return Bun.file(filePath).type || 'application/octet-stream';
+    }
+    async write(filePath, content) {
+        // normalise wider arraybuffer views into a shape Bun.write accepts directly
+        await Bun.write(filePath, typeof content === 'string'
+            ? content
+            : content instanceof Uint8Array
+                ? content
+                : new Uint8Array(content.buffer, content.byteOffset, content.byteLength));
+    }
+    hash(value) {
+        const hash = Bun.hash(value);
+        // Bun.hash returns an integer-like value, so keep it in BigInt space and avoid
+        // precision loss. Clamp it to an unsigned 64-bit value before hex
+        // formatting. Pad to 16 chars to match the Node runtime
+        // output shape
+        return BigInt.asUintN(64, typeof hash === 'bigint' ? hash : BigInt(hash))
+            .toString(16)
+            .padStart(16, '0');
+    }
+}

package/dist/internal/runtimes/node.d.ts

@@ -0,0 +1,9 @@
+import { RuntimeBase } from './runtime.js';
+export declare class RuntimeNode extends RuntimeBase {
+    exists(filePath: string): Promise<boolean>;
+    readText(filePath: string): Promise<string>;
+    readBuffer(filePath: string): Promise<ArrayBuffer>;
+    mimeType(filePath: string): string;
+    write(filePath: string, content: string | NodeJS.ArrayBufferView): Promise<void>;
+    hash(value: string): string;
+}

package/dist/internal/runtimes/node.js

@@ -0,0 +1,31 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import { lookup } from 'mime-types';
+import { RuntimeBase } from './runtime.js';
+export class RuntimeNode extends RuntimeBase {
+    async exists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    readText(filePath) {
+        return fs.readFile(filePath, 'utf-8');
+    }
+    async readBuffer(filePath) {
+        const buffer = await fs.readFile(filePath);
+        return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    }
+    mimeType(filePath) {
+        return lookup(filePath) || 'application/octet-stream';
+    }
+    async write(filePath, content) {
+        await fs.writeFile(filePath, content);
+    }
+    hash(value) {
+        return createHash('sha256').update(value).digest('hex').slice(0, 16);
+    }
+}

package/dist/internal/runtimes/runtime.d.ts

@@ -0,0 +1,29 @@
+export declare namespace Runtime {
+    type Impl = {
+        exists: (filePath: string) => Promise<boolean>;
+        readText: (filePath: string) => Promise<string>;
+        readBuffer: (filePath: string) => Promise<ArrayBuffer>;
+        mimeType: (filePath: string) => string;
+        write: (filePath: string, content: string | NodeJS.ArrayBufferView) => Promise<void>;
+        hash: (value: string) => string;
+    };
+}
+export declare abstract class RuntimeBase implements Runtime.Impl {
+    abstract exists(filePath: string): Promise<boolean>;
+    abstract readText(filePath: string): Promise<string>;
+    abstract readBuffer(filePath: string): Promise<ArrayBuffer>;
+    abstract mimeType(filePath: string): string;
+    abstract write(filePath: string, content: string | NodeJS.ArrayBufferView): Promise<void>;
+    abstract hash(value: string): string;
+}
+export declare class Runtime {
+    #private;
+    static set runtime(runtime: Runtime.Impl);
+    static get runtime(): Runtime.Impl;
+    static exists(filePath: string): Promise<boolean>;
+    static readText(filePath: string): Promise<string>;
+    static readBuffer(filePath: string): Promise<ArrayBuffer>;
+    static mimeType(filePath: string): string;
+    static write(filePath: string, content: string | NodeJS.ArrayBufferView): Promise<void>;
+    static hash(value: string): string;
+}

package/dist/internal/runtimes/runtime.js

@@ -0,0 +1,32 @@
+export class RuntimeBase {
+}
+export class Runtime {
+    static #runtime;
+    static set runtime(runtime) {
+        this.#runtime = runtime;
+    }
+    static get runtime() {
+        if (!this.#runtime) {
+            throw new Error('No runtime configured. Please set the runtime implementation before using runtime methods.');
+        }
+        return this.#runtime;
+    }
+    static exists(filePath) {
+        return this.runtime.exists(filePath);
+    }
+    static readText(filePath) {
+        return this.runtime.readText(filePath);
+    }
+    static readBuffer(filePath) {
+        return this.runtime.readBuffer(filePath);
+    }
+    static mimeType(filePath) {
+        return this.runtime.mimeType(filePath);
+    }
+    static write(filePath, content) {
+        return this.runtime.write(filePath, content);
+    }
+    static hash(value) {
+        return this.runtime.hash(value);
+    }
+}

package/dist/runtimes/bun.d.ts

@@ -0,0 +1,13 @@
+import { RuntimeBase } from '../internal/runtimes/runtime.js';
+declare class BunAdapter extends RuntimeBase {
+    readonly name: "bun";
+    readonly module: string;
+    exists(filePath: string): Promise<boolean>;
+    readText(filePath: string): Promise<string>;
+    readBuffer(filePath: string): Promise<ArrayBuffer>;
+    mimeType(filePath: string): string;
+    write(filePath: string, content: string | NodeJS.ArrayBufferView): Promise<void>;
+    hash(value: string): string;
+}
+export default function bunAdapter(): BunAdapter;
+export {};

package/dist/runtimes/bun.js

@@ -0,0 +1,39 @@
+import { RuntimeBase } from '../internal/runtimes/runtime.js';
+import { Solas } from '../solas.js';
+class BunAdapter extends RuntimeBase {
+    name = 'bun';
+    module = `${Solas.Config.PKG_NAME}/runtimes/bun`;
+    async exists(filePath) {
+        return Bun.file(filePath).exists();
+    }
+    readText(filePath) {
+        return Bun.file(filePath).text();
+    }
+    readBuffer(filePath) {
+        return Bun.file(filePath).arrayBuffer();
+    }
+    mimeType(filePath) {
+        return Bun.file(filePath).type || 'application/octet-stream';
+    }
+    async write(filePath, content) {
+        // normalise wider arraybuffer views into a shape Bun.write accepts directly
+        await Bun.write(filePath, typeof content === 'string'
+            ? content
+            : content instanceof Uint8Array
+                ? content
+                : new Uint8Array(content.buffer, content.byteOffset, content.byteLength));
+    }
+    hash(value) {
+        const hash = Bun.hash(value);
+        // Bun.hash returns an integer-like value, so keep it in BigInt space and avoid
+        // precision loss. Clamp it to an unsigned 64-bit value before hex
+        // formatting. Pad to 16 chars to match the Node adapter
+        // output shape
+        return BigInt.asUintN(64, typeof hash === 'bigint' ? hash : BigInt(hash))
+            .toString(16)
+            .padStart(16, '0');
+    }
+}
+export default function bunAdapter() {
+    return new BunAdapter();
+}