@jk2908/solas 0.3.7 → 0.4.0

package/dist/internal/navigation/http-exception.js

@@ -4,8 +4,9 @@ export const HTTP_EXCEPTION_NAME_MAP = {
     404: 'NOT_FOUND',
     500: 'INTERNAL_SERVER_ERROR',
 };
+export const HTTP_EXCEPTION_DIGEST_PREFIX = 'HTTP_EXCEPTION';
 /**
- * An exception representing an HTTP error, with an optional payload
+ * An exception representing an HttpException error, with an optional payload
  * and cause
  */
 export class HttpException extends Error {
@@ -22,9 +23,14 @@ export class HttpException extends Error {
         this.digest = `${HTTP_EXCEPTION_DIGEST_PREFIX}:${status}:${message}`;
     }
 }
-export const HTTP_EXCEPTION_DIGEST_PREFIX = 'HTTP_EXCEPTION';
 /**
- * Check if an error is an HTTPException
+ * Status type predicate
+ */
+function isStatusCode(value) {
+    return value === 401 || value === 403 || value === 404 || value === 500;
+}
+/**
+ * Check if an error is an HttpException
  */
 export function isHttpException(err) {
     return (typeof err === 'object' &&
@@ -33,6 +39,41 @@ export function isHttpException(err) {
         typeof err.digest === 'string' &&
         err.digest.startsWith(HTTP_EXCEPTION_DIGEST_PREFIX));
 }
+/**
+ * Convert any error into an HttpException
+ */
+export function toHttpException(err) {
+    if (err instanceof HttpException)
+        return err;
+    let digestStatus;
+    let digestMessage;
+    if (typeof err === 'object' &&
+        err !== null &&
+        'digest' in err &&
+        typeof err.digest === 'string') {
+        const [type, rawStatus, ...rawMessageParts] = err.digest.split(':');
+        const status = Number(rawStatus);
+        if (type === HTTP_EXCEPTION_DIGEST_PREFIX && isStatusCode(status)) {
+            digestStatus = status;
+            digestMessage = rawMessageParts.join(':');
+        }
+    }
+    const status = digestStatus ??
+        (typeof err === 'object' &&
+            err !== null &&
+            'status' in err &&
+            isStatusCode(err.status)
+            ? err.status
+            : 500);
+    const message = digestMessage ||
+        (typeof err === 'object' &&
+            err !== null &&
+            'message' in err &&
+            typeof err.message === 'string'
+            ? err.message
+            : 'Internal Server Error');
+    return new HttpException(status, message, { cause: err });
+}
 /**
  * Convert an HttpException or any Error into a plain object that can be
  * safely serialised
@@ -41,18 +82,17 @@ export function toHttpExceptionLike(error) {
     return {
         name: error.name,
         message: error.message,
-        stack: error.stack,
         ...('digest' in error && typeof error.digest === 'string'
             ? { digest: error.digest }
             : {}),
         ...('payload' in error && error.payload !== undefined
             ? { payload: error.payload }
             : {}),
-        ...('status' in error ? { status: error.status } : {}),
+        ...('status' in error && isStatusCode(error.status) ? { status: error.status } : {}),
     };
 }
 /**
- * Throw an HTTPException
+ * Throw an HttpException
  */
 export function abort(status, message, opts) {
     throw new HttpException(status, message, {

package/dist/internal/postbuild.d.ts

@@ -0,0 +1 @@
+export declare function postbuild(cwd?: string): Promise<void>;

package/dist/{cli/build.js → internal/postbuild.js}

@@ -2,33 +2,11 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { Compress } from '../utils/compress.js';
 import { Logger } from '../utils/logger.js';
-import { Prerender } from '../internal/prerender.js';
 import { Solas } from '../solas.js';
+import { Prerender } from './prerender.js';
 const logger = new Logger();
-/**
- * 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 async function build() {
-    // build and prerender should both run in production mode
-    process.env.NODE_ENV = 'production';
-    const cwd = process.cwd();
+export async function postbuild(cwd = process.cwd()) {
     const manifestPath = path.join(cwd, Solas.Config.GENERATED_DIR, 'build.json');
-    // run vite build
-    logger.info('[build]', 'running vite build...');
-    const vite = Bun.spawnSync(['bunx', '--bun', 'vite', 'build', '--mode', 'production'], {
-        cwd,
-        stdout: 'inherit',
-        stderr: 'inherit',
-        env: { ...process.env, NODE_ENV: 'production' },
-    });
-    if (vite.exitCode !== 0) {
-        logger.error('[build] vite build failed');
-        process.exit(1);
-    }
-    // read build manifest
     let manifest;
     try {
         const raw = await fs.readFile(manifestPath, 'utf-8');
@@ -36,7 +14,7 @@ export async function build() {
     }
     catch (err) {
         logger.error('[build] failed to read build manifest', err);
-        process.exit(1);
+        throw err;
     }
     const outDir = path.resolve(cwd, Solas.Config.OUT_DIR);
     const rscDir = path.join(outDir, 'rsc');
@@ -44,16 +22,11 @@ export async function build() {
     // clear old prerender artifacts so routes that have switched modes
     // do not keep stale metadata from a previous build
     await fs.rm(artifactRoot, { recursive: true, force: true });
-    // prerender routes
+    const artifactManifest = {};
     if (manifest.prerenderRoutes.length > 0) {
-        const timeout = Prerender.Build.getTimeout();
         const concurrency = Prerender.Build.getConcurrency();
-        // track the extra prerender files we write for preview
-        const artifactManifest = {};
-        // keep in-flight artifact writes bounded so result handling does not block on one route at a time
         const pendingWrites = new Set();
-        logger.info('[prerender]', `prerendering ${manifest.prerenderRoutes.length} routes (timeout: ${timeout}ms, concurrency: ${concurrency})...`);
-        // load the built server entry and render each prerendered route through it
+        logger.info('[prerender]', `prerendering ${manifest.prerenderRoutes.length} routes (concurrency: ${concurrency})...`);
         const rscEntry = path.join(rscDir, 'index.js');
         const { default: app } = await import(/* @vite-ignore */ rscEntry);
         async function enqueueWrite(task) {
@@ -65,9 +38,8 @@ export async function build() {
                 await Promise.race(pendingWrites);
             }
         }
-        // run prerender through the built app so build output uses the same path as preview
         for await (const result of Prerender.Build.run(app, manifest.prerenderRoutes, {
-            timeout,
+            base: manifest.base,
             concurrency,
             origin: manifest.url,
         })) {
@@ -85,7 +57,6 @@ export async function build() {
             await enqueueWrite(async () => {
                 try {
                     if (artifact.mode === 'ppr') {
-                        // for ppr save the shell now and keep the postponed state for later
                         await fs.mkdir(artifactDir, { recursive: true });
                         const writes = [
                             Bun.write(path.join(artifactDir, 'prelude.html'), artifact.html),
@@ -120,9 +91,7 @@ export async function build() {
                         logger.info('[prerender]', `${route} (ppr)`);
                         return;
                     }
-                    // full prerender still keeps metadata so preview knows to serve saved html
                     await fs.mkdir(artifactDir, { recursive: true });
-                    const fullPrerenderFilename = Prerender.Artifact.FULL_PRERENDER_FILENAME;
                     await Promise.all([
                         Bun.write(path.join(artifactDir, 'metadata.json'), JSON.stringify({
                             schema: artifact.schema,
@@ -130,7 +99,7 @@ export async function build() {
                             createdAt: artifact.createdAt,
                             mode: artifact.mode,
                         })),
-                        Bun.write(Prerender.Artifact.getFilePath(outDir, route, fullPrerenderFilename), artifact.html),
+                        Bun.write(Prerender.Artifact.getFilePath(outDir, route, Prerender.Artifact.FULL_PRERENDER_FILENAME), artifact.html),
                     ]);
                     artifactManifest[route] = {
                         mode: artifact.mode,
@@ -144,13 +113,13 @@ export async function build() {
             });
         }
         await Promise.all(pendingWrites);
-        // write one manifest for the saved prerender files after all routes finish
-        await fs.mkdir(artifactRoot, { recursive: true });
-        await Bun.write(Prerender.Artifact.getManifestPath(outDir), JSON.stringify({
-            routes: artifactManifest,
-        }));
     }
-    // sitemap
+    await fs.mkdir(artifactRoot, { recursive: true });
+    const runtimeManifest = {
+        artifacts: artifactManifest,
+        publicFiles: manifest.publicFiles,
+    };
+    await Bun.write(Solas.Runtime.getManifestPath(outDir), JSON.stringify(runtimeManifest));
     if (manifest.sitemapRoutes.length > 0 && manifest.url) {
         const origin = manifest.url.replace(/\/$/, '');
         const urls = manifest.sitemapRoutes
@@ -165,10 +134,8 @@ export async function build() {
         await Bun.write(path.join(outDir, 'sitemap.xml'), sitemap);
         logger.info('[sitemap]', `generated ${manifest.sitemapRoutes.length} urls`);
     }
-    // precompress
     if (manifest.precompress) {
         logger.info('[precompress]', 'compressing assets...');
-        // compress after prerender so generated html and json are included too
         for await (const { input, compressed } of Compress.run(outDir, {
             filter: f => /\.(js|css|html|svg|json|txt)$/.test(f),
         })) {
@@ -176,8 +143,6 @@ export async function build() {
             logger.info('[precompress]', `${path.basename(input)}.br`);
         }
     }
-    // cleanup
-    // this file is only needed while the build command is running
     await fs.unlink(manifestPath).catch(() => { });
     logger.info('[build]', 'done');
 }

package/dist/internal/prerender.d.ts

@@ -22,11 +22,6 @@ export declare namespace Prerender {
          * based on the output directory specified in the configuration
          */
         function getRootPath(outDir: string): string;
-        /**
-         * Get the file system path for the prerender artifact manifest, which
-         * contains metadata about all prerendered routes and their artifacts
-         */
-        function getManifestPath(outDir: string): string;
         /**
          * Get the file system path for storing prerender artifacts for a given route
          */
@@ -39,10 +34,6 @@ export declare namespace Prerender {
          * File name used for saved full-prerender html inside each route artifact directory
          */
         const FULL_PRERENDER_FILENAME = "prerendered.html";
-        /**
-         * Load the prerender artifact manifest for faster runtime route mode checks
-         */
-        function loadManifest(outDir: string): Promise<Manifest | null>;
         /**
          * Load the postponed state for a given route from the file system, if it exists
          */
@@ -95,11 +86,6 @@ export declare namespace Prerender {
         function isPostponed(error: unknown): boolean;
     }
     namespace Build {
-        /**
-         * Get the prerender timeout value from the environment variable, or return the default
-         * if it's not set or invalid
-         */
-        function getTimeout(): number;
         /**
          * Get the prerender concurrency value from the environment variable, or return the default
          * if it's not set or invalid
@@ -128,8 +114,8 @@ export declare namespace Prerender {
         function get(app: {
             fetch: (req: Request) => Promise<Response>;
         }, route: string, opts: {
-            timeout: number;
             origin?: string;
+            base?: string;
         }): Promise<{
             route: string;
             status: number;
@@ -140,16 +126,15 @@ export declare namespace Prerender {
             artifact: any;
         }>;
         /**
-         * Run the prerendering process for a list of routes, with a specified concurrency limit and timeout for
-         * each route, by calling the 'get' function for each route and yielding the results as they
-         * become available
+         * Run the prerendering process for a list of routes with a specified concurrency limit,
+         * by calling the 'get' function for each route and yielding the results as they become available
          */
         function run(app: {
             fetch: (req: Request) => Promise<Response>;
         }, routes: string[], opts: {
-            timeout: number;
             concurrency?: number;
             origin?: string;
+            base?: string;
         }): AsyncGenerator<Result, void, unknown>;
     }
 }

package/dist/internal/prerender.js

@@ -1,18 +1,16 @@
 import path from 'node:path';
 import { compile } from 'path-to-regexp';
+import { BasePath } from '../utils/base-path.js';
 import { Logger } from '../utils/logger.js';
-import { Time } from '../utils/time.js';
 import { Solas } from '../solas.js';
 import { toPathPattern } from './http-router/utils.js';
 const logger = new Logger();
 export { Prerender };
 var Prerender;
 (function (Prerender) {
-    const DEFAULT_TIMEOUT_MS = 15_000;
     const DEFAULT_CONCURRENCY = 4;
     let Artifact;
     (function (Artifact) {
-        const manifestCache = new Map();
         /**
          * Check whether a file name is safe to join under an artifact directory
          */
@@ -30,14 +28,6 @@ var Prerender;
             return path.join(outDir, Solas.Config.GENERATED_DIR, 'ppr');
         }
         Artifact.getRootPath = getRootPath;
-        /**
-         * Get the file system path for the prerender artifact manifest, which
-         * contains metadata about all prerendered routes and their artifacts
-         */
-        function getManifestPath(outDir) {
-            return path.join(getRootPath(outDir), 'manifest.json');
-        }
-        Artifact.getManifestPath = getManifestPath;
         /**
          * Get the file system path for storing prerender artifacts for a given route
          */
@@ -66,73 +56,6 @@ var Prerender;
          * File name used for saved full-prerender html inside each route artifact directory
          */
         Artifact.FULL_PRERENDER_FILENAME = 'prerendered.html';
-        /**
-         * Load the prerender artifact manifest for faster runtime route mode checks
-         */
-        async function loadManifest(outDir) {
-            // if we already loaded this outDir, return cached result
-            // (either a valid manifest or null when it was missing/invalid)
-            if (manifestCache.has(outDir)) {
-                return manifestCache.get(outDir) ?? null;
-            }
-            const file = Bun.file(getManifestPath(outDir));
-            // no manifest means no prerender metadata to use
-            if (!(await file.exists())) {
-                manifestCache.set(outDir, null);
-                return null;
-            }
-            try {
-                // parse once, then validate the shape before trusting any fields
-                const value = JSON.parse(await file.text());
-                if (!value || typeof value !== 'object') {
-                    manifestCache.set(outDir, null);
-                    return null;
-                }
-                const routes = value.routes;
-                if (!routes || typeof routes !== 'object') {
-                    manifestCache.set(outDir, null);
-                    return null;
-                }
-                // verify each route entry so runtime can rely on mode/files safely
-                for (const entry of Object.values(routes)) {
-                    if (!entry || typeof entry !== 'object') {
-                        manifestCache.set(outDir, null);
-                        return null;
-                    }
-                    const { mode, files } = entry;
-                    // only allow known modes
-                    if (mode !== 'full' && mode !== 'ppr') {
-                        manifestCache.set(outDir, null);
-                        return null;
-                    }
-                    if (files !== undefined) {
-                        if (!Array.isArray(files)) {
-                            manifestCache.set(outDir, null);
-                            return null;
-                        }
-                        // only allow known artifact file labels
-                        for (const f of files) {
-                            if (f !== 'html' &&
-                                f !== 'prelude' &&
-                                f !== 'postponed' &&
-                                f !== 'metadata') {
-                                manifestCache.set(outDir, null);
-                                return null;
-                            }
-                        }
-                    }
-                }
-                const manifest = routes;
-                // cache validated manifest to avoid reparsing on every request
-                manifestCache.set(outDir, manifest);
-                return manifest;
-            }
-            catch {
-                manifestCache.set(outDir, null);
-                return null;
-            }
-        }
-        Artifact.loadManifest = loadManifest;
         /**
          * Load the postponed state for a given route from the file system, if it exists
          */
@@ -319,18 +242,6 @@ var Prerender;
     })(Runtime = Prerender.Runtime || (Prerender.Runtime = {}));
     let Build;
     (function (Build) {
-        /**
-         * Get the prerender timeout value from the environment variable, or return the default
-         * if it's not set or invalid
-         */
-        function getTimeout() {
-            const v = Number(process.env.SOLAS_PRERENDER_TIMEOUT_MS);
-            if (!Number.isFinite(v) || v <= 0) {
-                return DEFAULT_TIMEOUT_MS;
-            }
-            return v;
-        }
-        Build.getTimeout = getTimeout;
         /**
          * Get the prerender concurrency value from the environment variable, or return the default
          * if it's not set or invalid
@@ -359,7 +270,7 @@ var Prerender;
             const params = await buildContext.exportReader.value(filePath, 'params', (v) => typeof v === 'function');
             if (!params)
                 return [];
-            const resolved = await Time.timeout(Promise.try(() => params()), getTimeout(), `static params for ${filePath}`);
+            const resolved = await Promise.try(() => params());
             if (!Array.isArray(resolved))
                 return [];
             return resolved;
@@ -402,14 +313,14 @@ var Prerender;
          * postponed to request-time
          */
         async function get(app, route, opts) {
-            const url = `${opts.origin ?? `http://${Solas.Config.SLUG}.local`}${route}`;
-            const res = await Time.timeout(app.fetch(new Request(url, {
+            const url = `${opts.origin ?? `http://${Solas.Config.SLUG}.local`}${BasePath.apply(route, opts.base)}`;
+            const res = await app.fetch(new Request(url, {
                 headers: {
                     Accept: 'text/html',
                     [`x-${Solas.Config.SLUG}-prerender`]: '1',
                     [`x-${Solas.Config.SLUG}-prerender-artifact`]: '1',
                 },
-            })), opts.timeout, `route ${route}`);
+            }));
             if (!(res instanceof Response)) {
                 const error = new TypeError(`Invalid response for ${route}`);
                 logger.error(`[prerender:get] ${error.message}`, error);
@@ -421,9 +332,8 @@ var Prerender;
         }
         Build.get = get;
         /**
-         * Run the prerendering process for a list of routes, with a specified concurrency limit and timeout for
-         * each route, by calling the 'get' function for each route and yielding the results as they
-         * become available
+         * Run the prerendering process for a list of routes with a specified concurrency limit,
+         * by calling the 'get' function for each route and yielding the results as they become available
          */
         async function* run(app, routes, opts) {
             const limit = Math.max(1, Math.min(opts.concurrency ?? 4, routes.length || 1));
@@ -434,7 +344,7 @@ var Prerender;
                     const i = index++;
                     const value = routes[i];
                     pending.set(i, get(app, value, {
-                        timeout: opts.timeout,
+                        base: opts.base,
                         origin: opts.origin,
                     })
                         .then(result => ({ index: i, result }))

package/dist/internal/public-files.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Collect the root request paths for files that originate in Vite's public dir.
+ * Vite copies these files into the built client output unchanged. Solas stores
+ * the request paths here so runtime serving can whitelist them
+ *
+ * @example
+ * ```ts
+ * // public/robots.txt
+ * // becomes '/robots.txt'
+ * ```
+ *
+ * @example
+ * ```ts
+ * // public/images/logo 1.png
+ * // becomes '/images/logo%201.png'
+ * ```
+ */
+export declare function collect(root: string | false | null | undefined): Promise<string[]>;

package/dist/internal/public-files.js

@@ -0,0 +1,63 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { Solas } from '../solas.js';
+/**
+ * Collect the root request paths for files that originate in Vite's public dir.
+ * Vite copies these files into the built client output unchanged. Solas stores
+ * the request paths here so runtime serving can whitelist them
+ *
+ * @example
+ * ```ts
+ * // public/robots.txt
+ * // becomes '/robots.txt'
+ * ```
+ *
+ * @example
+ * ```ts
+ * // public/images/logo 1.png
+ * // becomes '/images/logo%201.png'
+ * ```
+ */
+export async function collect(root) {
+    if (!root)
+        return [];
+    // normalise the configured public dir before we start walking it
+    const publicRoot = path.resolve(root);
+    try {
+        const stat = await fs.stat(publicRoot);
+        if (!stat.isDirectory())
+            return [];
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    async function walk(dir, parts = []) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            // top-level /public/_solas would collide with framework assets served
+            // from /_solas, so keep that namespace reserved
+            if (parts.length === 0 &&
+                entry.isDirectory() &&
+                entry.name === Solas.Config.ASSETS_DIR) {
+                continue;
+            }
+            const nextParts = [...parts, entry.name];
+            const nextPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(nextPath, nextParts);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            // store the external request path, not the filesystem path
+            // eg public/favicon.ico -> /favicon.ico
+            // eg public/images/logo 1.png -> /images/logo%201.png
+            // encode each segment so manifest lookups match routed URLs
+            files.push(`/${nextParts.map(part => encodeURIComponent(part)).join('/')}`);
+        }
+    }
+    await walk(publicRoot);
+    // keep manifest output stable regardless of directory iteration order
+    return files.sort();
+}

package/dist/internal/render/tree.d.ts

@@ -11,9 +11,6 @@ type Match = NonNullable<Resolver.EnhancedMatch>;
  * 2. `Suspense` with that segment's loading fallback
  * 3. `HttpExceptionBoundary` with that segment's status boundaries
  *
- * The shell level is applied last using the same outer wrapper order:
- * `HttpExceptionBoundary` -> `Suspense` -> `Shell`
- *
  * @example
  * ```tsx
  *   <HttpExceptionBoundary shell>

package/dist/internal/render/tree.js

@@ -17,9 +17,6 @@ const SERVER_ERROR = new HttpException(500, 'Internal Server Error');
  * 2. `Suspense` with that segment's loading fallback
  * 3. `HttpExceptionBoundary` with that segment's status boundaries
  *
- * The shell level is applied last using the same outer wrapper order:
- * `HttpExceptionBoundary` -> `Suspense` -> `Shell`
- *
  * @example
  * ```tsx
  *   <HttpExceptionBoundary shell>
@@ -63,7 +60,7 @@ export function Tree({ depth, params, error, ui, }) {
         const Exception = httpExceptionMap[error.status].slice(0, depth + 1).findLast(e => e !== null) ??
             DefaultErr;
         inner = (_jsxs(_Fragment, { children: [
-                _jsx("meta", { name: "robots", content: "noindex,nofollow" }), _jsx(Exception, { error: error })
+                _jsx("meta", { name: "robots", content: "noindex,nofollow" }), _jsx(Exception, { error: error, params: params })
             ] }));
     }
     else if (Page) {
@@ -96,8 +93,6 @@ export function Tree({ depth, params, error, ui, }) {
             inner = (_jsx(HttpExceptionBoundary, { components: errorBoundaries, children: inner }));
         }
     }
-    // now wrap with shell structure: shell renders immediately,
-    // inner streams inside Suspense
     const ShellLoading = loaders[0];
     const ShellUnauthorised = unauthorised[0];
     const ShellForbidden = forbidden[0];