@jk2908/solas 0.3.1 → 0.3.2

package/dist/internal/prerender.js

@@ -1,9 +1,9 @@
 import path from 'node:path';
 import { compile } from 'path-to-regexp';
-import { Solas } from '../solas.js';
 import { Logger } from '../utils/logger.js';
 import { Time } from '../utils/time.js';
-import { toPathPattern } from './router/utils.js';
+import { Solas } from '../solas.js';
+import { toPathPattern } from './http-router/utils.js';
 const logger = new Logger();
 export { Prerender };
 var Prerender;
@@ -63,12 +63,9 @@ var Prerender;
         }
         Artifact.getFilePath = getFilePath;
         /**
-         * Build a deterministic file name for a full prerender html artifact
+         * File name used for saved full-prerender html inside each route artifact directory
          */
-        function getFullHtmlFileName(html) {
-            return `html.${Bun.hash(html).toString(16)}.html`;
-        }
-        Artifact.getFullHtmlFileName = getFullHtmlFileName;
+        Artifact.FULL_PRERENDER_FILENAME = 'prerendered.html';
         /**
          * Load the prerender artifact manifest for faster runtime route mode checks
          */
@@ -91,12 +88,7 @@ var Prerender;
                     manifestCache.set(outDir, null);
                     return null;
                 }
-                const generatedAt = value.generatedAt;
                 const routes = value.routes;
-                if (typeof generatedAt !== 'number') {
-                    manifestCache.set(outDir, null);
-                    return null;
-                }
                 if (!routes || typeof routes !== 'object') {
                     manifestCache.set(outDir, null);
                     return null;
@@ -107,16 +99,12 @@ var Prerender;
                         manifestCache.set(outDir, null);
                         return null;
                     }
-                    const { mode, createdAt, files } = entry;
+                    const { mode, files } = entry;
                     // only allow known modes
                     if (mode !== 'full' && mode !== 'ppr') {
                         manifestCache.set(outDir, null);
                         return null;
                     }
-                    if (typeof createdAt !== 'number') {
-                        manifestCache.set(outDir, null);
-                        return null;
-                    }
                     if (files !== undefined) {
                         if (!Array.isArray(files)) {
                             manifestCache.set(outDir, null);
@@ -133,13 +121,8 @@ var Prerender;
                             }
                         }
                     }
-                    if (entry.fullPrerenderFilename !== undefined &&
-                        !isArtifactFileName(entry.fullPrerenderFilename)) {
-                        manifestCache.set(outDir, null);
-                        return null;
-                    }
                 }
-                const manifest = { generatedAt, routes };
+                const manifest = routes;
                 // cache validated manifest to avoid reparsing on every request
                 manifestCache.set(outDir, manifest);
                 return manifest;

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 { Solas } from '../../solas.js';
 import { Logger } from '../../utils/logger.js';
+import { Solas } from '../../solas.js';
 const logger = new Logger();
 const cache = new WeakMap();
 /**

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

@@ -1,4 +1,4 @@
-import type { Resolver } from '../router/resolver.js';
+import type { Resolver } from '../resolver.js';
 type Match = NonNullable<Resolver.EnhancedMatch>;
 /**
  * Render the resolved route tree for a matched page

package/dist/internal/render/tree.js

@@ -1,8 +1,12 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Suspense } from 'react';
-import { HttpException, isHttpException } from '../navigation/http-exception.js';
 import { HttpExceptionBoundary } from '../navigation/http-exception-boundary.js';
+import { HttpException, isHttpException } from '../navigation/http-exception.js';
 import DefaultErr from '../ui/defaults/error.js';
+const UNAUTHORISED_ERROR = new HttpException(401, 'Unauthorised');
+const FORBIDDEN_ERROR = new HttpException(403, 'Forbidden');
+const NOT_FOUND_ERROR = new HttpException(404, 'Not found');
+const SERVER_ERROR = new HttpException(500, 'Internal Server Error');
 /**
  * Render the resolved route tree for a matched page
  *
@@ -42,7 +46,7 @@ import DefaultErr from '../ui/defaults/error.js';
  * ```
  */
 export function Tree({ depth, params, error, ui, }) {
-    const { layouts, Page, '401s': unauthorized, '403s': forbidden, '404s': notFounds, '500s': serverErrors, loaders, } = ui;
+    const { layouts, Page, '401s': unauthorised, '403s': forbidden, '404s': notFounds, '500s': serverErrors, loaders, } = ui;
     const Shell = layouts[0];
     if (!Shell)
         throw new Error('Shell layout is required in the route tree');
@@ -50,7 +54,7 @@ export function Tree({ depth, params, error, ui, }) {
     let inner = null;
     // map http status codes to exception components
     const httpExceptionMap = {
-        401: unauthorized,
+        401: unauthorised,
         403: forbidden,
         404: notFounds,
         500: serverErrors,
@@ -69,7 +73,7 @@ export function Tree({ depth, params, error, ui, }) {
     for (let idx = layouts.length - 1; idx >= 1; idx--) {
         const Layout = layouts[idx];
         const Loading = loaders[idx];
-        const Unauthorized = unauthorized[idx];
+        const Unauthorised = unauthorised[idx];
         const Forbidden = forbidden[idx];
         const NotFound = notFounds[idx];
         const ServerError = serverErrors[idx];
@@ -82,10 +86,10 @@ export function Tree({ depth, params, error, ui, }) {
             inner = _jsx(Suspense, { fallback: _jsx(Loading, {}), children: inner });
         }
         const errorBoundaries = {
-            401: Unauthorized ? (_jsx(Unauthorized, { error: new HttpException(401, 'Unauthorized') })) : null,
-            403: Forbidden ? _jsx(Forbidden, { error: new HttpException(403, 'Forbidden') }) : null,
-            404: NotFound ? _jsx(NotFound, { error: new HttpException(404, 'Not found') }) : null,
-            500: ServerError ? (_jsx(ServerError, { error: new HttpException(500, 'Internal Server Error') })) : null,
+            401: Unauthorised ? _jsx(Unauthorised, { error: UNAUTHORISED_ERROR }) : null,
+            403: Forbidden ? _jsx(Forbidden, { error: FORBIDDEN_ERROR }) : null,
+            404: NotFound ? _jsx(NotFound, { error: NOT_FOUND_ERROR }) : null,
+            500: ServerError ? _jsx(ServerError, { error: SERVER_ERROR }) : null,
         };
         // wrap in error boundaries (if supplied for this segment's http errors)
         if (Object.values(errorBoundaries).some(c => c !== null)) {
@@ -95,14 +99,14 @@ export function Tree({ depth, params, error, ui, }) {
     // now wrap with shell structure: shell renders immediately,
     // inner streams inside Suspense
     const ShellLoading = loaders[0];
-    const ShellUnauthorized = unauthorized[0];
+    const Shellunauthorised = unauthorised[0];
     const ShellForbidden = forbidden[0];
     const ShellNotFound = notFounds[0];
     const ShellServerError = serverErrors[0];
     return (_jsx(HttpExceptionBoundary, { components: {
-            401: ShellUnauthorized ? _jsx(ShellUnauthorized, {}) : null,
-            403: ShellForbidden ? _jsx(ShellForbidden, {}) : null,
-            404: ShellNotFound ? _jsx(ShellNotFound, {}) : null,
-            500: ShellServerError ? _jsx(ShellServerError, {}) : null,
+            401: Shellunauthorised ? _jsx(Shellunauthorised, { error: UNAUTHORISED_ERROR }) : null,
+            403: ShellForbidden ? _jsx(ShellForbidden, { error: FORBIDDEN_ERROR }) : null,
+            404: ShellNotFound ? _jsx(ShellNotFound, { error: NOT_FOUND_ERROR }) : null,
+            500: ShellServerError ? _jsx(ShellServerError, { error: SERVER_ERROR }) : null,
         }, children: _jsx(Suspense, { fallback: ShellLoading ? _jsx(ShellLoading, {}) : null, children: _jsx(Shell, { params: params, children: inner }) }) }));
 }

package/dist/internal/{router/resolver.d.ts → resolver.d.ts}

@@ -1,7 +1,7 @@
-import type { ImportMap, Manifest, ManifestEntry, Primitive, View } from '../../types.js';
-import type { Router } from './router.js';
-import { Metadata } from '../metadata.js';
-import { HttpException } from '../navigation/http-exception.js';
+import type { ImportMap, Manifest, ManifestEntry, Primitive, View } from '../types.js';
+import { HttpRouter } from './http-router/router.js';
+import { Metadata } from './metadata.js';
+import { HttpException } from './navigation/http-exception.js';
 export declare namespace Resolver {
     type ReconciledMatch = ReturnType<Resolver['reconcile']>;
     type CachedEnhancedMatch = Omit<EnhancedMatch, 'params' | 'error'>;
@@ -9,11 +9,11 @@ export declare namespace Resolver {
         ui: {
             layouts: (View<{
                 children?: React.ReactNode;
-                params?: Router.Params;
+                params?: HttpRouter.Params;
             }> | null)[];
             Page: View<{
                 children?: React.ReactNode;
-                params?: Router.Params;
+                params?: HttpRouter.Params;
             }> | null;
             '401s': (View<{
                 children?: React.ReactNode;
@@ -37,13 +37,13 @@ export declare namespace Resolver {
         };
         error?: HttpException | Error;
         endpoint?: (req?: Request & {
-            params?: Router.Params;
+            params?: HttpRouter.Params;
         }) => unknown;
-        metadata?: (input: Metadata.Input<Router.Params>) => Metadata.Task[];
+        metadata?: (input: Metadata.Input<HttpRouter.Params>) => Metadata.Task[];
     };
 }
 /**
- * Resolve router matches against the application manifest and import map
+ * Resolve HttpRouter matches against the application manifest and import map
  */
 export declare class Resolver {
     #private;
@@ -55,15 +55,17 @@ export declare class Resolver {
     /**
      * Narrow down a route entry to a page entry if it exists
      */
-    static narrow(entry?: ManifestEntry | ManifestEntry[]): import("../../types.js").Segment | null;
+    static narrow(entry?: ManifestEntry | ManifestEntry[]): import("../types.js").Segment | null;
     /**
      * Get the status code for a matched route that may or may not have errored
      */
     static getMatchStatusCode(match: Resolver.ReconciledMatch | Resolver.EnhancedMatch | null): 200 | HttpException.StatusCode;
     /**
-     * Reconcile a router match against a manifest entry
+     * Reconcile a HttpRouter match against a manifest entry
      */
-    reconcile(path: string, match: Router.Match | null, error?: Error): {
+    reconcile(path: string, match: HttpRouter.Match | null, error?: Error): {
+        params: HttpRouter.Params;
+        error: Error | undefined;
         __id: string;
         __path: string;
         __params: string[];
@@ -83,9 +85,9 @@ export declare class Resolver {
         prerender: "full" | "ppr" | false;
         dynamic: boolean;
         wildcard: boolean;
-        params: Router.Params;
-        error: Error | undefined;
     } | {
+        params: {};
+        error: HttpException;
         __id: string;
         __path: string;
         __params: string[];
@@ -105,40 +107,19 @@ export declare class Resolver {
         prerender: "full" | "ppr" | false;
         dynamic: boolean;
         wildcard: boolean;
-        params: {};
-        error: HttpException;
     } | null;
     /**
      * Enhance a matched route with its associated components
      */
     enhance(match: Resolver.ReconciledMatch | null): {
-        __id: string;
-        __path: string;
-        __params: string[];
-        __kind: "$P";
-        __depth: number;
-        method: "get";
-        paths: {
-            layouts: (string | null)[];
-            '401s': (string | null)[];
-            '403s': (string | null)[];
-            '404s': (string | null)[];
-            '500s': (string | null)[];
-            loaders: (string | null)[];
-            middlewares: (string | null)[];
-            page?: string | null | undefined;
-        };
-        prerender: "full" | "ppr" | false;
-        dynamic: boolean;
-        wildcard: boolean;
         ui: {
             layouts: (View<{
                 children?: import("react").ReactNode;
-                params?: Router.Params | undefined;
+                params?: HttpRouter.Params | undefined;
             }> | null)[];
             Page: View<{
                 children?: import("react").ReactNode;
-                params?: Router.Params | undefined;
+                params?: HttpRouter.Params | undefined;
             }> | null;
             '401s': (View<{
                 children?: import("react").ReactNode;
@@ -161,14 +142,33 @@ export declare class Resolver {
             }> | null)[];
         };
         endpoint?: ((req?: (Request & {
-            params?: Router.Params | undefined;
+            params?: HttpRouter.Params | undefined;
         }) | undefined) => unknown) | undefined;
-        metadata?: ((input: Metadata.Input<Router.Params, Error>) => Metadata.Task[]) | undefined;
-        params: Router.Params | {};
+        metadata?: ((input: Metadata.Input<HttpRouter.Params, Error>) => Metadata.Task[]) | undefined;
+        params: HttpRouter.Params | {};
         error: Error | HttpException | undefined;
+        __id: string;
+        __path: string;
+        __params: string[];
+        __kind: "$P";
+        __depth: number;
+        method: "get";
+        paths: {
+            layouts: (string | null)[];
+            '401s': (string | null)[];
+            '403s': (string | null)[];
+            '404s': (string | null)[];
+            '500s': (string | null)[];
+            loaders: (string | null)[];
+            middlewares: (string | null)[];
+            page?: string | null | undefined;
+        };
+        prerender: "full" | "ppr" | false;
+        dynamic: boolean;
+        wildcard: boolean;
     } | null;
     /**
      * Find the closest ancestor entry for a given path and property
      */
-    closest(path: string, property: string, value?: Omit<Primitive, 'undefined'>): import("../../types.js").Segment | null;
+    closest(path: string, property: string, value?: Omit<Primitive, 'undefined'>): import("../types.js").Segment | null;
 }

package/dist/internal/{router/resolver.js → resolver.js}

@@ -1,12 +1,12 @@
 import { lazy } from 'react';
-import { Logger } from '../../utils/logger.js';
-import { Build } from '../build.js';
-import { Metadata } from '../metadata.js';
-import { HttpException, isHttpException } from '../navigation/http-exception.js';
+import { Logger } from '../utils/logger.js';
+import { Build } from './build.js';
+import { Metadata } from './metadata.js';
+import { HttpException, isHttpException } from './navigation/http-exception.js';
 const logger = new Logger();
 const IS_DEV = import.meta.env.DEV;
 /**
- * Resolve router matches against the application manifest and import map
+ * Resolve HttpRouter matches against the application manifest and import map
  */
 export class Resolver {
     /**
@@ -122,13 +122,13 @@ export class Resolver {
         return entry.Component;
     }
     /**
-     * Reconcile a router match against a manifest entry
+     * Reconcile a HttpRouter match against a manifest entry
      */
     reconcile(path, match, error) {
         if (match) {
             const entry = Resolver.narrow(Resolver.#getEntryByPath(this.#manifest, match.route.path));
             if (entry) {
-                // normal case, the router matched a page route so just attach request state
+                // normal case, the HttpRouter matched a page route so just attach request state
                 return {
                     ...entry,
                     params: match.params,

package/dist/internal/server/actions.js

@@ -68,7 +68,7 @@ export async function processActionRequest(req) {
         // 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]?.parsedFormData;
+        const parsedFormData = req[Solas.Config.REQUEST_META_KEY]?.parsedFormData;
         const formData = parsedFormData ?? (await req.formData());
         const decodedAction = await decodeAction(formData);
         const result = await decodedAction();

package/dist/internal/server/cookies.d.ts

@@ -1,6 +1,7 @@
 import { Cookies } from '../../utils/cookies.js';
 /**
  * Get the request cookies as a Cookies instance
- * @returns a read-only Cookies instance containing the request cookies
+ * @returns a Promise resolving to a read-only Cookies instance containing the
+ * request cookies
  */
-export declare function cookies(): Readonly<ReturnType<typeof Cookies.parse>>;
+export declare function cookies(): Promise<Readonly<ReturnType<typeof Cookies.parse>>>;

package/dist/internal/server/cookies.js

@@ -3,10 +3,11 @@ import { RequestContext } from '../env/request-context.js';
 import { dynamic } from './dynamic.js';
 /**
  * Get the request cookies as a Cookies instance
- * @returns a read-only Cookies instance containing the request cookies
+ * @returns a Promise resolving to a read-only Cookies instance containing the
+ * request cookies
  */
-export function cookies() {
-    dynamic();
+export async function cookies() {
+    await dynamic();
     const { req, cache } = RequestContext.use();
     // use request cache if possible to avoid reparsing
     if (cache.cookies)

package/dist/internal/server/dynamic.d.ts

@@ -3,7 +3,5 @@
  * @description in prerender mode this suspends forever so the nearest Suspense
  * boundary renders its fallback into the static shell. In request mode this
  * resolves immediately
- * @returns void during normal requests or prerender not in ppr mode
- * @throws if called in prerender mode (the desired effect)
  */
-export declare function dynamic(): void;
+export declare function dynamic(): Promise<void>;

package/dist/internal/server/dynamic.js

@@ -1,22 +1,14 @@
-import { Logger } from '../../utils/logger.js';
 import { RequestContext } from '../env/request-context.js';
-const logger = new Logger();
 const NEVER = new Promise(() => { });
 /**
  * Declaratively mark render below this call as request-time only
  * @description in prerender mode this suspends forever so the nearest Suspense
  * boundary renders its fallback into the static shell. In request mode this
  * resolves immediately
- * @returns void during normal requests or prerender not in ppr mode
- * @throws if called in prerender mode (the desired effect)
  */
-export function dynamic() {
+export async function dynamic() {
     const { prerender } = RequestContext.use();
-    if (!prerender)
+    if (prerender !== 'ppr')
         return;
-    if (prerender !== 'ppr') {
-        logger.warn('[dynamic]', "dynamic() was called but prerender mode is not 'ppr'. This means the component will be rendered at build time, which may not be what you intended");
-        return;
-    }
-    throw NEVER;
+    await NEVER;
 }

package/dist/internal/server/headers.d.ts

@@ -1,5 +1,5 @@
 /**
  * Get the request headers as a read-only map
- * @returns a read-only map of request headers
+ * @returns a Promise resolving to a read-only map of request headers
  */
-export declare function headers(): ReadonlyMap<string, string>;
+export declare function headers(): Promise<ReadonlyMap<string, string>>;

package/dist/internal/server/headers.js

@@ -2,10 +2,10 @@ import { RequestContext } from '../env/request-context.js';
 import { dynamic } from './dynamic.js';
 /**
  * Get the request headers as a read-only map
- * @returns a read-only map of request headers
+ * @returns a Promise resolving to a read-only map of request headers
  */
-export function headers() {
-    dynamic();
+export async function headers() {
+    await dynamic();
     const { req, cache } = RequestContext.use();
     // use request cache if possible to avoid reconstructing the map
     if (cache.headers)

package/dist/internal/server/url.d.ts

@@ -1,5 +1,5 @@
 /**
  * Get the request url as a URL instance
- * @returns a URL instance containing the request url
+ * @returns a Promise resolving to a URL instance containing the request url
  */
-export declare function url(): URL;
+export declare function url(): Promise<URL>;

package/dist/internal/server/url.js

@@ -4,10 +4,10 @@ import { dynamic } from './dynamic.js';
 const logger = new Logger();
 /**
  * Get the request url as a URL instance
- * @returns a URL instance containing the request url
+ * @returns a Promise resolving to a URL instance containing the request url
  */
-export function url() {
-    dynamic();
+export async function url() {
+    await dynamic();
     const { req, cache } = RequestContext.use();
     // always return a clone so consumers can mutate (e.g. searchParams.set)
     // without corrupting the cached instance shared across the request

package/dist/navigation.d.ts

@@ -1,6 +1,4 @@
 export { HttpExceptionBoundary } from './internal/navigation/http-exception-boundary.js';
 export { HttpException, abort, isHttpException, } from './internal/navigation/http-exception.js';
-export { Link } from './internal/navigation/link.js';
 export { RedirectBoundary } from './internal/navigation/redirect-boundary.js';
 export { Redirect, isRedirect, redirect } from './internal/navigation/redirect.js';
-export { useSearchParams } from './internal/navigation/use-search-params.js';

package/dist/navigation.js

@@ -1,6 +1,4 @@
 export { HttpExceptionBoundary } from './internal/navigation/http-exception-boundary.js';
 export { HttpException, abort, isHttpException, } from './internal/navigation/http-exception.js';
-export { Link } from './internal/navigation/link.js';
 export { RedirectBoundary } from './internal/navigation/redirect-boundary.js';
 export { Redirect, isRedirect, redirect } from './internal/navigation/redirect.js';
-export { useSearchParams } from './internal/navigation/use-search-params.js';

package/dist/router.d.ts

@@ -1,4 +1,3 @@
-export { createRouter } from './internal/router/create-router.js';
-export { Router } from './internal/router/router.js';
-export { RouterProvider } from './internal/router/router-provider.js';
-export { useRouter } from './internal/router/use-router.js';
+export { Link } from './internal/browser-router/link.js';
+export { useRouter } from './internal/browser-router/use-router.js';
+export { useSearchParams } from './internal/browser-router/use-search-params.js';

package/dist/router.js

@@ -1,4 +1,3 @@
-export { createRouter } from './internal/router/create-router.js';
-export { Router } from './internal/router/router.js';
-export { RouterProvider } from './internal/router/router-provider.js';
-export { useRouter } from './internal/router/use-router.js';
+export { Link } from './internal/browser-router/link.js';
+export { useRouter } from './internal/browser-router/use-router.js';
+export { useSearchParams } from './internal/browser-router/use-search-params.js';

package/dist/solas.d.ts

@@ -1,5 +1,7 @@
 import type { PluginConfig } from './types.js';
 export declare namespace Solas {
+    interface Routes {
+    }
     namespace Config {
         const NAME = "Solas";
         const SLUG: string;
@@ -12,7 +14,7 @@ export declare namespace Solas {
         const ENTRY_BROWSER = "entry.browser.tsx";
         const ASSETS_DIR = "assets";
         const $: unique symbol;
-        const REQUEST_META: string;
+        const REQUEST_META_KEY: string;
         const LOG_LEVELS: readonly ["debug", "info", "warn", "error", "fatal"];
         const PRERENDER_MODES: readonly ["full", "ppr", false];
         const TRAILING_SLASH_MODES: readonly ["always", "never", "ignore"];

package/dist/solas.js

@@ -14,7 +14,7 @@ var Solas;
         Config.ENTRY_BROWSER = 'entry.browser.tsx';
         Config.ASSETS_DIR = 'assets';
         Config.$ = Symbol(Config.SLUG);
-        Config.REQUEST_META = `__${Config.SLUG.toUpperCase()}__`;
+        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'];

package/dist/types.d.ts

@@ -1,19 +1,20 @@
 type BunRequest = Request & {
     params?: Record<string, string | string[]>;
 };
-import { Solas } from './solas.js';
 import { ExportReader } from './utils/export-reader.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 type { Router } from './internal/router/router.js';
+import { BrowserRouter } from './internal/browser-router/router.js';
+import { Solas } from './solas.js';
 export type LogLevel = (typeof Solas.Config.LOG_LEVELS)[number];
 type PluginConfigBase = {
     port?: number;
     precompress?: boolean;
     prerender?: Route.Prerender;
     metadata?: Metadata.Item;
-    trailingSlash?: Route.TrailingSlash;
+    trailingSlash?: (typeof Solas.Config.TRAILING_SLASH_MODES)[number];
     readonly logger?: {
         level?: LogLevel;
     };
@@ -36,6 +37,13 @@ export type BuildContext = {
     knownRoutes: Set<string>;
     exportReader: ExportReader;
 };
+export type RequestMeta = {
+    error?: HttpException | Error;
+    action?: boolean;
+    match: HttpRouter.Match | null;
+    parsedFormData?: FormData | null;
+    url?: URL;
+};
 export type SolasRequest = Request & {};
 export type Segment = {
     __id: string;
@@ -68,6 +76,7 @@ export type Endpoint = {
     middlewares: (string | null)[];
 };
 export type ManifestEntry = Segment | Endpoint;
+export type ManifestEntryGroup = ManifestEntry | [ManifestEntry, ...ManifestEntry[]];
 export type Manifest = Awaited<ReturnType<typeof Build.Finder.prototype.process>>['manifest'];
 export type View<TProps> = React.ComponentType<TProps> | React.LazyExoticComponent<React.ComponentType<TProps>>;
 export type StaticImport = Record<string, unknown>;
@@ -81,7 +90,7 @@ export type MapEntry = {
     '404s'?: readonly (DynamicImport | null)[];
     '500s'?: readonly (DynamicImport | null)[];
     loaders?: readonly (DynamicImport | null)[];
-    middlewares?: readonly (Router.Middleware | null)[];
+    middlewares?: readonly (HttpRouter.Middleware | null)[];
     endpoint?: (req?: BunRequest) => unknown;
 };
 export type ImportMap = Record<string, MapEntry>;
@@ -92,13 +101,12 @@ export type BuildManifest = {
     prerenderRoutes: string[];
     sitemapRoutes: string[];
     precompress: boolean;
-    trailingSlash: Route.TrailingSlash;
+    trailingSlash: (typeof Solas.Config.TRAILING_SLASH_MODES)[number];
     url?: PluginConfig['url'];
 };
 export declare namespace Route {
-    type Metadata = Metadata.Item | ((input: Metadata.Input<Router.Params>) => Promise<Metadata.Item> | Metadata.Item);
+    type Metadata = Metadata.Item | ((input: Metadata.Input<BrowserRouter.Params>) => Promise<Metadata.Item> | Metadata.Item);
     type Prerender = (typeof Solas.Config.PRERENDER_MODES)[number];
-    type TrailingSlash = (typeof Solas.Config.TRAILING_SLASH_MODES)[number];
 }
 export type BoundaryError = Error & {
     digest?: string;

package/dist/utils/logger.js

@@ -1,5 +1,5 @@
-import { Solas } from '../solas.js';
 import { HttpException } from '../internal/navigation/http-exception.js';
+import { Solas } from '../solas.js';
 const LEVELS = {
     debug: 0,
     info: 1,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jk2908/solas",
-	"version": "0.3.1",
+	"version": "0.3.2",
 	"description": "A React Server Components meta-framework powered by Vite",
 	"keywords": [
 		"framework",
@@ -71,10 +71,6 @@
 		"./error-boundary": {
 			"types": "./dist/error-boundary.d.ts",
 			"import": "./dist/error-boundary.js"
-		},
-		"./solas": {
-			"types": "./dist/solas.d.ts",
-			"import": "./dist/solas.js"
 		}
 	},
 	"scripts": {
@@ -89,8 +85,7 @@
 	},
 	"dependencies": {
 		"@vitejs/plugin-rsc": "^0.5.20",
-		"path-to-regexp": "^8.3.0",
-		"rsc-html-stream": "^0.0.7"
+		"path-to-regexp": "^8.3.0"
 	},
 	"devDependencies": {
 		"@prettier/plugin-oxc": "^0.1.3",