@jk2908/solas 0.3.8 → 0.4.1

package/dist/solas.js

@@ -12,12 +12,14 @@ var Solas;
         Config.ENTRY_RSC = 'entry.rsc.tsx';
         Config.ENTRY_SSR = 'entry.ssr.tsx';
         Config.ENTRY_BROWSER = 'entry.browser.tsx';
-        Config.ASSETS_DIR = 'assets';
+        Config.ASSETS_DIR = `_${Config.SLUG}`;
+        Config.PUBLIC_DIR = 'public';
         Config.$ = Symbol(Config.SLUG);
         Config.REQUEST_META_KEY = `__${Config.SLUG.toUpperCase()}__`;
         Config.LOG_LEVELS = ['debug', 'info', 'warn', 'error', 'fatal'];
         Config.PRERENDER_MODES = ['full', 'ppr', false];
         Config.TRAILING_SLASH_MODES = ['always', 'never', 'ignore'];
+        Config.RUNTIME_MANIFEST = 'runtime-manifest.json';
         const CONFIG_KEYS = new Set([
             'port',
             'logger',
@@ -25,6 +27,7 @@ var Solas;
             'precompress',
             'prerender',
             'sitemap',
+            'trustedOrigins',
             'trailingSlash',
             'url',
         ]);
@@ -67,6 +70,33 @@ var Solas;
                     errors.push('config.precompress must be a boolean');
                 }
             }
+            if ('trustedOrigins' in input && input.trustedOrigins !== undefined) {
+                if (!Array.isArray(input.trustedOrigins)) {
+                    errors.push('config.trustedOrigins must be an array of origins');
+                }
+                else {
+                    for (const [index, value] of input.trustedOrigins.entries()) {
+                        if (typeof value !== 'string') {
+                            errors.push(`config.trustedOrigins[${index}] must be a string`);
+                            continue;
+                        }
+                        try {
+                            const url = new URL(value);
+                            const canonical = value.replace(/\/$/, '');
+                            if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+                                errors.push(`config.trustedOrigins[${index}] must use http:// or https://`);
+                                continue;
+                            }
+                            if (canonical !== url.origin) {
+                                errors.push(`config.trustedOrigins[${index}] must be an origin without a path, query, or hash`);
+                            }
+                        }
+                        catch {
+                            errors.push(`config.trustedOrigins[${index}] must be a valid URL origin`);
+                        }
+                    }
+                }
+            }
             if ('sitemap' in input && input.sitemap !== undefined && input.sitemap !== false) {
                 if (typeof input.sitemap !== 'boolean' && typeof input.sitemap !== 'object') {
                     errors.push('config.sitemap must be a boolean or an object with a routes function');
@@ -129,6 +159,91 @@ var Solas;
         return value;
     }
     Solas.getVersion = getVersion;
+    let Runtime;
+    (function (Runtime) {
+        const manifestCache = new Map();
+        function getManifestPath(outDir) {
+            return [outDir, Config.GENERATED_DIR, Config.RUNTIME_MANIFEST]
+                .map((part, index) => {
+                const normalised = part.replace(/\\/g, '/').replace(/\/+/g, '/');
+                if (index === 0)
+                    return normalised.replace(/\/+$/, '');
+                return normalised.replace(/^\/+/, '').replace(/\/+$/, '');
+            })
+                .join('/');
+        }
+        Runtime.getManifestPath = getManifestPath;
+        async function loadManifest(outDir) {
+            if (manifestCache.has(outDir)) {
+                return manifestCache.get(outDir) ?? null;
+            }
+            const file = Bun.file(getManifestPath(outDir));
+            if (!(await file.exists())) {
+                manifestCache.set(outDir, null);
+                return null;
+            }
+            try {
+                const value = JSON.parse(await file.text());
+                if (!isRecord(value)) {
+                    manifestCache.set(outDir, null);
+                    return null;
+                }
+                const artifacts = value.artifacts ?? value.routes;
+                const publicFiles = value.publicFiles;
+                if (!isRecord(artifacts)) {
+                    manifestCache.set(outDir, null);
+                    return null;
+                }
+                if (publicFiles !== undefined && !Array.isArray(publicFiles)) {
+                    manifestCache.set(outDir, null);
+                    return null;
+                }
+                for (const entry of Object.values(artifacts)) {
+                    if (!isRecord(entry)) {
+                        manifestCache.set(outDir, null);
+                        return null;
+                    }
+                    const { mode, files } = entry;
+                    if (mode !== 'full' && mode !== 'ppr') {
+                        manifestCache.set(outDir, null);
+                        return null;
+                    }
+                    if (files !== undefined) {
+                        if (!Array.isArray(files)) {
+                            manifestCache.set(outDir, null);
+                            return null;
+                        }
+                        for (const file of files) {
+                            if (file !== 'html' &&
+                                file !== 'prelude' &&
+                                file !== 'postponed' &&
+                                file !== 'metadata') {
+                                manifestCache.set(outDir, null);
+                                return null;
+                            }
+                        }
+                    }
+                }
+                for (const entry of publicFiles ?? []) {
+                    if (typeof entry !== 'string' || !entry.startsWith('/')) {
+                        manifestCache.set(outDir, null);
+                        return null;
+                    }
+                }
+                const manifest = {
+                    artifacts: artifacts,
+                    publicFiles: new Set(publicFiles ?? []),
+                };
+                manifestCache.set(outDir, manifest);
+                return manifest;
+            }
+            catch {
+                manifestCache.set(outDir, null);
+                return null;
+            }
+        }
+        Runtime.loadManifest = loadManifest;
+    })(Runtime = Solas.Runtime || (Solas.Runtime = {}));
     let Events;
     (function (Events) {
         Events.names = {

package/dist/types.d.ts

@@ -2,35 +2,38 @@ type BunRequest = Request & {
     params?: Record<string, string | string[]>;
 };
 import { ExportReader } from './utils/export-reader.js';
+import type { BrowserRouter } from './internal/browser-router/shared.js';
 import type { Build } from './internal/build.js';
 import type { HttpRouter } from './internal/http-router/router.js';
 import type { Metadata } from './internal/metadata.js';
 import type { HttpException } from './internal/navigation/http-exception.js';
-import { BrowserRouter } from './internal/browser-router/router.js';
 import { Solas } from './solas.js';
 export type LogLevel = (typeof Solas.Config.LOG_LEVELS)[number];
+type Origin = `http://${string}` | `https://${string}`;
 type PluginConfigBase = {
     port?: number;
     precompress?: boolean;
     prerender?: Route.Prerender;
     metadata?: Metadata.Item;
     trailingSlash?: (typeof Solas.Config.TRAILING_SLASH_MODES)[number];
+    trustedOrigins?: readonly Origin[];
     readonly logger?: {
         level?: LogLevel;
     };
 };
 export type PluginConfig = PluginConfigBase & ({
-    url: `http://${string}` | `https://${string}`;
+    url: Origin;
     sitemap: true | {
         routes: (existing: string[]) => string[] | Promise<string[]>;
     };
 } | {
-    url?: `http://${string}` | `https://${string}`;
+    url?: Origin;
     sitemap?: false;
 });
 export type RuntimeConfig = PluginConfig & {
     precompress: NonNullable<PluginConfig['precompress']>;
     trailingSlash: NonNullable<PluginConfig['trailingSlash']>;
+    trustedOrigins: NonNullable<PluginConfig['trustedOrigins']>;
 };
 export type BuildContext = {
     prerenderRoutes: Set<string>;
@@ -99,6 +102,8 @@ export type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' |
 export type Primitive = string | number | boolean | bigint | symbol | null | undefined;
 export type LooseNumber<T extends number> = T | (number & {});
 export type BuildManifest = {
+    base: string;
+    publicFiles: string[];
     prerenderRoutes: string[];
     sitemapRoutes: string[];
     precompress: boolean;

package/dist/utils/base-path.d.ts

@@ -0,0 +1,14 @@
+export declare namespace BasePath {
+    /**
+     * Normalise a base path so every check uses the same shape
+     */
+    function normalise(value: string | null | undefined): string;
+    /**
+     * Strip the base path from a request path
+     */
+    function strip(pathname: string, base: string | null | undefined): string | null;
+    /**
+     * Add the base path to a path when needed
+     */
+    function apply(pathname: string, base: string | null | undefined): string;
+}

package/dist/utils/base-path.js

@@ -0,0 +1,85 @@
+export { BasePath };
+var BasePath;
+(function (BasePath) {
+    /**
+     * Normalise a base path so every check uses the same shape
+     */
+    function normalise(value) {
+        // no base means the app lives at the site root
+        if (!value)
+            return '/';
+        if (value === '/' || value === '.' || value === './')
+            return '/';
+        let pathname = value.trim();
+        if (!pathname)
+            return '/';
+        // plain path bases are the common case, so keep them cheap
+        if (!pathname.startsWith('http://') && !pathname.startsWith('https://')) {
+            const hashIndex = pathname.indexOf('#');
+            const searchIndex = pathname.indexOf('?');
+            const end = hashIndex === -1
+                ? searchIndex
+                : searchIndex === -1
+                    ? hashIndex
+                    : Math.min(hashIndex, searchIndex);
+            if (end >= 0)
+                pathname = pathname.slice(0, end);
+        }
+        else {
+            try {
+                // full urls can still show up here, but we only need the path part
+                pathname = new URL(pathname).pathname;
+            }
+            catch {
+                // if parsing fails, fall back to the raw value below
+            }
+        }
+        if (!pathname || pathname === '.' || pathname === './')
+            return '/';
+        // keep one stable shape: leading slash, trailing slash
+        if (!pathname.startsWith('/'))
+            pathname = `/${pathname}`;
+        return pathname.endsWith('/') ? pathname : `${pathname}/`;
+    }
+    BasePath.normalise = normalise;
+    /**
+     * Strip the base path from a request path
+     */
+    function strip(pathname, base) {
+        const normalisedBase = normalise(base);
+        // root base means there is nothing to strip
+        if (normalisedBase === '/')
+            return pathname || '/';
+        const basePath = normalisedBase.slice(0, -1);
+        // treat both '/docs' and '/docs/' as the app root
+        if (pathname === basePath || pathname === normalisedBase)
+            return '/';
+        // paths outside the base do not belong to this app
+        if (!pathname.startsWith(`${basePath}/`))
+            return null;
+        // return the path as the app should see it
+        return pathname.slice(basePath.length) || '/';
+    }
+    BasePath.strip = strip;
+    /**
+     * Add the base path to a path when needed
+     */
+    function apply(pathname, base) {
+        const normalisedBase = normalise(base);
+        // always work with a path-like value
+        const target = pathname.startsWith('/') ? pathname : `/${pathname}`;
+        // root base means the path can pass through unchanged
+        if (normalisedBase === '/')
+            return target;
+        const basePath = normalisedBase.slice(0, -1);
+        // leave it alone if the base is already there
+        if (target === basePath || target.startsWith(`${basePath}/`))
+            return target;
+        // the app root maps to the base path itself
+        if (target === '/')
+            return normalisedBase;
+        // everything else sits underneath the base path
+        return `${basePath}${target}`;
+    }
+    BasePath.apply = apply;
+})(BasePath || (BasePath = {}));

package/dist/utils/export-reader.js

@@ -84,17 +84,23 @@ export class ExportReader {
      * The export must be in the form of `export const|let|var name = <literal>`
      */
     async literal(filePath, name, validate) {
-        const code = await this.raw(filePath);
+        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 `
-        '\\bexport\\s+(?:const|let|var)\\s+' +
+        // 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|;|$)';
-        const text = code.match(new RegExp(source))?.groups?.value;
+        // 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

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jk2908/solas",
-	"version": "0.3.8",
-	"description": "A React Server Components meta-framework powered by Vite",
+	"version": "0.4.1",
+	"description": "A Vite + React meta-framework exploring streaming, Server Components, and partial prerendering. Designed for simplicity and lightness",
 	"keywords": [
 		"framework",
 		"ppr",
@@ -17,10 +17,7 @@
 	"license": "MIT",
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/jk2908/solas.git"
-	},
-	"bin": {
-		"solas": "./dist/cli.js"
+		"url": "git+https://github.com/jk2908/solas.git"
 	},
 	"files": [
 		"dist",
@@ -74,7 +71,7 @@
 		}
 	},
 	"scripts": {
-		"build": "rm -rf dist && tsgo && chmod +x dist/cli.js",
+		"build": "rm -rf dist && tsgo",
 		"lint": "bunx oxlint .",
 		"lint:fix": "bunx oxlint --fix .",
 		"format": "bunx oxfmt --write .",

package/dist/cli/build.d.ts

@@ -1,7 +0,0 @@
-/**
- * The build command does more than just run vite build - it also handles prerendering and
- * precompressing assets. This is because prerendering needs to run against the built
- * server entry to ensure the same code paths as preview, and precompressing needs
- * to include the prerendered html and json files
- */
-export declare function build(): Promise<void>;

package/dist/cli/dev.d.ts

@@ -1,4 +0,0 @@
-/**
- * Start the vite development server
- */
-export declare function dev(): Promise<void>;

package/dist/cli/dev.js

@@ -1,13 +0,0 @@
-/**
- * Start the vite development server
- */
-export async function dev() {
-    const proc = Bun.spawn(['bunx', '--bun', 'vite', 'dev'], {
-        cwd: process.cwd(),
-        stdout: 'inherit',
-        stderr: 'inherit',
-        stdin: 'inherit',
-        env: { ...process.env, NODE_ENV: 'development' },
-    });
-    await proc.exited;
-}

package/dist/cli/preview.d.ts

@@ -1 +0,0 @@
-export declare function preview(): Promise<void>;

package/dist/cli/preview.js

@@ -1,47 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { Logger } from '../utils/logger.js';
-import { Solas } from '../solas.js';
-const logger = new Logger();
-const DEFAULT_PREVIEW_PORT = 4173;
-const [, , , ...args] = process.argv;
-export async function preview() {
-    // preview should behave like production, not like vite dev
-    process.env.NODE_ENV = 'production';
-    const cwd = process.cwd();
-    const outDir = path.resolve(cwd, Solas.Config.OUT_DIR);
-    const rscDir = path.join(outDir, 'rsc');
-    const rscEntry = path.join(rscDir, 'index.js');
-    const portFlagIndex = args.findIndex(arg => arg === '--port' || arg === '-p');
-    const parsedPort = portFlagIndex >= 0 && args[portFlagIndex + 1]
-        ? Number(args[portFlagIndex + 1])
-        : DEFAULT_PREVIEW_PORT;
-    // fail fast if the port is invalid
-    if (!Number.isInteger(parsedPort) || parsedPort <= 0 || parsedPort > 65535) {
-        logger.error(`[preview] invalid port: ${args[portFlagIndex + 1] ?? 'undefined'}`);
-        process.exit(1);
-    }
-    // the built server entry handles routing, prerendered html, and ssr here
-    try {
-        await fs.access(rscEntry);
-    }
-    catch (err) {
-        logger.error(`[preview] missing ${path.relative(cwd, rscEntry)} - run \`${Solas.Config.SLUG} build\` from this project directory first`, err);
-        process.exit(1);
-    }
-    const { default: app } = await import(/* @vite-ignore */ rscEntry);
-    try {
-        // keep the preview server thin and let the app handle requests
-        Bun.serve({
-            port: parsedPort,
-            fetch: app.fetch,
-        });
-    }
-    catch (err) {
-        logger.error(`[preview] failed to start on port ${parsedPort}: ${err}`);
-        process.exit(1);
-    }
-    logger.info('[preview]', `server running at http://localhost:${parsedPort}`);
-    // keep the process running after the server starts
-    await new Promise(() => { });
-}

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-export {};

package/dist/cli.js

@@ -1,28 +0,0 @@
-#!/usr/bin/env bun
-import { build } from './cli/build.js';
-import { dev } from './cli/dev.js';
-import { preview } from './cli/preview.js';
-import { Solas } from './solas.js';
-// read the subcommand once and dispatch below
-const [, , command] = process.argv;
-switch (command) {
-    case 'build':
-        await build();
-        break;
-    case 'dev':
-        await dev();
-        break;
-    case 'preview':
-        await preview();
-        break;
-    default:
-        console.log(`
-			${Solas.Config.NAME} - cli
-
-			Commands:
-				build    Build for production (vite build + prerender + compress)
-				dev      Start development server
-				preview  Preview production build (serves prerendered HTML with SSR fallback)
-		`);
-        process.exit(command ? 1 : 0);
-}