@jk2908/solas 0.6.0 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # 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

package/README.md

@@ -201,16 +201,6 @@ That keeps your route params aligned across links, imperative navigation, metada
 
 All Solas options are passed to `solas()` inside `defineConfig`.
 
-### `runtime`
-
-Use `runtime` 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.
-
 ### `url`
 
 Use `url` to set the public origin for your app. It is optional.
@@ -519,26 +509,11 @@ export default 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.
 
-### 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()],
-})
-```
+## Scripts
 
-Use the normal Vite commands with the Node runtime:
+Add scripts to your app:
 
 ```json
 {
@@ -550,22 +525,7 @@ Use the normal Vite commands with the Node runtime:
 }
 ```
 
-### 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:
+If you run Vite through Bun, use the Bun-backed commands instead:
 
 ```json
 {
@@ -577,22 +537,6 @@ When you use the Bun runtime, run Vite through Bun so the server/runtime code ex
 }
 ```
 
-## Scripts
-
-Add scripts to your app:
-
-```json
-{
-	"scripts": {
-		"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
 
 - `vite dev` starts the development server.

package/dist/config.d.ts

@@ -13,7 +13,6 @@ 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 RUNTIMES: readonly ["auto", "node", "bun"];
 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";

package/dist/config.js

@@ -1,4 +1,3 @@
-import * as Config from './config.js';
 export const NAME = 'Solas';
 export const SLUG = NAME.toLowerCase();
 export const PKG_NAME = `@jk2908/${SLUG}`;
@@ -13,12 +12,10 @@ 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 RUNTIMES = ['auto', 'node', 'bun'];
 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([
-    'runtime',
     'logger',
     'metadata',
     'precompress',
@@ -46,9 +43,6 @@ export function validate(input) {
             errors.push(`Unknown config key: ${key}`);
         }
     }
-    if ('runtime' in input && input.runtime !== undefined && !isRuntime(input.runtime)) {
-        errors.push("runtime must be 'auto', 'node', or 'bun'");
-    }
     if ('url' in input && input.url !== undefined) {
         if (typeof input.url !== 'string') {
             errors.push('url must be a string');
@@ -147,6 +141,3 @@ export function validate(input) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-function isRuntime(value) {
-    return typeof value === 'string' && new Set(Config.RUNTIMES).has(value);
-}

package/dist/index.js

@@ -16,10 +16,8 @@ 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';
 const DEFAULT_CONFIG = {
-    runtime: 'auto',
     precompress: false,
     prerender: false,
     trustedOrigins: [],
@@ -30,11 +28,9 @@ function solas(c) {
     const config = {
         ...DEFAULT_CONFIG,
         ...validatedConfig,
-        runtime: validatedConfig.runtime ?? DEFAULT_CONFIG.runtime,
     };
     const envUrl = process.env.VITE_APP_URL?.toString();
     let resolvedUrl = c?.url ?? (envUrl && envUrl.length > 0 ? envUrl : undefined);
-    Runtime.runtime = createRuntime(config.runtime);
     if (config.logger?.level)
         Logger.defaultLevel = config.logger.level;
     const logger = new Logger();

package/dist/internal/codegen/config.js

@@ -4,7 +4,6 @@ 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 { RuntimeConfig } from '${Config.PKG_NAME}'`,
@@ -12,7 +11,7 @@ export function writeConfig(config) {
     ]
         .filter(Boolean)
         .join('\n');
-    const configStatement = `const config = ${toSourceLiteral(runtimeConfig)} as const satisfies RuntimeConfig`;
+    const configStatement = `const config = ${toSourceLiteral(config)} as const satisfies RuntimeConfig`;
     const loggerStatement = loggerLevel
         ? `Logger.defaultLevel = ${toSourceLiteral(loggerLevel)}`
         : '';

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

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

package/dist/internal/codegen/environments.js

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

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

@@ -2,7 +2,6 @@ import type { ReactFormState } from 'react-dom/client';
 import type { ImportMap, Manifest, RuntimeConfig } from '../../types.js';
 import * as RuntimeManifest from '../../manifest.js';
 import { Metadata } from '../metadata.js';
-export { createRuntime } from '../runtimes/create.js';
 export { Runtime } from '../runtimes/runtime.js';
 export { loadManifest } from '../../manifest.js';
 export type RscPayload = {

package/dist/internal/env/rsc.js

@@ -17,7 +17,6 @@ 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 { createRuntime } from '../runtimes/create.js';
 export { Runtime } from '../runtimes/runtime.js';
 export { loadManifest } from '../../manifest.js';
 const logger = new Logger();

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

@@ -1,25 +1,11 @@
-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;
-}
+/**
+ * A single filesystem/hash/mime implementation shared by every runtime.
+ *
+ * Bun runs the Node standard library natively, so there is no need for
+ * per-runtime adapters: `node:fs` and `node:crypto` behave identically under
+ * Bun and Node, and mime lookups go through the same table for both.
+ */
 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>;

package/dist/internal/runtimes/runtime.js

@@ -1,32 +1,37 @@
-export class RuntimeBase {
-}
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import { getMimeTypeFromPath } from './mime.js';
+/**
+ * A single filesystem/hash/mime implementation shared by every runtime.
+ *
+ * Bun runs the Node standard library natively, so there is no need for
+ * per-runtime adapters: `node:fs` and `node:crypto` behave identically under
+ * Bun and Node, and mime lookups go through the same table for both.
+ */
 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.');
+    static async exists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
         }
-        return this.#runtime;
-    }
-    static exists(filePath) {
-        return this.runtime.exists(filePath);
     }
     static readText(filePath) {
-        return this.runtime.readText(filePath);
+        return fs.readFile(filePath, 'utf-8');
     }
-    static readBuffer(filePath) {
-        return this.runtime.readBuffer(filePath);
+    static async readBuffer(filePath) {
+        const buffer = await fs.readFile(filePath);
+        return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
     }
     static mimeType(filePath) {
-        return this.runtime.mimeType(filePath);
+        return getMimeTypeFromPath(filePath);
     }
     static write(filePath, content) {
-        return this.runtime.write(filePath, content);
+        return fs.writeFile(filePath, content);
     }
     static hash(value) {
-        return this.runtime.hash(value);
+        return createHash('sha256').update(value).digest('hex').slice(0, 16);
     }
 }

package/dist/types.d.ts

@@ -9,10 +9,8 @@ import type { HttpException } from './internal/navigation/http-exception.js';
 import * as Config from './config.js';
 import * as Build from './internal/build.js';
 export type LogLevel = (typeof Config.LOG_LEVELS)[number];
-export type Runtime = (typeof Config.RUNTIMES)[number];
 export type Origin = `http://${string}` | `https://${string}`;
 type PluginConfigBase = {
-    runtime?: Runtime;
     precompress?: boolean;
     prerender?: Route.Prerender;
     metadata?: Metadata.Item;
@@ -28,10 +26,8 @@ export type PluginConfig = PluginConfigBase & {
         routes: (existing: string[]) => string[] | Promise<string[]>;
     };
 };
-export type ConfiguredPluginConfig = PluginConfig & {
-    runtime: Runtime;
-};
-export type RuntimeConfig = Omit<PluginConfig, 'runtime'> & {
+export type ConfiguredPluginConfig = PluginConfig;
+export type RuntimeConfig = PluginConfig & {
     precompress: NonNullable<PluginConfig['precompress']>;
     trailingSlash: NonNullable<PluginConfig['trailingSlash']>;
     trustedOrigins: NonNullable<PluginConfig['trustedOrigins']>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jk2908/solas",
-	"version": "0.6.0",
+	"version": "0.7.0",
 	"description": "A Vite + React meta-framework exploring streaming, Server Components, and partial prerendering. Designed for simplicity and lightness",
 	"keywords": [
 		"framework",

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

@@ -1,9 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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/create.d.ts

@@ -1,4 +0,0 @@
-import type { Runtime } from '../../types.js';
-import { RuntimeBun } from './bun.js';
-import { RuntimeNode } from './node.js';
-export declare function createRuntime(runtime: Runtime): RuntimeBun | RuntimeNode;

package/dist/internal/runtimes/create.js

@@ -1,9 +0,0 @@
-import { RuntimeBun } from './bun.js';
-import { RuntimeNode } from './node.js';
-export function createRuntime(runtime) {
-    if (runtime === 'bun' ||
-        (runtime === 'auto' && typeof globalThis.Bun !== 'undefined')) {
-        return new RuntimeBun();
-    }
-    return new RuntimeNode();
-}

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

@@ -1,9 +0,0 @@
-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

@@ -1,31 +0,0 @@
-import { createHash } from 'node:crypto';
-import fs from 'node:fs/promises';
-import { getMimeTypeFromPath } from './mime.js';
-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 getMimeTypeFromPath(filePath);
-    }
-    async write(filePath, content) {
-        await fs.writeFile(filePath, content);
-    }
-    hash(value) {
-        return createHash('sha256').update(value).digest('hex').slice(0, 16);
-    }
-}