@jk2908/solas 0.5.4 → 0.7.0

package/dist/internal/codegen/config.js

@@ -1,18 +1,17 @@
-import { Solas } from '../../solas.js';
+import * as Config from '../../config.js';
 import { AUTOGEN_MSG, source, toSourceLiteral } from './utils.js';
 /**
  * Generates the code to create an exported config object
  */
 export function writeConfig(config) {
-    const { runtime: _runtime, ...runtimeConfig } = config;
     const loggerLevel = config.logger?.level;
     const importLines = [
-        `import type { RuntimeConfig } from '${Solas.Config.PKG_NAME}'`,
-        loggerLevel ? `import { Logger } from '${Solas.Config.PKG_NAME}/utils/logger'` : '',
+        `import type { RuntimeConfig } from '${Config.PKG_NAME}'`,
+        loggerLevel ? `import { Logger } from '${Config.PKG_NAME}/utils/logger'` : '',
     ]
         .filter(Boolean)
         .join('\n');
-    const configStatement = `const config = ${toSourceLiteral(runtimeConfig)} as const satisfies RuntimeConfig`;
+    const configStatement = `const config = ${toSourceLiteral(config)} as const satisfies RuntimeConfig`;
     const loggerStatement = loggerLevel
         ? `Logger.defaultLevel = ${toSourceLiteral(loggerLevel)}`
         : '';

package/dist/internal/codegen/environments.d.ts

@@ -2,7 +2,7 @@ import type { ConfiguredPluginConfig } from '../../types.js';
 /**
  * Generates the RSC entry code
  */
-export declare function writeRSCEntry(config: ConfiguredPluginConfig): string;
+export declare function writeRSCEntry(_config: ConfiguredPluginConfig): string;
 /**
  * Generates the SSR entry code
  */

package/dist/internal/codegen/environments.js

@@ -1,22 +1,19 @@
-import { Solas } from '../../solas.js';
+import * as Config from '../../config.js';
 import { AUTOGEN_MSG, source, toStringLiteral } from './utils.js';
 /**
  * Generates the RSC entry code
  */
-export function writeRSCEntry(config) {
-    const runtime = toStringLiteral(config.runtime);
+export function writeRSCEntry(_config) {
     return source `
 		${AUTOGEN_MSG}
 
-		import { createHandler, createRuntime, Runtime } from '${Solas.Config.PKG_NAME}/env/rsc'
-		import { Solas } from '${Solas.Config.PKG_NAME}/$'
+		import { createHandler, loadManifest } from '${Config.PKG_NAME}/env/rsc'
 
 		import { manifest } from './manifest.js'
 		import { importMap } from './maps.js'
 		import { config } from './config.js'
 
-		Runtime.runtime = createRuntime(${runtime})
-		const runtimeManifest = await Solas.Runtime.loadManifest(Solas.Config.OUT_DIR)
+		const runtimeManifest = await loadManifest(${toStringLiteral(Config.OUT_DIR)})
 
 		export default createHandler(config, manifest, importMap, runtimeManifest)
 
@@ -32,7 +29,7 @@ export function writeSSREntry() {
     return source `
 		${AUTOGEN_MSG}
 
-		export { prerender, resume, ssr } from '${Solas.Config.PKG_NAME}/env/ssr'
+		export { prerender, resume, ssr } from '${Config.PKG_NAME}/env/ssr'
 	`;
 }
 /**
@@ -42,7 +39,7 @@ export function writeBrowserEntry() {
     return source `
 		${AUTOGEN_MSG}
 
-		import { browser } from '${Solas.Config.PKG_NAME}/env/browser'
+		import { browser } from '${Config.PKG_NAME}/env/browser'
 
 		browser()
 	`;

package/dist/internal/codegen/format.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Format generated source before it is written to disk. Falls back to the
+ * unformatted content when parsing fails so codegen never blocks on a
+ * formatter error
+ */
+export declare function format(fileName: string, content: string): Promise<string>;

package/dist/internal/codegen/format.js

@@ -0,0 +1,24 @@
+import { format as oxfmtFormat } from 'oxfmt';
+const FORMAT_OPTIONS = {
+    useTabs: true,
+    tabWidth: 2,
+    printWidth: 90,
+    singleQuote: true,
+    quoteProps: 'as-needed',
+    trailingComma: 'all',
+    semi: false,
+    arrowParens: 'avoid',
+    bracketSameLine: true,
+    bracketSpacing: true,
+};
+/**
+ * Format generated source before it is written to disk. Falls back to the
+ * unformatted content when parsing fails so codegen never blocks on a
+ * formatter error
+ */
+export async function format(fileName, content) {
+    const result = await oxfmtFormat(fileName, content, FORMAT_OPTIONS);
+    if (result.errors.length > 0)
+        return content;
+    return result.code;
+}

package/dist/internal/codegen/manifest.js

@@ -1,4 +1,4 @@
-import { Solas } from '../../solas.js';
+import * as Config from '../../config.js';
 import { AUTOGEN_MSG, source, toSourceLiteral } from './utils.js';
 /**
  * Generates the code to create an exported manifest object
@@ -7,7 +7,7 @@ export function writeManifest(manifest) {
     return source `
 		${AUTOGEN_MSG}
 
-		import type { Manifest } from '${Solas.Config.PKG_NAME}'
+		import type { Manifest } from '${Config.PKG_NAME}'
 
 		export const manifest = ${toSourceLiteral(manifest)} as const satisfies Manifest
 	`;

package/dist/internal/codegen/maps.d.ts

@@ -1,4 +1,4 @@
-import type { Build } from '../build.js';
+import * as Build from '../build.js';
 /**
  * Generates the import map for all route components, endpoints, layouts, shells, and middlewares
  */

package/dist/internal/codegen/maps.js

@@ -1,4 +1,4 @@
-import { Solas } from '../../solas.js';
+import * as Config from '../../config.js';
 import { AUTOGEN_MSG, indent, source, toIdentifier, toIdentifierList, toRelativeModuleSpecifier, toStringLiteral, } from './utils.js';
 /**
  * Generates the import map for all route components, endpoints, layouts, shells, and middlewares
@@ -69,7 +69,7 @@ export function writeMaps(imports, modules) {
     return source `
 		${AUTOGEN_MSG}
 
-		import type { ImportMap } from '${Solas.Config.PKG_NAME}'
+		import type { ImportMap } from '${Config.PKG_NAME}'
 		
 		${importLines
         ? `

package/dist/internal/codegen/types.js

@@ -1,5 +1,5 @@
-import { Solas } from '../../solas.js';
-import { Build } from '../build.js';
+import * as Config from '../../config.js';
+import * as Build from '../build.js';
 import { AUTOGEN_MSG, source } from './utils.js';
 function render(path, params) {
     if (!params || params.length === 0) {
@@ -36,9 +36,9 @@ export function writeTypes(manifest) {
     return source `
    ${AUTOGEN_MSG}
 
-	 import '${Solas.Config.PKG_NAME}'
+	 import '${Config.PKG_NAME}'
 
-	 declare module '${Solas.Config.PKG_NAME}' {
+	 declare module '${Config.PKG_NAME}' {
 		export namespace Solas {
 			export interface Routes {
 				${body}

package/dist/internal/codegen/utils.js

@@ -1,5 +1,5 @@
-import { Solas } from '../../solas.js';
-export const AUTOGEN_MSG = `// auto-generated by ${Solas.Config.NAME}`;
+import * as Config from '../../config.js';
+export const AUTOGEN_MSG = `// auto-generated by ${Config.NAME}`;
 const INDENT = '\t';
 const IDENTIFIER = /^[$A-Z_a-z][$\w]*$/;
 /**

package/dist/internal/env/request-context.js

@@ -1,2 +1,2 @@
-import { Context } from '../../utils/context.js';
+import * as Context from '../../utils/context.js';
 export const RequestContext = Context.create('request');

package/dist/internal/env/rsc.d.ts

@@ -1,9 +1,9 @@
 import type { ReactFormState } from 'react-dom/client';
 import type { ImportMap, Manifest, RuntimeConfig } from '../../types.js';
-import { Solas } from '../../solas.js';
+import * as RuntimeManifest from '../../manifest.js';
 import { Metadata } from '../metadata.js';
-export { createRuntime } from '../runtimes/create.js';
 export { Runtime } from '../runtimes/runtime.js';
+export { loadManifest } from '../../manifest.js';
 export type RscPayload = {
     returnValue?: {
         ok: boolean;
@@ -23,6 +23,6 @@ export type RscPayload = {
  * route manifest, and import map to build the router once, then returns an object
  * with a fetch method that handles requests
  */
-export declare function createHandler(config: RuntimeConfig, manifest: Manifest, importMap: ImportMap, runtimeManifest?: Solas.Runtime.Manifest | null): {
+export declare function createHandler(config: RuntimeConfig, manifest: Manifest, importMap: ImportMap, runtimeManifest?: RuntimeManifest.Manifest | null): {
     fetch(req: Request): Promise<Response>;
 };

package/dist/internal/env/rsc.js

@@ -1,26 +1,26 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import path from 'node:path';
 import { renderToReadableStream } from '@vitejs/plugin-rsc/rsc';
-import { BasePath } from '../../utils/base-path.js';
+import { applyBasePath, normaliseBasePath, stripBasePath } from '../../utils/base-path.js';
 import { Logger } from '../../utils/logger.js';
-import { Solas } from '../../solas.js';
+import * as Config from '../../config.js';
 import { createHttpRouter } from '../http-router/create-http-router.js';
 import { HttpRouter } from '../http-router/router.js';
 import { normalisePathname } from '../http-router/utils.js';
 import { Metadata } from '../metadata.js';
 import { HttpException, isHttpException, toHttpException, toHttpExceptionLike, } from '../navigation/http-exception.js';
 import { isRedirect, toRedirect } from '../navigation/redirect.js';
-import { Prerender } from '../prerender.js';
+import * as Prerender from '../prerender.js';
 import { Tree } from '../render/tree.js';
 import { Resolver } from '../resolver.js';
 import { processActionRequest } from '../server/actions.js';
 import DefaultErr from '../ui/defaults/error.js';
 import { RequestContext } from './request-context.js';
 import { getKnownDigest, isKnownError } from './utils.js';
-export { createRuntime } from '../runtimes/create.js';
 export { Runtime } from '../runtimes/runtime.js';
+export { loadManifest } from '../../manifest.js';
 const logger = new Logger();
-const BASE_PATH = BasePath.normalise(import.meta.env.BASE_URL);
+const BASE_PATH = normaliseBasePath(import.meta.env.BASE_URL);
 function resolveFilePath(root, relativePath) {
     try {
         const decodedPath = decodeURIComponent(relativePath);
@@ -43,16 +43,16 @@ function resolveFilePath(root, relativePath) {
  */
 async function createPayload(req, manifest, importMap, baseMetadata, returnValue, formState, temporaryReferences) {
     const resolver = new Resolver(manifest, importMap);
-    const prerender = req.headers.get(`x-${Solas.Config.SLUG}-prerender`) === '1';
+    const prerender = req.headers.get(`x-${Config.SLUG}-prerender`) === '1';
     const url = new URL(req.url);
-    const routedPath = BasePath.strip(url.pathname, BASE_PATH) ?? url.pathname;
+    const routedPath = stripBasePath(url.pathname, BASE_PATH) ?? url.pathname;
     const pathname = routedPath.endsWith('/') && routedPath !== '/' ? routedPath.slice(0, -1) : routedPath;
-    const match = resolver.enhance(resolver.reconcile(pathname, req[Solas.Config.REQUEST_META_KEY].match, req[Solas.Config.REQUEST_META_KEY].error));
+    const match = resolver.enhance(resolver.reconcile(pathname, req[Config.REQUEST_META_KEY].match, req[Config.REQUEST_META_KEY].error));
     // if there's no match then no user supplied error boundary
     // has been found, and we should server render a default
     // error screen
     if (!match) {
-        const error = toHttpExceptionLike(req[Solas.Config.REQUEST_META_KEY].error ?? new HttpException(404, 'Not found'));
+        const error = toHttpExceptionLike(req[Config.REQUEST_META_KEY].error ?? new HttpException(404, 'Not found'));
         const title = `${error.status ? `${error.status} -` : ''}${error.message}`;
         const rscPayload = {
             root: (_jsxs("html", { lang: "en", children: [
@@ -163,11 +163,11 @@ async function createPayload(req, manifest, importMap, baseMetadata, returnValue
  * with a fetch method that handles requests
  */
 export function createHandler(config, manifest, importMap, runtimeManifest = null) {
-    const CLIENT_OUTPUT_DIR = path.resolve(Solas.Config.OUT_DIR, 'client');
+    const CLIENT_OUTPUT_DIR = path.resolve(Config.OUT_DIR, 'client');
     // vite emits solas-controlled assets under dist/client/_solas
-    const SOLAS_ASSETS_DIR = path.resolve(CLIENT_OUTPUT_DIR, Solas.Config.ASSETS_DIR);
+    const SOLAS_ASSETS_DIR = path.resolve(CLIENT_OUTPUT_DIR, Config.ASSETS_DIR);
     // requests for /_solas and /_solas/* are reserved
-    const SOLAS_ASSETS_URL_ROOT = `/${Solas.Config.ASSETS_DIR}`;
+    const SOLAS_ASSETS_URL_ROOT = `/${Config.ASSETS_DIR}`;
     const prerenderPathMode = config.trailingSlash === 'always' ? 'always' : 'never';
     /**
      * Create the HTTP response for a single incoming request. Runs actions when needed,
@@ -180,7 +180,7 @@ export function createHandler(config, manifest, importMap, runtimeManifest = nul
             temporaryReferences: undefined,
             returnValue: undefined,
         };
-        if (req[Solas.Config.REQUEST_META_KEY].action) {
+        if (req[Config.REQUEST_META_KEY].action) {
             opts = await processActionRequest(req, {
                 trustedOrigins: config.trustedOrigins,
                 url: config.url,
@@ -206,16 +206,16 @@ export function createHandler(config, manifest, importMap, runtimeManifest = nul
             if (isRedirect(err)) {
                 const redirect = toRedirect(err);
                 const location = redirect.url.startsWith('/')
-                    ? new URL(BasePath.apply(redirect.url, BASE_PATH), req.url).toString()
+                    ? new URL(applyBasePath(redirect.url, BASE_PATH), req.url).toString()
                     : redirect.url;
                 return Response.redirect(location, redirect.status);
             }
-            if (req[Solas.Config.REQUEST_META_KEY].error || !isHttpException(err)) {
+            if (req[Config.REQUEST_META_KEY].error || !isHttpException(err)) {
                 return null;
             }
             // retry once with the surfaced HttpException attached so createPayload can
             // rebuild the route through the nearest matching status boundary
-            req[Solas.Config.REQUEST_META_KEY].error = toHttpException(err);
+            req[Config.REQUEST_META_KEY].error = toHttpException(err);
             try {
                 const { stream: retriedRscStream, status: retriedStatus } = await createPayload(req, manifest, importMap, config.metadata, opts.returnValue, opts.formState, opts.temporaryReferences);
                 const retriedStream = await retriedRscStream;
@@ -225,13 +225,13 @@ export function createHandler(config, manifest, importMap, runtimeManifest = nul
                 };
             }
             finally {
-                req[Solas.Config.REQUEST_META_KEY].error = undefined;
+                req[Config.REQUEST_META_KEY].error = undefined;
             }
         }
         // prerender artifact requests bypass the normal document path so the cli
         // gets structured JSON instead of a rendered html response
-        if (req.headers.get(`x-${Solas.Config.SLUG}-prerender`) === '1' &&
-            req.headers.get(`x-${Solas.Config.SLUG}-prerender-artifact`) === '1') {
+        if (req.headers.get(`x-${Config.SLUG}-prerender`) === '1' &&
+            req.headers.get(`x-${Config.SLUG}-prerender-artifact`) === '1') {
             try {
                 const artifact = await mod.prerender(stream, {
                     formState: opts.formState,
@@ -275,8 +275,8 @@ export function createHandler(config, manifest, importMap, runtimeManifest = nul
                 : null;
             const tryPrelude = artifactEntry?.mode === 'ppr';
             if (tryPrelude) {
-                const postponedState = await Prerender.Artifact.loadPostponedState(Solas.Config.OUT_DIR, lookupPath);
-                const prelude = await Prerender.Artifact.loadPrelude(Solas.Config.OUT_DIR, lookupPath);
+                const postponedState = await Prerender.loadPostponedState(Config.OUT_DIR, lookupPath);
+                const prelude = await Prerender.loadPrelude(Config.OUT_DIR, lookupPath);
                 // resumable ppr responses splice fresh streamed content into the cached
                 // prelude when postponed state is available for this route
                 if (postponedState) {
@@ -287,7 +287,7 @@ export function createHandler(config, manifest, importMap, runtimeManifest = nul
                         injectPayload: false,
                     });
                     const body = prelude
-                        ? Prerender.Artifact.composePreludeAndResume(prelude, resumeStream)
+                        ? Prerender.composePreludeAndResume(prelude, resumeStream)
                         : resumeStream;
                     return new Response(body, {
                         headers: {
@@ -343,13 +343,13 @@ export function createHandler(config, manifest, importMap, runtimeManifest = nul
             if (method !== 'GET' && method !== 'HEAD')
                 return httpRouter.fetch(req);
             const accept = req.headers.get('accept') ?? '';
-            const routedPath = BasePath.strip(url.pathname, BASE_PATH);
+            const routedPath = stripBasePath(url.pathname, BASE_PATH);
             const canonicalPath = routedPath == null
                 ? null
                 : config.trailingSlash === 'ignore'
                     ? routedPath
                     : normalisePathname(routedPath, config.trailingSlash);
-            const canonicalPathname = canonicalPath == null ? null : BasePath.apply(canonicalPath, BASE_PATH);
+            const canonicalPathname = canonicalPath == null ? null : applyBasePath(canonicalPath, BASE_PATH);
             if (canonicalPathname != null &&
                 (method === 'GET' || method === 'HEAD') &&
                 config.trailingSlash !== 'ignore' &&
@@ -384,12 +384,12 @@ export function createHandler(config, manifest, importMap, runtimeManifest = nul
             if (canonicalPath != null &&
                 !import.meta.env.DEV &&
                 accept.includes('text/html') &&
-                req.headers.get(`x-${Solas.Config.SLUG}-prerender-artifact`) !== '1') {
+                req.headers.get(`x-${Config.SLUG}-prerender-artifact`) !== '1') {
                 // turn the request path into the normal route shape we use for artifact lookups
                 const lookupPath = normalisePathname(canonicalPath, prerenderPathMode);
                 // only full prerender routes have a saved html file we can serve directly
                 const prerenderPath = runtimeManifest?.artifacts[lookupPath]?.mode === 'full'
-                    ? Prerender.Artifact.getFilePath(Solas.Config.OUT_DIR, lookupPath, Prerender.Artifact.FULL_PRERENDER_FILENAME)
+                    ? Prerender.getArtifactFilePath(Config.OUT_DIR, lookupPath, Prerender.FULL_PRERENDER_FILENAME)
                     : null;
                 if (prerenderPath) {
                     const res = await HttpRouter.serveStatic(prerenderPath, req, config.precompress, {

package/dist/internal/env/ssr.js

@@ -4,10 +4,10 @@ import { resume as reactResume, renderToReadableStream } from 'react-dom/server.
 import { prerender as reactPrerender } from 'react-dom/static.edge';
 import { createFromReadableStream } from '@vitejs/plugin-rsc/ssr';
 import { Logger } from '../../utils/logger.js';
-import { Solas } from '../../solas.js';
+import * as Solas from '../../solas.js';
 import { BrowserRouterProvider } from '../browser-router/router.js';
 import { RedirectBoundary } from '../navigation/redirect-boundary.js';
-import { Prerender } from '../prerender.js';
+import * as Prerender from '../prerender.js';
 import { Head } from '../render/head.js';
 import { ErrorBoundary } from '../ui/error-boundary.js';
 import { captureBuffered, injectPayload } from './flight.js';
@@ -78,13 +78,13 @@ async function prerender(rscStream, opts = {}) {
         // abort on a macrotask so sync and microtask work still lands in prelude
         // unresolved work is captured as postponed state for resume
         setTimeout(() => {
-            controller.abort(new Prerender.Runtime.Postponed());
+            controller.abort(new Prerender.Postponed());
         }, 0);
         const { prelude, postponed } = await reactPrerender(_jsx(A, { payloadPromise: payloadPromise }), {
             bootstrapScriptContent,
             signal: controller.signal,
             onError(err) {
-                if (Prerender.Runtime.isPostponed(err))
+                if (Prerender.isPostponed(err))
                     return;
                 const digest = getKnownDigest(err);
                 if (digest)

package/dist/internal/http-router/router.js

@@ -1,12 +1,12 @@
 import { match as createMatch } from 'path-to-regexp';
-import { BasePath } from '../../utils/base-path.js';
-import { Solas } from '../../solas.js';
+import { applyBasePath, normaliseBasePath, stripBasePath } from '../../utils/base-path.js';
+import * as Config from '../../config.js';
 import { HttpException } from '../navigation/http-exception.js';
 import { Runtime } from '../runtimes/runtime.js';
 import { maybeAction } from '../server/actions.js';
 import { enforce } from '../server/csrf.js';
 import { getAlternatePathname, normalisePathname, toPathPattern } from './utils.js';
-const BASE_PATH = BasePath.normalise(import.meta.env.BASE_URL);
+const BASE_PATH = normaliseBasePath(import.meta.env.BASE_URL);
 /**
  * Handle routing and matching for server requests
  */
@@ -166,7 +166,7 @@ export class HttpRouter {
     async fetch(req) {
         const url = new URL(req.url);
         const trailingSlash = this.opts.trailingSlash ?? 'never';
-        const routedPath = BasePath.strip(url.pathname, BASE_PATH);
+        const routedPath = stripBasePath(url.pathname, BASE_PATH);
         const path = routedPath == null
             ? null
             : trailingSlash === 'ignore'
@@ -176,7 +176,7 @@ export class HttpRouter {
         let action = false;
         try {
             const method = req.method.toUpperCase();
-            const canonicalPathname = path == null ? null : BasePath.apply(path, BASE_PATH);
+            const canonicalPathname = path == null ? null : applyBasePath(path, BASE_PATH);
             if (canonicalPathname != null &&
                 (method === 'GET' || method === 'HEAD') &&
                 canonicalPathname !== url.pathname) {
@@ -197,13 +197,13 @@ export class HttpRouter {
                 const error = new HttpException(404, 'Not found');
                 // unmatched requests still go through the same error hook shape as matched ones
                 return (this.#onError?.(error, Object.assign(req, {
-                    [Solas.Config.REQUEST_META_KEY]: { match: null, error, action },
+                    [Config.REQUEST_META_KEY]: { match: null, error, action },
                 })) ?? new Response(error.message, { status: error.status }));
             }
             const matched = match;
             // attach route state once so middleware and handlers read the same request data
             const request = Object.assign(req, {
-                [Solas.Config.REQUEST_META_KEY]: { match: matched, action, parsedFormData },
+                [Config.REQUEST_META_KEY]: { match: matched, action, parsedFormData },
             });
             // check csrf before any middleware or handler runs
             enforce(request, this.opts.csrf);
@@ -215,7 +215,7 @@ export class HttpRouter {
             // turn unknown throws into Error objects so the error hook sees one shape
             const error = err instanceof Error ? err : new Error(String(err), { cause: err });
             const request = Object.assign(req, {
-                [Solas.Config.REQUEST_META_KEY]: { match, error, action },
+                [Config.REQUEST_META_KEY]: { match, error, action },
             });
             if (this.#onError)
                 return this.#onError(error, request);

package/dist/internal/metadata.d.ts

@@ -1,5 +1,5 @@
 import type { HttpException } from './navigation/http-exception.js';
-import { Build } from './build.js';
+import * as Build from './build.js';
 type EntryKind = typeof Build.EntryKind;
 export declare namespace Metadata {
     type EntrySource = Exclude<EntryKind[keyof EntryKind], typeof Build.EntryKind.ENDPOINT | typeof Build.EntryKind.MIDDLEWARE>;

package/dist/internal/metadata.js

@@ -1,4 +1,4 @@
-import { Build } from './build.js';
+import * as Build from './build.js';
 import { isHttpException } from './navigation/http-exception.js';
 const TITLE_TEMPLATE_STR = '%s';
 export { Metadata };

package/dist/internal/navigation/http-exception-boundary.d.ts

@@ -1,4 +1,4 @@
-import type { BoundaryError } from '../../types.js';
+import type { BoundaryError } from '../boundary-error.js';
 import { type HttpException } from './http-exception.js';
 type ComponentsMap = Partial<Record<HttpException.StatusCode, React.ReactElement | null>>;
 export type Props = {

package/dist/internal/navigation/redirect-boundary.d.ts

@@ -1,4 +1,4 @@
-import type { BoundaryError } from '../../types.js';
+import type { BoundaryError } from '../boundary-error.js';
 export type Props = {
     fallback: ((error: BoundaryError) => React.ReactNode) | React.ReactNode;
     children: React.ReactNode;

package/dist/internal/navigation/redirect.js

@@ -1,4 +1,4 @@
-import { Solas } from '../../solas.js';
+import * as Config from '../../config.js';
 function isRedirectStatusCode(value) {
     return value === 301 || value === 302 || value === 307 || value === 308;
 }
@@ -24,12 +24,12 @@ export const REDIRECT_DIGEST_PREFIX = 'REDIRECT';
  */
 function validate(url) {
     if (url.startsWith('//')) {
-        throw new TypeError(`[${Solas.Config.NAME}] redirect() does not allow protocol-relative urls`);
+        throw new TypeError(`[${Config.NAME}] redirect() does not allow protocol-relative urls`);
     }
     // reject urls with control characters to prevent header injection
     for (const char of url) {
         if (char === '\r' || char === '\n') {
-            throw new TypeError(`[${Solas.Config.NAME}] redirect() does not allow control characters`);
+            throw new TypeError(`[${Config.NAME}] redirect() does not allow control characters`);
         }
     }
     // good
@@ -40,10 +40,10 @@ function validate(url) {
         parsed = new URL(url);
     }
     catch {
-        throw new TypeError(`[${Solas.Config.NAME}] redirect() only supports relative paths or absolute http/https urls`);
+        throw new TypeError(`[${Config.NAME}] redirect() only supports relative paths or absolute http/https urls`);
     }
     if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-        throw new TypeError(`[${Solas.Config.NAME}] redirect() only supports http:// and https:// urls`);
+        throw new TypeError(`[${Config.NAME}] redirect() only supports http:// and https:// urls`);
     }
 }
 /**
@@ -87,7 +87,7 @@ export function toRedirect(err) {
             ? err.url
             : undefined);
     if (!url) {
-        throw new TypeError(`[${Solas.Config.NAME}] failed to reconstruct redirect`);
+        throw new TypeError(`[${Config.NAME}] failed to reconstruct redirect`);
     }
     return new Redirect(url, status);
 }

package/dist/internal/postbuild.js

@@ -1,13 +1,14 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { Compress } from '../utils/compress.js';
+import * as Compress from '../utils/compress.js';
 import { Logger } from '../utils/logger.js';
-import { Solas } from '../solas.js';
-import { Prerender } from './prerender.js';
+import * as Config from '../config.js';
+import * as Manifest from '../manifest.js';
+import * as 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');
+    const manifestPath = path.join(cwd, Config.GENERATED_DIR, 'build.json');
     let manifest;
     try {
         const raw = await fs.readFile(manifestPath, 'utf-8');
@@ -17,15 +18,15 @@ export async function postbuild(cwd = process.cwd()) {
         logger.error('[build] failed to read build manifest', err);
         throw err;
     }
-    const outDir = path.resolve(cwd, Solas.Config.OUT_DIR);
+    const outDir = path.resolve(cwd, Config.OUT_DIR);
     const rscDir = path.join(outDir, 'rsc');
-    const artifactRoot = Prerender.Artifact.getRootPath(outDir);
+    const artifactRoot = Prerender.getArtifactRootPath(outDir);
     // 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 });
-    const artifactManifest = {};
+    const artfifactManifest = {};
     if (manifest.prerenderRoutes.length > 0) {
-        const concurrency = Prerender.Build.getConcurrency();
+        const concurrency = Prerender.getConcurrency();
         const pendingWrites = new Set();
         logger.info('[prerender]', `prerendering ${manifest.prerenderRoutes.length} routes (concurrency: ${concurrency})...`);
         const rscEntry = path.join(rscDir, 'index.js');
@@ -39,7 +40,7 @@ export async function postbuild(cwd = process.cwd()) {
                 await Promise.race(pendingWrites);
             }
         }
-        for await (const result of Prerender.Build.run(app, manifest.prerenderRoutes, {
+        for await (const result of Prerender.run(app, manifest.prerenderRoutes, {
             base: manifest.base,
             concurrency,
             origin: manifest.url,
@@ -54,7 +55,7 @@ export async function postbuild(cwd = process.cwd()) {
                 continue;
             }
             const artifact = result.artifact;
-            const artifactDir = Prerender.Artifact.getPath(outDir, route);
+            const artifactDir = Prerender.getArtifactPath(outDir, route);
             await enqueueWrite(async () => {
                 try {
                     if (artifact.mode === 'ppr') {
@@ -72,7 +73,7 @@ export async function postbuild(cwd = process.cwd()) {
                             writes.push(Runtime.write(path.join(artifactDir, 'postponed.json'), JSON.stringify(artifact.postponed)));
                         }
                         await Promise.all(writes);
-                        artifactManifest[route] = {
+                        artfifactManifest[route] = {
                             mode: artifact.mode,
                             files: artifact.postponed !== undefined
                                 ? ['metadata', 'prelude', 'postponed']
@@ -89,9 +90,9 @@ export async function postbuild(cwd = process.cwd()) {
                             createdAt: artifact.createdAt,
                             mode: artifact.mode,
                         })),
-                        Runtime.write(Prerender.Artifact.getFilePath(outDir, route, Prerender.Artifact.FULL_PRERENDER_FILENAME), artifact.html),
+                        Runtime.write(Prerender.getArtifactFilePath(outDir, route, Prerender.FULL_PRERENDER_FILENAME), artifact.html),
                     ]);
-                    artifactManifest[route] = {
+                    artfifactManifest[route] = {
                         mode: artifact.mode,
                         files: ['metadata', 'html'],
                     };
@@ -106,10 +107,10 @@ export async function postbuild(cwd = process.cwd()) {
     }
     await fs.mkdir(artifactRoot, { recursive: true });
     const runtimeManifest = {
-        artifacts: artifactManifest,
+        artifacts: artfifactManifest,
         publicFiles: manifest.publicFiles,
     };
-    await Runtime.write(Solas.Runtime.getManifestPath(outDir), JSON.stringify(runtimeManifest));
+    await Runtime.write(Manifest.getManifestPath(outDir), JSON.stringify(runtimeManifest));
     if (manifest.sitemapRoutes.length > 0 && manifest.url) {
         const origin = manifest.url.replace(/\/$/, '');
         const urls = manifest.sitemapRoutes
@@ -141,8 +142,8 @@ export async function postbuild(cwd = process.cwd()) {
                 }
                 // full prerendered html is served straight from disk, but internal ppr
                 // support files like prelude/metadata/postponed are read by the server
-                return (normalisedPath.startsWith(`${Solas.Config.GENERATED_DIR}/ppr/`) &&
-                    normalisedPath.endsWith(`/${Prerender.Artifact.FULL_PRERENDER_FILENAME}`));
+                return (normalisedPath.startsWith(`${Config.GENERATED_DIR}/ppr/`) &&
+                    normalisedPath.endsWith(`/${Prerender.FULL_PRERENDER_FILENAME}`));
             },
         })) {
             await Runtime.write(`${input}.br`, compressed);