@jk2908/solas 0.5.4 → 0.7.0

package/dist/internal/public-files.js

@@ -1,6 +1,6 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { Solas } from '../solas.js';
+import * as Config from '../config.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
@@ -37,9 +37,7 @@ export async function collect(root) {
         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) {
+            if (parts.length === 0 && entry.isDirectory() && entry.name === Config.ASSETS_DIR) {
                 continue;
             }
             const nextParts = [...parts, entry.name];

package/dist/internal/render/head.js

@@ -1,7 +1,7 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { use } from 'react';
 import { Logger } from '../../utils/logger.js';
-import { Solas } from '../../solas.js';
+import * as Config from '../../config.js';
 const logger = new Logger();
 const cache = new WeakMap();
 /**
@@ -37,7 +37,7 @@ export function Head({ metadata: m, }) {
         return null;
     const metadata = use(toSafeUsable(m));
     return (_jsxs(_Fragment, { children: [
-            _jsx("meta", { name: "generator", content: Solas.Config.NAME }), toContent(metadata.title) !== undefined && (_jsx("title", { children: toContent(metadata.title) })), metadata.meta?.map(meta => {
+            _jsx("meta", { name: "generator", content: Config.NAME }), toContent(metadata.title) !== undefined && (_jsx("title", { children: toContent(metadata.title) })), metadata.meta?.map(meta => {
                 if ('charSet' in meta) {
                     return _jsx("meta", { charSet: meta.charSet }, meta.charSet);
                 }

package/dist/internal/resolver.js

@@ -1,6 +1,6 @@
 import { lazy } from 'react';
 import { Logger } from '../utils/logger.js';
-import { Build } from './build.js';
+import * as Build from './build.js';
 import { Metadata } from './metadata.js';
 import { HttpException, isHttpException } from './navigation/http-exception.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/internal/server/actions.js

@@ -1,5 +1,5 @@
 import { createTemporaryReferenceSet, decodeAction, decodeFormState, decodeReply, loadServerAction, } from '@vitejs/plugin-rsc/rsc';
-import { Solas } from '../../solas.js';
+import * as Config from '../../config.js';
 import { enforce } from './csrf.js';
 /**
  * Check if a request is an action request and reuse parsed FormData
@@ -66,7 +66,7 @@ export async function processActionRequest(req, csrf = {}) {
         // we might have already parsed FormData in the router for multipart action
         // detection should be attached to the SolasRequest, so we can reuse that
         // to avoid parsing twice
-        const parsedFormData = req[Solas.Config.REQUEST_META_KEY]?.parsedFormData;
+        const parsedFormData = req[Config.REQUEST_META_KEY]?.parsedFormData;
         const formData = parsedFormData ?? (await req.formData());
         const decodedAction = await decodeAction(formData);
         const result = await decodedAction();

package/dist/internal/ui/error-boundary.d.ts

@@ -1,5 +1,5 @@
 import { Component } from 'react';
-import type { BoundaryError } from '../../types.js';
+import type { BoundaryError } from '../boundary-error.js';
 export type Props = {
     fallback: ((error: BoundaryError, reset: () => void) => React.ReactNode) | React.ReactNode;
     onError?: (error: BoundaryError) => void;

package/dist/manifest.d.ts

@@ -0,0 +1,7 @@
+import * as Prerender from './internal/prerender.js';
+export type Manifest = {
+    artifacts: Prerender.ArtifactManifest;
+    publicFiles: ReadonlySet<string>;
+};
+export declare function getManifestPath(outDir: string): string;
+export declare function loadManifest(outDir: string): Promise<Manifest | null>;

package/dist/manifest.js

@@ -0,0 +1,85 @@
+import * as Config from './config.js';
+import { Runtime } from './internal/runtimes/runtime.js';
+const manifestCache = new Map();
+export 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('/');
+}
+export async function loadManifest(outDir) {
+    if (manifestCache.has(outDir)) {
+        return manifestCache.get(outDir) ?? null;
+    }
+    const manifestPath = getManifestPath(outDir);
+    if (!(await Runtime.exists(manifestPath))) {
+        manifestCache.set(outDir, null);
+        return null;
+    }
+    try {
+        const value = JSON.parse(await Runtime.readText(manifestPath));
+        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 runtimeManifest = {
+            artifacts: artifacts,
+            publicFiles: new Set(publicFiles ?? []),
+        };
+        manifestCache.set(outDir, runtimeManifest);
+        return runtimeManifest;
+    }
+    catch {
+        manifestCache.set(outDir, null);
+        return null;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/prerender.d.ts

@@ -1 +1 @@
-export { Prerender } from './internal/prerender.js';
+export * as Prerender from './internal/prerender.js';

package/dist/prerender.js

@@ -1 +1 @@
-export { Prerender } from './internal/prerender.js';
+export * as Prerender from './internal/prerender.js';

package/dist/solas.d.ts

@@ -1,47 +1,3 @@
-import type { Prerender } from './internal/prerender.js';
-import type { PluginConfig } from './types.js';
-export declare namespace Solas {
-    interface Routes {
-    }
-    namespace Config {
-        const NAME = "Solas";
-        const SLUG: string;
-        const PKG_NAME: string;
-        const OUT_DIR = "dist";
-        const APP_DIR = "app";
-        const GENERATED_DIR: string;
-        const ENTRY_RSC = "entry.rsc.tsx";
-        const ENTRY_SSR = "entry.ssr.tsx";
-        const ENTRY_BROWSER = "entry.browser.tsx";
-        const ASSETS_DIR: string;
-        const PUBLIC_DIR = "public";
-        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";
-        /**
-         * Validate the plugin configuration object, throwing an error if invalid
-         * @param input - the unvalidated configuration object
-         * @return the typed and validated configuration object
-         */
-        function validate(input: unknown): PluginConfig;
-    }
-    function getVersion(): string;
-    namespace Runtime {
-        type Manifest = {
-            artifacts: Prerender.Artifact.Manifest;
-            publicFiles: ReadonlySet<string>;
-        };
-        function getManifestPath(outDir: string): string;
-        function loadManifest(outDir: string): Promise<Manifest | null>;
-    }
-    namespace Events {
-        const names: {
-            readonly NAVIGATION: `${string}navigation`;
-            readonly NAVIGATION_ERROR: `${string}navigationerror`;
-        };
-    }
+export interface Routes {
 }
+export declare function getVersion(): string;

package/dist/solas.js

@@ -1,268 +1,8 @@
-import { Runtime as InternalRuntime } from './internal/runtimes/runtime.js';
-export { Solas };
-var Solas;
-(function (Solas) {
-    let Config;
-    (function (Config) {
-        Config.NAME = 'Solas';
-        Config.SLUG = Config.NAME.toLowerCase();
-        Config.PKG_NAME = `@jk2908/${Config.SLUG}`;
-        Config.OUT_DIR = 'dist';
-        Config.APP_DIR = 'app';
-        Config.GENERATED_DIR = `.${Config.SLUG}`;
-        Config.ENTRY_RSC = 'entry.rsc.tsx';
-        Config.ENTRY_SSR = 'entry.ssr.tsx';
-        Config.ENTRY_BROWSER = 'entry.browser.tsx';
-        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.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',
-            'precompress',
-            'prerender',
-            'sitemap',
-            'trustedOrigins',
-            'trailingSlash',
-            'url',
-        ]);
-        const LOGGER_KEYS = new Set(['level']);
-        /**
-         * Validate the plugin configuration object, throwing an error if invalid
-         * @param input - the unvalidated configuration object
-         * @return the typed and validated configuration object
-         */
-        function validate(input) {
-            if (input === undefined)
-                return {};
-            const errors = [];
-            if (!isRecord(input)) {
-                throw new Error(`[${Config.NAME}] Invalid config:\n- Expected plugin config to be an object`);
-            }
-            for (const key of Object.keys(input)) {
-                if (!CONFIG_KEYS.has(key)) {
-                    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');
-                }
-                else {
-                    try {
-                        const url = new URL(input.url);
-                        if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-                            errors.push('config.url must use http:// or https://');
-                        }
-                    }
-                    catch {
-                        errors.push('config.url must be a valid URL');
-                    }
-                }
-            }
-            if ('precompress' in input && input.precompress !== undefined) {
-                if (typeof input.precompress !== 'boolean') {
-                    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');
-                }
-                if (typeof input.sitemap === 'object' &&
-                    input.sitemap !== null &&
-                    typeof input.sitemap.routes !== 'function') {
-                    errors.push('config.sitemap.routes must be a function');
-                }
-                if (!input.url) {
-                    errors.push('config.url is required when sitemap is enabled');
-                }
-            }
-            if ('prerender' in input && input.prerender !== undefined) {
-                if (!new Set(Config.PRERENDER_MODES).has(input.prerender)) {
-                    errors.push("config.prerender must be 'full', 'ppr', or false");
-                }
-            }
-            if ('trailingSlash' in input && input.trailingSlash !== undefined) {
-                if (typeof input.trailingSlash !== 'string' ||
-                    !new Set(Config.TRAILING_SLASH_MODES).has(input.trailingSlash)) {
-                    errors.push("config.trailingSlash must be 'always', 'never', or 'ignore'");
-                }
-            }
-            if ('metadata' in input &&
-                input.metadata !== undefined &&
-                !isRecord(input.metadata)) {
-                errors.push('config.metadata must be an object when provided');
-            }
-            if ('logger' in input && input.logger !== undefined) {
-                if (!isRecord(input.logger)) {
-                    errors.push('config.logger must be an object when provided');
-                }
-                else {
-                    for (const key of Object.keys(input.logger)) {
-                        if (!LOGGER_KEYS.has(key)) {
-                            errors.push(`Unknown config.logger key: ${key}`);
-                        }
-                    }
-                    if ('level' in input.logger && input.logger.level !== undefined) {
-                        if (typeof input.logger.level !== 'string' ||
-                            !new Set(Config.LOG_LEVELS).has(input.logger.level)) {
-                            errors.push('config.logger.level must be one of: debug, info, warn, error, fatal');
-                        }
-                    }
-                }
-            }
-            if (errors.length > 0) {
-                throw new Error(`[${Config.NAME}] Invalid config:\n- ${errors.join('\n- ')}`);
-            }
-            return input;
-        }
-        Config.validate = validate;
-    })(Config = Solas.Config || (Solas.Config = {}));
-    function getVersion() {
-        const value = import.meta.env.SOLAS_VERSION;
-        if (typeof value !== 'string' || value.length === 0) {
-            throw new Error(`[${Config.NAME}] Missing ${Config.NAME} package version`);
-        }
-        return value;
+import * as Config from './config.js';
+export function getVersion() {
+    const value = import.meta.env.SOLAS_VERSION;
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`[${Config.NAME}] Missing ${Config.NAME} package version`);
     }
-    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 manifestPath = getManifestPath(outDir);
-            if (!(await InternalRuntime.exists(manifestPath))) {
-                manifestCache.set(outDir, null);
-                return null;
-            }
-            try {
-                const value = JSON.parse(await InternalRuntime.readText(manifestPath));
-                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 runtimeManifest = {
-                    artifacts: artifacts,
-                    publicFiles: new Set(publicFiles ?? []),
-                };
-                manifestCache.set(outDir, runtimeManifest);
-                return runtimeManifest;
-            }
-            catch {
-                manifestCache.set(outDir, null);
-                return null;
-            }
-        }
-        Runtime.loadManifest = loadManifest;
-    })(Runtime = Solas.Runtime || (Solas.Runtime = {}));
-    let Events;
-    (function (Events) {
-        Events.names = {
-            NAVIGATION: `${Config.SLUG}navigation`,
-            NAVIGATION_ERROR: `${Config.SLUG}navigationerror`,
-        };
-    })(Events = Solas.Events || (Solas.Events = {}));
-})(Solas || (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);
+    return value;
 }

package/dist/types.d.ts

@@ -2,40 +2,32 @@ 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 * as BrowserRouter from './internal/browser-router/shared.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 { 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}`;
+import * as Config from './config.js';
+import * as Build from './internal/build.js';
+export type LogLevel = (typeof Config.LOG_LEVELS)[number];
+export type Origin = `http://${string}` | `https://${string}`;
 type PluginConfigBase = {
-    runtime?: Runtime;
-    port?: number;
     precompress?: boolean;
     prerender?: Route.Prerender;
     metadata?: Metadata.Item;
-    trailingSlash?: (typeof Solas.Config.TRAILING_SLASH_MODES)[number];
+    trailingSlash?: (typeof Config.TRAILING_SLASH_MODES)[number];
     trustedOrigins?: readonly Origin[];
     readonly logger?: {
         level?: LogLevel;
     };
 };
-export type PluginConfig = PluginConfigBase & ({
-    url: Origin;
-    sitemap: true | {
+export type PluginConfig = PluginConfigBase & {
+    url?: Origin;
+    sitemap?: boolean | {
         routes: (existing: string[]) => string[] | Promise<string[]>;
     };
-} | {
-    url?: Origin;
-    sitemap?: false;
-});
-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']>;
@@ -112,8 +104,8 @@ export type BuildManifest = {
     prerenderRoutes: string[];
     sitemapRoutes: string[];
     precompress: boolean;
-    trailingSlash: (typeof Solas.Config.TRAILING_SLASH_MODES)[number];
-    url?: PluginConfig['url'];
+    trailingSlash: (typeof Config.TRAILING_SLASH_MODES)[number];
+    url?: Origin;
 };
 export declare namespace Route {
     type ParamsOf<TRoute> = TRoute extends {
@@ -132,10 +124,7 @@ export declare namespace Route {
     } : {
         params: ParamsOf<TRoute>;
     }) & ErrorPropsOf<TError>;
-    export type Prerender = (typeof Solas.Config.PRERENDER_MODES)[number];
+    export type Prerender = (typeof Config.PRERENDER_MODES)[number];
     export {};
 }
-export type BoundaryError = Error & {
-    digest?: string;
-};
 export {};