@jk2908/solas 0.3.0 → 0.3.2

package/dist/internal/{router → http-router}/router.js

@@ -1,13 +1,13 @@
 import path from 'node:path';
 import { match as createMatch } from 'path-to-regexp';
 import { Solas } from '../../solas.js';
-import { getAlternatePathname, normalisePathname, toPathPattern } from './utils.js';
 import { HttpException } from '../navigation/http-exception.js';
 import { maybeAction } from '../server/actions.js';
+import { getAlternatePathname, normalisePathname, toPathPattern } from './utils.js';
 /**
  * Handle routing and matching for server requests
  */
-export class Router {
+export class HttpRouter {
     opts;
     static #matchers = new WeakMap();
     #routes = {
@@ -54,7 +54,7 @@ export class Router {
         const routePath = !path.includes(':') && !path.includes('*')
             ? normalisePathname(path, this.opts.trailingSlash ?? 'never')
             : path;
-        const segments = Router.#split(routePath);
+        const segments = HttpRouter.#split(routePath);
         const tokens = [];
         let score = 0;
         let wildcard = false;
@@ -122,7 +122,7 @@ export class Router {
      * Match a path and method, returning params and route
      */
     match(path, method) {
-        for (const candidate of Router.#candidates(path)) {
+        for (const candidate of HttpRouter.#candidates(path)) {
             const direct = this.#routes.static.get(`${method}:${candidate}`);
             if (direct)
                 return { route: direct, params: {} };
@@ -133,25 +133,25 @@ export class Router {
             }
         }
         // else dynamic/wildcard match
-        const segments = Router.#split(path);
+        const segments = HttpRouter.#split(path);
         // try the leading-static prefix bucket first
         const prefixed = this.#routes.dynamic.byPrefix.get(segments[0] ?? '');
-        const prefixedMatch = prefixed ? Router.#pick(prefixed, segments, method) : null;
+        const prefixedMatch = prefixed ? HttpRouter.#pick(prefixed, segments, method) : null;
         if (prefixedMatch)
             return prefixedMatch;
         // if the prefix bucket has no winner, fall back to all dynamic
         // routes with the same segment count
-        const dynamicMatch = Router.#pick(this.#routes.dynamic.byLength.get(segments.length) ?? [], segments, method);
+        const dynamicMatch = HttpRouter.#pick(this.#routes.dynamic.byLength.get(segments.length) ?? [], segments, method);
         if (dynamicMatch)
             return dynamicMatch;
         // finally check wildcard routes, prefixed first, then fully generic ones
         const wildcardPrefixed = this.#routes.wildcard.byPrefix.get(segments[0] ?? '');
         const wildcardMatch = wildcardPrefixed
-            ? Router.#pick(wildcardPrefixed, segments, method)
+            ? HttpRouter.#pick(wildcardPrefixed, segments, method)
             : null;
         if (wildcardMatch)
             return wildcardMatch;
-        const wildcardFallbackMatch = Router.#pick(this.#routes.wildcard.fallback, segments, method);
+        const wildcardFallbackMatch = HttpRouter.#pick(this.#routes.wildcard.fallback, segments, method);
         if (wildcardFallbackMatch)
             return wildcardFallbackMatch;
         // no match
@@ -192,14 +192,14 @@ export class Router {
                 // unmatched requests still pass through the shared error hook with the
                 // same request metadata shape as matched requests
                 return (this.#onError?.(error, Object.assign(req, {
-                    [Solas.Config.REQUEST_META]: { match: null, error, action },
+                    [Solas.Config.REQUEST_META_KEY]: { match: null, error, action },
                 })) ?? new Response(error.message, { status: error.status }));
             }
             const matched = match;
             // attach routing state to the request once so middleware and handlers can
             // read the same per-request metadata
             const request = Object.assign(req, {
-                [Solas.Config.REQUEST_META]: { match: matched, action, parsedFormData },
+                [Solas.Config.REQUEST_META_KEY]: { match: matched, action, parsedFormData },
             });
             // global middleware stays outside route middleware by preserving
             // registration order here before composition in #run
@@ -210,7 +210,7 @@ export class Router {
             // normalise unknown throwables so the error hook always receives an Error
             const error = err instanceof Error ? err : new Error(String(err), { cause: err });
             const request = Object.assign(req, {
-                [Solas.Config.REQUEST_META]: { match, error, action },
+                [Solas.Config.REQUEST_META_KEY]: { match, error, action },
             });
             if (this.#onError)
                 return this.#onError(error, request);
@@ -270,7 +270,7 @@ export class Router {
                 return new Response('Forbidden', { status: 403 });
             }
             // emitted assets are fingerprinted so they can be cached aggressively
-            return Router.serve(filePath, req, config.precompress, {
+            return HttpRouter.serve(filePath, req, config.precompress, {
                 'Cache-Control': 'public, immutable, max-age=31536000',
             });
         };
@@ -343,7 +343,7 @@ export class Router {
      * Get or create a path matcher for a route using path-to-regexp
      */
     static #getMatcher(route) {
-        const cached = Router.#matchers.get(route);
+        const cached = HttpRouter.#matchers.get(route);
         if (cached)
             return cached;
         // convert route tokens back into a path pattern for path-to-regexp to compile
@@ -352,7 +352,7 @@ export class Router {
         const matcher = createMatch(path, {
             decode: false,
         });
-        Router.#matchers.set(route, matcher);
+        HttpRouter.#matchers.set(route, matcher);
         return matcher;
     }
     /**
@@ -375,7 +375,8 @@ export class Router {
         for (let index = 0; index < length; index += 1) {
             // prefer static over dynamic and dynamic over wildcard at the
             // first segment position where the two routes differ
-            const diff = Router.#getTokenRank(a.tokens[index]) - Router.#getTokenRank(b.tokens[index]);
+            const diff = HttpRouter.#getTokenRank(a.tokens[index]) -
+                HttpRouter.#getTokenRank(b.tokens[index]);
             if (diff !== 0)
                 return diff;
         }
@@ -399,11 +400,11 @@ export class Router {
             }
             // skip routes that do not fit this path. Only compare specificity
             // across matched routes
-            const params = Router.#fit(route, segments);
+            const params = HttpRouter.#fit(route, segments);
             if (!params)
                 continue;
             // replace the winner only when this route is strictly more specific
-            if (!best || Router.#compare(route, best) > 0) {
+            if (!best || HttpRouter.#compare(route, best) > 0) {
                 best = route;
                 bestParams = params;
             }
@@ -426,7 +427,7 @@ export class Router {
         }
         // defer the actual param extraction to the cached path-to-regexp matcher so
         // dynamic and wildcard params stay consistent with registration
-        const matched = Router.#getMatcher(route)(segments.length ? `/${segments.join('/')}` : '/');
+        const matched = HttpRouter.#getMatcher(route)(segments.length ? `/${segments.join('/')}` : '/');
         if (!matched)
             return null;
         return matched.params;

package/dist/internal/{router → http-router}/utils.d.ts

@@ -1,4 +1,4 @@
-import type { Route } from '../../types.js';
+import type { PluginConfig } from '../../types.js';
 export type PathPattern = {
     path: string;
     wildcardNames: Set<string>;
@@ -14,8 +14,16 @@ export declare function toPathPattern(route: string, paramNames?: string[]): {
 /**
  * Apply the configured trailing-slash policy to a pathname
  */
-export declare function normalisePathname(pathname: string, trailingSlash?: Route.TrailingSlash): string;
+export declare function normalisePathname(pathname: string, trailingSlash?: PluginConfig['trailingSlash']): string;
 /**
- * Return the other pathname shape for a non-root route
+ * Return the other pathname shape for a non-root route. For use within
+ * trailingSlash logic to easily switch between shapes
+ *
+ * @example
+ * ```ts
+ * 	getAlternatePathname('/about') // '/about/'
+ * 	getAlternatePathname('/about/') // '/about'
+ * 	getAlternatePathname('/') // '/'
+ * ```
  */
 export declare function getAlternatePathname(pathname: string): string;

package/dist/internal/{router → http-router}/utils.js

@@ -53,7 +53,15 @@ export function normalisePathname(pathname, trailingSlash = 'never') {
     return pathname.endsWith('/') ? pathname.slice(0, -1) : pathname;
 }
 /**
- * Return the other pathname shape for a non-root route
+ * Return the other pathname shape for a non-root route. For use within
+ * trailingSlash logic to easily switch between shapes
+ *
+ * @example
+ * ```ts
+ * 	getAlternatePathname('/about') // '/about/'
+ * 	getAlternatePathname('/about/') // '/about'
+ * 	getAlternatePathname('/') // '/'
+ * ```
  */
 export function getAlternatePathname(pathname) {
     if (pathname === '/')

package/dist/internal/metadata.js

@@ -85,15 +85,6 @@ var Metadata;
             metadata.link = [...linkMap.values()];
             return metadata;
         }
-        /**
-         * Clones an object using structuredClone w/ JSON fallback
-         */
-        static #clone(obj) {
-            if (typeof structuredClone === 'function') {
-                return structuredClone(obj);
-            }
-            return JSON.parse(JSON.stringify(obj));
-        }
         /**
          * Gets a unique key for the meta tag
          */
@@ -123,6 +114,15 @@ var Metadata;
             }
             return this;
         }
+        /**
+         * Clones an object using structuredClone w/ JSON fallback
+         */
+        static #clone(obj) {
+            if (typeof structuredClone === 'function') {
+                return structuredClone(obj);
+            }
+            return JSON.parse(JSON.stringify(obj));
+        }
         /**
          * Merges metadata from all sources, sorted by priority
          */
@@ -130,7 +130,7 @@ var Metadata;
             const items = [...this.#collection].sort((a, b) => a.priority - b.priority);
             if (items.length === 0)
                 return Collection.#clone(this.#base);
-            let merged = Collection.#clone(this.#base);
+            let merged = this.#base;
             const res = await Promise.allSettled(items.map(item => item.task));
             const ok = res
                 .filter((result) => result.status === 'fulfilled')

package/dist/internal/prerender.d.ts

@@ -14,14 +14,9 @@ export declare namespace Prerender {
         type Metadata = Pick<Value, 'schema' | 'route' | 'createdAt' | 'mode'>;
         type ManifestEntry = {
             mode: Mode;
-            createdAt: number;
-            files?: File[];
-            fullPrerenderFilename?: string;
-        };
-        type Manifest = {
-            generatedAt: number;
-            routes: Record<string, ManifestEntry>;
+            files?: readonly File[];
         };
+        type Manifest = Record<string, ManifestEntry>;
         /**
          * Get the root directory path where prerender artifacts are stored,
          * based on the output directory specified in the configuration
@@ -41,9 +36,9 @@ export declare namespace Prerender {
          */
         function getFilePath(outDir: string, pathname: string, fileName: string): string;
         /**
-         * 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: string): string;
+        const FULL_PRERENDER_FILENAME = "prerendered.html";
         /**
          * Load the prerender artifact manifest for faster runtime route mode checks
          */

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)