@jk2908/solas 0.4.4 → 0.5.0

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();
+}

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) {