@jk2908/solas 0.2.3 → 0.3.0

package/dist/internal/navigation/use-search-params.js

@@ -1,6 +1,8 @@
 import { useMemo, useSyncExternalStore } from 'react';
-import { Solas } from '../../solas';
+import { useRouter } from '../../router.js';
+import { Solas } from '../../solas.js';
 export function useSearchParams() {
+    const { url } = useRouter();
     const search = useSyncExternalStore(fn => {
         window.addEventListener('popstate', fn);
         window.addEventListener(Solas.Events.names.NAVIGATION, fn);
@@ -8,6 +10,6 @@ export function useSearchParams() {
             window.removeEventListener('popstate', fn);
             window.removeEventListener(Solas.Events.names.NAVIGATION, fn);
         };
-    }, () => window.location.search, () => '');
+    }, () => window.location.search, () => url?.search);
     return useMemo(() => new URLSearchParams(search), [search]);
 }

package/dist/internal/prerender.d.ts

@@ -1,4 +1,4 @@
-import type { BuildContext } from '../types';
+import type { BuildContext } from '../types.js';
 export declare namespace Prerender {
     namespace Artifact {
         type Mode = 'full' | 'ppr';
@@ -16,6 +16,7 @@ export declare namespace Prerender {
             mode: Mode;
             createdAt: number;
             files?: File[];
+            fullPrerenderFilename?: string;
         };
         type Manifest = {
             generatedAt: number;
@@ -35,6 +36,14 @@ export declare namespace Prerender {
          * Get the file system path for storing prerender artifacts for a given route
          */
         function getPath(outDir: string, pathname: string): string;
+        /**
+         * Get the file system path for a single prerender artifact file under a route directory
+         */
+        function getFilePath(outDir: string, pathname: string, fileName: string): string;
+        /**
+         * Build a deterministic file name for a full prerender html artifact
+         */
+        function getFullHtmlFileName(html: string): string;
         /**
          * 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';
-import { Logger } from '../utils/logger';
-import { Time } from '../utils/time';
-import { toPathPattern } from './router/utils';
+import { Solas } from '../solas.js';
+import { Logger } from '../utils/logger.js';
+import { Time } from '../utils/time.js';
+import { toPathPattern } from './router/utils.js';
 const logger = new Logger();
 export { Prerender };
 var Prerender;
@@ -13,6 +13,15 @@ var Prerender;
     let Artifact;
     (function (Artifact) {
         const manifestCache = new Map();
+        /**
+         * Check whether a file name is safe to join under an artifact directory
+         */
+        function isArtifactFileName(value) {
+            return (typeof value === 'string' &&
+                value.length > 0 &&
+                path.basename(value) === value &&
+                !value.includes(path.sep));
+        }
         /**
          * Get the root directory path where prerender artifacts are stored,
          * based on the output directory specified in the configuration
@@ -43,6 +52,23 @@ var Prerender;
             return artifactPath;
         }
         Artifact.getPath = getPath;
+        /**
+         * Get the file system path for a single prerender artifact file under a route directory
+         */
+        function getFilePath(outDir, pathname, fileName) {
+            if (!isArtifactFileName(fileName)) {
+                throw new Error('[prerender] invalid artifact file name');
+            }
+            return path.join(getPath(outDir, pathname), fileName);
+        }
+        Artifact.getFilePath = getFilePath;
+        /**
+         * Build a deterministic file name for a full prerender html artifact
+         */
+        function getFullHtmlFileName(html) {
+            return `html.${Bun.hash(html).toString(16)}.html`;
+        }
+        Artifact.getFullHtmlFileName = getFullHtmlFileName;
         /**
          * Load the prerender artifact manifest for faster runtime route mode checks
          */
@@ -107,6 +133,11 @@ var Prerender;
                             }
                         }
                     }
+                    if (entry.fullPrerenderFilename !== undefined &&
+                        !isArtifactFileName(entry.fullPrerenderFilename)) {
+                        manifestCache.set(outDir, null);
+                        return null;
+                    }
                 }
                 const manifest = { generatedAt, routes };
                 // cache validated manifest to avoid reparsing on every request
@@ -193,7 +224,12 @@ var Prerender;
                     return null;
                 if (mode !== 'full' && mode !== 'ppr')
                     return null;
-                return { schema, route, createdAt, mode };
+                return {
+                    schema,
+                    route,
+                    createdAt,
+                    mode,
+                };
             }
             catch {
                 return null;
@@ -219,14 +255,22 @@ var Prerender;
          * into the prelude at the appropriate location (before </body> or </html>)
          */
         function composePreludeAndResume(prelude, resumeStream) {
+            // `prelude` is the static shell html as one complete string, usually shaped like
+            // `<html>...<body>static shell...</body></html>` or an html fragment with no close tags
             // search both cases to avoid duplicating the full string with toLowerCase
             const bodyClose = Math.max(prelude.lastIndexOf('</body>'), prelude.lastIndexOf('</BODY>'));
             const htmlClose = Math.max(prelude.lastIndexOf('</html>'), prelude.lastIndexOf('</HTML>'));
+            // prefer inserting before </body>, then before </html>, and fall back
+            // to appending when the prelude is only a fragment with no close tags
             const splitAt = bodyClose >= 0 ? bodyClose : htmlClose >= 0 ? htmlClose : prelude.length;
             return new ReadableStream({
                 async start(controller) {
                     // send everything before the closing tags so the resume stream can be injected
                     controller.enqueue(encoder.encode(prelude.slice(0, splitAt)));
+                    // resumeStream is the html React emits when it resumes postponed work for this page. Its
+                    // first chunk begins with an extra `</body></html>` pair, then continues with the
+                    // resumed scripts and markup for the unfinished work. Strip that leading
+                    // pair once, then pass the rest through unchanged
                     const reader = resumeStream.getReader();
                     let strippedLeadingClose = false;
                     try {
@@ -239,11 +283,17 @@ var Prerender;
                             if (!strippedLeadingClose) {
                                 strippedLeadingClose = true;
                                 const text = decoder.decode(value);
+                                // we already wrote the prelude up to the insertion point before its closing tags.
+                                // React's first resumed chunk starts with an extra `</body></html>` pair,
+                                // so strip that prefix and keep the rest of the chunk
                                 const trimmed = text.replace(/^\s*<\/body>\s*<\/html>/i, '');
                                 if (trimmed.length > 0)
                                     controller.enqueue(encoder.encode(trimmed));
                                 continue;
                             }
+                            // once the duplicated `</body></html>` prefix is removed, stop trying to
+                            // interpret the stream and forward each remaining chunk exactly as React
+                            // emitted it
                             controller.enqueue(value);
                         }
                     }

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

@@ -1,4 +1,7 @@
-import { type Metadata as Collection } from '../metadata';
+import { type Metadata as Collection } from '../metadata.js';
+/**
+ * Renders title, meta, and link tags based on the provided metadata payload
+ */
 export declare function Head({ metadata: m }: {
     metadata?: Collection.Item | Promise<Collection.Item>;
 }): import("react/jsx-runtime").JSX.Element | null;

package/dist/internal/render/head.js

@@ -1,38 +1,57 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { use } from 'react';
-import { Solas } from '../../solas';
-import { Logger } from '../../utils/logger';
+import { Solas } from '../../solas.js';
+import { Logger } from '../../utils/logger.js';
 const logger = new Logger();
 const cache = new WeakMap();
+/**
+ * Convert supported metadata primitives to string for meta tag content
+ */
+function toContent(value) {
+    return typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean'
+        ? String(value)
+        : undefined;
+}
+/**
+ * Convert a metadata item or promise of an item to a promise that always resolves
+ * successfully, caching the result for future use
+ */
+function toSafeUsable(metadata) {
+    const cached = cache.get(metadata);
+    if (cached)
+        return cached;
+    const safe = Promise.resolve(metadata).catch(err => {
+        logger.error('[head] failed to resolve metadata', err);
+        return {};
+    });
+    cache.set(metadata, safe);
+    return safe;
+}
+/**
+ * Renders title, meta, and link tags based on the provided metadata payload
+ */
 export function Head({ metadata: m, }) {
     if (!m)
         return null;
     const metadata = use(toSafeUsable(m));
     return (_jsxs(_Fragment, { children: [
-            _jsx("meta", { name: "generator", content: Solas.Config.NAME }), metadata.title && _jsx("title", { children: metadata.title.toString() }), metadata.meta?.map(meta => {
+            _jsx("meta", { name: "generator", content: Solas.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);
                 }
                 if ('name' in meta) {
-                    return (_jsx("meta", { name: meta.name, content: meta.content?.toString() }, meta.name));
+                    return (_jsx("meta", { name: meta.name, content: toContent(meta.content) }, meta.name));
                 }
                 if ('httpEquiv' in meta) {
-                    return (_jsx("meta", { httpEquiv: meta.httpEquiv, content: meta.content?.toString() }, meta.httpEquiv));
+                    return (_jsx("meta", { httpEquiv: meta.httpEquiv, content: toContent(meta.content) }, meta.httpEquiv));
                 }
                 if ('property' in meta) {
-                    return (_jsx("meta", { property: meta.property, content: meta.content?.toString() }, meta.property));
+                    return (_jsx("meta", { property: meta.property, content: toContent(meta.content) }, meta.property));
                 }
                 return null;
-            }), metadata.link?.map(link => (_jsx("link", { ...link }, `${link.rel}${link.href ?? ''}`)))] }));
-}
-function toSafeUsable(metadata) {
-    const cached = cache.get(metadata);
-    if (cached)
-        return cached;
-    const safe = Promise.resolve(metadata).catch(err => {
-        logger.error('[head] failed to resolve metadata', err);
-        return {};
-    });
-    cache.set(metadata, safe);
-    return safe;
+            }), metadata.link?.map(link => (_jsx("link", { rel: link.rel, href: typeof link.href === 'string' ? link.href : undefined, as: typeof link.as === 'string' ? link.as : undefined, type: typeof link.type === 'string' ? link.type : undefined, media: typeof link.media === 'string' ? link.media : undefined, sizes: typeof link.sizes === 'string' ? link.sizes : undefined, crossOrigin: link.crossOrigin === 'anonymous' || link.crossOrigin === 'use-credentials'
+                    ? link.crossOrigin
+                    : undefined }, `${link.rel}${link.href ?? ''}`)))] }));
 }

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

@@ -1,4 +1,4 @@
-import type { Resolver } from '../router/resolver';
+import type { Resolver } from '../router/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,8 @@
 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';
-import { HttpExceptionBoundary } from '../navigation/http-exception-boundary';
-import DefaultErr from '../ui/defaults/error';
+import { HttpException, isHttpException } from '../navigation/http-exception.js';
+import { HttpExceptionBoundary } from '../navigation/http-exception-boundary.js';
+import DefaultErr from '../ui/defaults/error.js';
 /**
  * Render the resolved route tree for a matched page
  *

package/dist/internal/router/create-router.d.ts

@@ -1,5 +1,5 @@
-import type { ImportMap, Manifest, PluginConfig, SolasRequest } from '../../types';
-import { Router } from './router';
+import type { ImportMap, Manifest, PluginConfig, SolasRequest } from '../../types.js';
+import { Router } from './router.js';
 /**
  * Create the application router from the generated manifest and import map
  */

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

@@ -1,4 +1,4 @@
-import { Router } from './router';
+import { Router } from './router.js';
 function callEndpoint(fn, req) {
     // endpoint modules may export either a zero-arg handler or one that expects the request
     if (fn.length === 0)

package/dist/internal/router/prefetcher.d.ts

@@ -16,7 +16,7 @@ export declare class Prefetcher {
      * Converts a url path to a cache key by normalising it
      * against a base url
      */
-    static key(path: string, base: string): string;
+    static key(path: string, base: string): string | null;
     /**
      * Evicts the oldest entry from the cache
      */

package/dist/internal/router/prefetcher.js

@@ -11,9 +11,14 @@ export class Prefetcher {
      * against a base url
      */
     static key(path, base) {
-        const url = new URL(path, base);
-        // hash is client-only and never sent to the server, so exclude it
-        return url.pathname + url.search;
+        try {
+            const url = new URL(path, base);
+            // hash is client-only and never sent to the server, so exclude it
+            return url.pathname + url.search;
+        }
+        catch {
+            return null;
+        }
     }
     /**
      * Evicts the oldest entry from the cache

package/dist/internal/router/resolver.d.ts

@@ -1,7 +1,7 @@
-import type { ImportMap, Manifest, ManifestEntry, Primitive, View } from '../../types';
-import type { Router } from './router';
-import { Metadata } from '../metadata';
-import { HttpException } from '../navigation/http-exception';
+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';
 export declare namespace Resolver {
     type ReconciledMatch = ReturnType<Resolver['reconcile']>;
     type CachedEnhancedMatch = Omit<EnhancedMatch, 'params' | 'error'>;
@@ -55,7 +55,7 @@ export declare class Resolver {
     /**
      * Narrow down a route entry to a page entry if it exists
      */
-    static narrow(entry?: ManifestEntry | ManifestEntry[]): import("../..").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
      */
@@ -64,8 +64,6 @@ export declare class Resolver {
      * Reconcile a router match against a manifest entry
      */
     reconcile(path: string, match: Router.Match | null, error?: Error): {
-        params: Router.Params;
-        error: Error | undefined;
         __id: string;
         __path: string;
         __params: string[];
@@ -85,9 +83,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[];
@@ -107,11 +105,32 @@ 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;
@@ -147,28 +166,9 @@ export declare class Resolver {
         metadata?: ((input: Metadata.Input<Router.Params, Error>) => Metadata.Task[]) | undefined;
         params: Router.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("../..").Segment | null;
+    closest(path: string, property: string, value?: Omit<Primitive, 'undefined'>): import("../../types.js").Segment | null;
 }

package/dist/internal/router/resolver.js

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

package/dist/internal/router/router-context.d.ts

@@ -8,4 +8,8 @@ export declare const RouterContext: import("react").Context<{
     go: (to: string, opts?: Navigation.GoOptions | undefined) => Promise<string>;
     prefetch: (path: string) => void;
     isNavigating: boolean;
+    url: {
+        pathname?: string | undefined;
+        search?: string | undefined;
+    };
 }>;

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

@@ -4,4 +4,5 @@ export const RouterContext = createContext({
     go: async () => '',
     prefetch: () => { },
     isNavigating: false,
+    url: {},
 });

package/dist/internal/router/router-provider.d.ts

@@ -1,6 +1,10 @@
-import type { RSCPayload } from '../env/rsc';
-export declare function RouterProvider({ children, setPayload, isNavigating }: {
+import type { RSCPayload } from '../env/rsc.js';
+export declare function RouterProvider({ children, setPayload, isNavigating, url }: {
     children: React.ReactNode;
     setPayload?: (payload: RSCPayload) => void;
     isNavigating?: boolean;
+    url?: {
+        pathname?: string;
+        search?: string;
+    };
 }): import("react/jsx-runtime").JSX.Element;

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

@@ -2,16 +2,16 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useCallback, useEffect, useMemo, useRef } from 'react';
 import { createFromFetch } from '@vitejs/plugin-rsc/browser';
-import { Solas } from '../../solas';
-import { Logger } from '../../utils/logger';
-import { Prefetcher } from './prefetcher';
-import { RouterContext } from './router-context';
+import { Logger } from '../../utils/logger.js';
+import { Solas } from '../../solas.js';
+import { Prefetcher } from './prefetcher.js';
+import { RouterContext } from './router-context.js';
 const DEFAULT_GO_CONFIG = {
     replace: false,
 };
 const logger = new Logger();
 const prefetcher = new Prefetcher();
-export function RouterProvider({ children, setPayload, isNavigating = false, }) {
+export function RouterProvider({ children, setPayload, isNavigating = false, url, }) {
     // id to track active navigations
     const id = useRef(0);
     // abort controller for in-flight navigation
@@ -23,23 +23,34 @@ export function RouterProvider({ children, setPayload, isNavigating = false, })
      * @returns the path that was navigated to (relative to origin)
      */
     const go = useCallback(async (to, opts = {}) => {
+        // increment navigation id to invalidate any in-flight navigations
         id.current += 1;
         const navigationId = id.current;
+        // fallback for abort/error paths
+        let path = window.location.pathname + window.location.search;
+        const replace = opts?.replace ?? DEFAULT_GO_CONFIG.replace;
         controller.current?.abort();
         controller.current = null;
-        const url = new URL(to, window.location.origin);
-        const replace = opts?.replace ?? DEFAULT_GO_CONFIG.replace;
-        if (opts?.query) {
-            for (const [key, value] of Object.entries(opts.query)) {
-                url.searchParams.set(key, String(value));
-            }
-        }
-        const path = Prefetcher.key(url.toString(), window.location.origin);
         // distinguish an actual prior prefetch from a cache entry we create
         // opportunistically for this navigation
-        const existing = prefetcher.has(path);
+        let existing = false;
         try {
+            const url = new URL(to, window.location.origin);
+            if (opts?.query) {
+                for (const [key, value] of Object.entries(opts.query)) {
+                    url.searchParams.set(key, String(value));
+                }
+            }
+            const key = Prefetcher.key(url.toString(), window.location.origin);
+            if (!key)
+                throw new Error('Invalid navigation url');
+            // switch to the normalized target once the url is valid
+            path = key;
+            // if the target was already prefetched, use the cached response promise
+            // and set existing to true so we don't remove it from cache
+            // after navigation
             let promise = prefetcher.get(path);
+            existing = promise !== undefined;
             if (!promise) {
                 const ctrl = new AbortController();
                 controller.current = ctrl;
@@ -47,9 +58,8 @@ export function RouterProvider({ children, setPayload, isNavigating = false, })
                     headers: { accept: 'text/x-component' },
                     signal: ctrl.signal,
                 });
-            }
-            if (!prefetcher.has(path))
                 prefetcher.set(path, promise);
+            }
             // if another navigation has started since this one, ignore the result
             // and return early
             if (navigationId !== id.current)
@@ -61,7 +71,7 @@ export function RouterProvider({ children, setPayload, isNavigating = false, })
                 createFromFetch(promise),
             ]);
             // use the final response url so client history matches server redirects
-            const resolvedPath = Prefetcher.key(res.url, window.location.origin);
+            const resolvedPath = Prefetcher.key(res.url, window.location.origin) ?? path;
             // check again if another navigation has started while we were awaiting
             // the response
             if (navigationId !== id.current)
@@ -95,11 +105,11 @@ export function RouterProvider({ children, setPayload, isNavigating = false, })
         finally {
             if (navigationId === id.current)
                 controller.current = null;
-            // preserve entries that were already prefetched so nearby follow-up
-            // navigations can still reuse them within the prefetch TTL window
+            // keep entries that were already in the prefetch cache before go() ran. Only remove
+            // the temporary cache entry go() created for its own in-flight dedupe
             if (!existing) {
-                // entries created by go() only serve as in-flight dedupe for this
-                // navigation (i.e. not intentionally prefetched)
+                // this fetch was not an intentional prefetch, so do not leave it behind
+                // as a reusable cache entry after navigation finishes
                 prefetcher.remove(path);
             }
         }
@@ -111,6 +121,8 @@ export function RouterProvider({ children, setPayload, isNavigating = false, })
      */
     const prefetch = useCallback((path) => {
         const key = Prefetcher.key(path, window.location.origin);
+        if (!key)
+            return;
         if (prefetcher.has(key))
             return;
         prefetcher.set(key, fetch(key, { headers: { Accept: 'text/x-component' } }));
@@ -128,6 +140,10 @@ export function RouterProvider({ children, setPayload, isNavigating = false, })
         go,
         prefetch,
         isNavigating,
-    }), [go, prefetch, isNavigating]);
+        url: {
+            pathname: url?.pathname,
+            search: url?.search,
+        },
+    }), [go, prefetch, isNavigating, url]);
     return _jsx(RouterContext, { value: value, children: children });
 }

package/dist/internal/router/router.d.ts

@@ -1,4 +1,4 @@
-import type { HttpMethod, PluginConfig, SolasRequest } from '../../types';
+import type { HttpMethod, PluginConfig, SolasRequest } from '../../types.js';
 export declare namespace Router {
     type Params = Record<string, string | string[]>;
     type Handler = (req: SolasRequest) => Response | Promise<Response>;

package/dist/internal/router/router.js

@@ -1,9 +1,9 @@
 import path from 'node:path';
 import { match as createMatch } from 'path-to-regexp';
-import { Solas } from '../../solas';
-import { getAlternatePathname, normalisePathname, toPathPattern } from './utils';
-import { maybeAction } from '../env/rsc';
-import { HttpException } from '../navigation/http-exception';
+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';
 /**
  * Handle routing and matching for server requests
  */

package/dist/internal/router/use-router.d.ts

@@ -1,5 +1,9 @@
 export declare function useRouter(): {
-    go: (to: string, opts?: import("./router-context").Navigation.GoOptions | undefined) => Promise<string>;
+    go: (to: string, opts?: import("./router-context.js").Navigation.GoOptions | undefined) => Promise<string>;
     prefetch: (path: string) => void;
     isNavigating: boolean;
+    url: {
+        pathname?: string | undefined;
+        search?: string | undefined;
+    };
 };

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

@@ -1,5 +1,5 @@
 import { use } from 'react';
-import { RouterContext } from './router-context';
+import { RouterContext } from './router-context.js';
 export function useRouter() {
     return use(RouterContext);
 }

package/dist/internal/router/utils.d.ts

@@ -1,4 +1,4 @@
-import type { Route } from '../../types';
+import type { Route } from '../../types.js';
 export type PathPattern = {
     path: string;
     wildcardNames: Set<string>;