@jk2908/solas 0.4.3 → 0.5.0

package/dist/solas.d.ts

@@ -1,5 +1,6 @@
 import type { Prerender } from './internal/prerender.js';
-import type { PluginConfig } from './types.js';
+import type { PluginConfig, Runtime } from './types.js';
+import { Runtime as InternalRuntime } from './internal/runtimes/runtime.js';
 export declare namespace Solas {
     interface Routes {
     }
@@ -18,6 +19,7 @@ export declare namespace Solas {
         const $: unique symbol;
         const REQUEST_META_KEY: string;
         const LOG_LEVELS: readonly ["debug", "info", "warn", "error", "fatal"];
+        const RUNTIMES: readonly ["auto", "node", "bun"];
         const PRERENDER_MODES: readonly ["full", "ppr", false];
         const TRAILING_SLASH_MODES: readonly ["always", "never", "ignore"];
         const RUNTIME_MANIFEST = "runtime-manifest.json";
@@ -34,6 +36,7 @@ export declare namespace Solas {
             artifacts: Prerender.Artifact.Manifest;
             publicFiles: ReadonlySet<string>;
         };
+        function create(runtime: Runtime): InternalRuntime.Impl;
         function getManifestPath(outDir: string): string;
         function loadManifest(outDir: string): Promise<Manifest | null>;
     }

package/dist/solas.js

@@ -1,3 +1,6 @@
+import { RuntimeBun } from './internal/runtimes/bun.js';
+import { RuntimeNode } from './internal/runtimes/node.js';
+import { Runtime as InternalRuntime } from './internal/runtimes/runtime.js';
 export { Solas };
 var Solas;
 (function (Solas) {
@@ -17,10 +20,12 @@ var Solas;
         Config.$ = Symbol(Config.SLUG);
         Config.REQUEST_META_KEY = `__${Config.SLUG.toUpperCase()}__`;
         Config.LOG_LEVELS = ['debug', 'info', 'warn', 'error', 'fatal'];
+        Config.RUNTIMES = ['auto', 'node', 'bun'];
         Config.PRERENDER_MODES = ['full', 'ppr', false];
         Config.TRAILING_SLASH_MODES = ['always', 'never', 'ignore'];
         Config.RUNTIME_MANIFEST = 'runtime-manifest.json';
         const CONFIG_KEYS = new Set([
+            'runtime',
             'port',
             'logger',
             'metadata',
@@ -49,6 +54,11 @@ var Solas;
                     errors.push(`Unknown config key: ${key}`);
                 }
             }
+            if ('runtime' in input &&
+                input.runtime !== undefined &&
+                !isRuntime(input.runtime)) {
+                errors.push("config.runtime must be 'auto', 'node', or 'bun'");
+            }
             if ('url' in input && input.url !== undefined) {
                 if (typeof input.url !== 'string') {
                     errors.push('config.url must be a string');
@@ -161,6 +171,14 @@ var Solas;
     Solas.getVersion = getVersion;
     let Runtime;
     (function (Runtime) {
+        function create(runtime) {
+            if (runtime === 'bun' ||
+                (runtime === 'auto' && typeof globalThis.Bun !== 'undefined')) {
+                return new RuntimeBun();
+            }
+            return new RuntimeNode();
+        }
+        Runtime.create = create;
         const manifestCache = new Map();
         function getManifestPath(outDir) {
             return [outDir, Config.GENERATED_DIR, Config.RUNTIME_MANIFEST]
@@ -177,13 +195,13 @@ var Solas;
             if (manifestCache.has(outDir)) {
                 return manifestCache.get(outDir) ?? null;
             }
-            const file = Bun.file(getManifestPath(outDir));
-            if (!(await file.exists())) {
+            const manifestPath = getManifestPath(outDir);
+            if (!(await InternalRuntime.exists(manifestPath))) {
                 manifestCache.set(outDir, null);
                 return null;
             }
             try {
-                const value = JSON.parse(await file.text());
+                const value = JSON.parse(await InternalRuntime.readText(manifestPath));
                 if (!isRecord(value)) {
                     manifestCache.set(outDir, null);
                     return null;
@@ -230,12 +248,12 @@ var Solas;
                         return null;
                     }
                 }
-                const manifest = {
+                const runtimeManifest = {
                     artifacts: artifacts,
                     publicFiles: new Set(publicFiles ?? []),
                 };
-                manifestCache.set(outDir, manifest);
-                return manifest;
+                manifestCache.set(outDir, runtimeManifest);
+                return runtimeManifest;
             }
             catch {
                 manifestCache.set(outDir, null);
@@ -255,3 +273,6 @@ var Solas;
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function isRuntime(value) {
+    return typeof value === 'string' && new Set(Solas.Config.RUNTIMES).has(value);
+}

package/dist/types.d.ts

@@ -9,8 +9,10 @@ import type { Metadata } from './internal/metadata.js';
 import type { HttpException } from './internal/navigation/http-exception.js';
 import { Solas } from './solas.js';
 export type LogLevel = (typeof Solas.Config.LOG_LEVELS)[number];
+export type Runtime = (typeof Solas.Config.RUNTIMES)[number];
 type Origin = `http://${string}` | `https://${string}`;
 type PluginConfigBase = {
+    runtime?: Runtime;
     port?: number;
     precompress?: boolean;
     prerender?: Route.Prerender;
@@ -30,7 +32,10 @@ export type PluginConfig = PluginConfigBase & ({
     url?: Origin;
     sitemap?: false;
 });
-export type RuntimeConfig = PluginConfig & {
+export type ConfiguredPluginConfig = PluginConfig & {
+    runtime: Runtime;
+};
+export type RuntimeConfig = Omit<PluginConfig, 'runtime'> & {
     precompress: NonNullable<PluginConfig['precompress']>;
     trailingSlash: NonNullable<PluginConfig['trailingSlash']>;
     trustedOrigins: NonNullable<PluginConfig['trustedOrigins']>;

package/dist/utils/compress.js

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { brotliCompress } from 'node:zlib';
+import { Runtime } from '../internal/runtimes/runtime.js';
 export { Compress };
 var Compress;
 (function (Compress) {
@@ -25,8 +26,7 @@ var Compress;
         return output;
     }
     async function compress(input) {
-        const file = Bun.file(input);
-        const buffer = Buffer.from(await file.arrayBuffer());
+        const buffer = Buffer.from(await Runtime.readBuffer(input));
         const compressed = await new Promise((fulfill, reject) => {
             brotliCompress(buffer, (err, res) => {
                 if (err) {

package/dist/utils/export-reader.js

@@ -1,9 +1,10 @@
+import fs from 'node:fs/promises';
 import path from 'node:path';
+import { parseSync, } from 'oxc-parser';
 export class ExportReader {
-    #transpilers = new Map();
     #loadModule = null;
     /**
-     * Pick the Bun loader type that matches the source file extension
+     * Pick the parser language that matches the source file extension
      */
     static #getLoaderType(filePath) {
         const ext = path.extname(filePath).toLowerCase();
@@ -17,28 +18,6 @@ export class ExportReader {
             return 'tsx';
         throw new Error(`Unsupported module extension: ${ext || '(none)'} in ${filePath}`);
     }
-    /**
-     * Parse a literal value from a string
-     */
-    static #parse(value) {
-        const trimmed = value.trim();
-        // keep quoted literals as strings without evaluating the
-        // source text
-        if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
-            (trimmed.startsWith("'") && trimmed.endsWith("'")) ||
-            (trimmed.startsWith('`') && trimmed.endsWith('`'))) {
-            return trimmed.slice(1, -1);
-        }
-        if (trimmed === 'true')
-            return true;
-        if (trimmed === 'false')
-            return false;
-        if (trimmed === 'null')
-            return null;
-        const n = Number(trimmed);
-        if (Number.isFinite(n))
-            return n;
-    }
     /**
      * Set the Vite server's SSR module loader so we can execute modules
      */
@@ -46,30 +25,35 @@ export class ExportReader {
         this.#loadModule = l;
     }
     /**
-     * Reuse one transpiler per supported loader so scans match the module syntax
+     * Parse a source file as an ESM route module
      */
-    #getTranspiler(filePath) {
-        const type = ExportReader.#getLoaderType(filePath);
-        const cached = this.#transpilers.get(type);
-        if (cached)
-            return cached;
-        const transpiler = new Bun.Transpiler({ loader: type });
-        this.#transpilers.set(type, transpiler);
-        return transpiler;
+    async #parse(filePath) {
+        const source = await this.raw(filePath);
+        const result = parseSync(filePath, source, {
+            lang: ExportReader.#getLoaderType(filePath),
+            sourceType: 'module',
+            preserveParens: false,
+        });
+        if (result.errors.length > 0) {
+            throw new Error(result.errors[0]?.message ?? `Failed to parse ${filePath}`);
+        }
+        return result;
     }
     /**
      * Read the raw text content of a file
      */
     async raw(filePath) {
-        return Bun.file(filePath).text();
+        return fs.readFile(filePath, 'utf-8');
     }
     /**
      * Get the names of all exports from a file
      */
     async exports(filePath) {
-        // use Bun's transpiler scan so we can inspect export names
-        // without loading the module
-        return this.#getTranspiler(filePath).scan(await this.raw(filePath)).exports;
+        const { module } = await this.#parse(filePath);
+        return Array.from(new Set(module.staticExports.flatMap((entry) => entry.entries
+            .filter((specifier) => !specifier.isType)
+            .map((specifier) => specifier.exportName.name)
+            .filter((name) => typeof name === 'string' && name.length > 0))));
     }
     /**
      * Check if a file exports a specific name
@@ -86,27 +70,8 @@ export class ExportReader {
     async literal(filePath, name, validate) {
         if (!(await this.has(filePath, name)))
             return;
-        // transpile first so comments and type-only syntax do not confuse the
-        // literal matcher with exports that do not actually exist at runtime
-        const code = this.#getTranspiler(filePath).transformSync(await this.raw(filePath));
-        // build the matcher from escaped plain-text pieces so arbitrary export names
-        // cannot change the regex shape
-        const source = 
-        // match: `export const|let|var ` at statement boundaries
-        '(?:^|[;\\n])\\s*export\\s+(?:const|let|var)\\s+' +
-            // treat export name as plain text in regex
-            name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
-            // capture one supported literal value (string, number, boolean, null)
-            '\\s*=\\s*(?<value>(?:"(?:[^"\\\\]|\\\\.)*"|\'(?:[^\'\\\\]|\\\\.)*\'|\\x60(?:[^\\x60\\\\]|\\\\.)*\\x60|true|false|null|-?\\d+(?:\\.\\d+)?))(?=\\s|;|$)';
-        // multiline mode lets ^ match the start of each transpiled line, so the
-        // export regex stays anchored to a real statement boundary instead of
-        // the file start
-        const text = code.match(new RegExp(source, 'm'))?.groups?.value;
-        if (!text)
-            return;
-        // only support cheap literal parsing here. Anything richer should go through
-        // value() so module semantics stay correct
-        const value = ExportReader.#parse(text);
+        const { program } = await this.#parse(filePath);
+        const value = ExportReader.#readLiteralExport(program, name);
         if (value === undefined)
             return;
         if (!validate || validate(value))
@@ -130,4 +95,50 @@ export class ExportReader {
         if (!validate || validate(value))
             return value;
     }
+    static #readLiteralExport(program, name) {
+        for (const statement of program.body) {
+            if (statement.type !== 'ExportNamedDeclaration')
+                continue;
+            const declaration = statement.declaration;
+            if (!declaration || declaration.type !== 'VariableDeclaration')
+                continue;
+            for (const declarator of declaration.declarations) {
+                if (declarator.id.type !== 'Identifier' || declarator.id.name !== name)
+                    continue;
+                return ExportReader.#readLiteralValue(declarator.init);
+            }
+        }
+    }
+    static #readLiteralValue(value) {
+        if (!value || typeof value !== 'object' || !('type' in value))
+            return;
+        const node = value;
+        if (node.type === 'Literal') {
+            const literal = value;
+            if (typeof literal.value === 'string' ||
+                typeof literal.value === 'number' ||
+                typeof literal.value === 'boolean' ||
+                literal.value === null) {
+                return literal.value;
+            }
+        }
+        if (node.type === 'TemplateLiteral' &&
+            Array.isArray(value.expressions) &&
+            value.expressions.length === 0 &&
+            Array.isArray(value.quasis) &&
+            value.quasis.length === 1) {
+            const quasi = value.quasis[0];
+            if (quasi?.value && typeof quasi.value.cooked === 'string') {
+                return quasi.value.cooked;
+            }
+        }
+        if (node.type === 'UnaryExpression' &&
+            value.operator === '-' &&
+            value.argument.type === 'Literal' &&
+            value.argument.value !== null &&
+            typeof value.argument.value === 'number') {
+            const argument = value.argument.value;
+            return -argument;
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jk2908/solas",
-	"version": "0.4.3",
+	"version": "0.5.0",
 	"description": "A Vite + React meta-framework exploring streaming, Server Components, and partial prerendering. Designed for simplicity and lightness",
 	"keywords": [
 		"framework",
@@ -33,6 +33,10 @@
 			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js"
 		},
+		"./$": {
+			"types": "./dist/solas.d.ts",
+			"import": "./dist/solas.js"
+		},
 		"./env/rsc": {
 			"types": "./dist/internal/env/rsc.d.ts",
 			"import": "./dist/internal/env/rsc.js"
@@ -82,11 +86,13 @@
 	},
 	"dependencies": {
 		"@vitejs/plugin-rsc": "^0.5.20",
+		"mime-types": "^3.0.2",
+		"oxc-parser": "^0.134.0",
 		"path-to-regexp": "^8.3.0"
 	},
 	"devDependencies": {
 		"@prettier/plugin-oxc": "^0.1.3",
-		"@types/bun": "^1.2.22",
+		"@types/mime-types": "^3.0.1",
 		"@typescript/native-preview": "^7.0.0-dev.20260224.1",
 		"network-information-types": "^0.1.1",
 		"oxfmt": "^0.35.0",
@@ -105,7 +111,5 @@
 			"optional": true
 		}
 	},
-	"engines": {
-		"bun": ">=1.2.0"
-	}
+	"engines": {}
 }