@jk2908/solas 0.2.2 → 0.3.0

package/dist/internal/codegen/utils.js

@@ -1,2 +1,141 @@
-import { Solas } from '../../solas';
+import { Solas } from '../../solas.js';
 export const AUTOGEN_MSG = `// auto-generated by ${Solas.Config.NAME}`;
+const INDENT = '\t';
+const IDENTIFIER = /^[$A-Z_a-z][$\w]*$/;
+/**
+ * Check whether a string contains control characters that should never appear in source
+ */
+function hasControlChar(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if ((code >= 0 && code <= 31) || code === 127) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Validate an identifier before writing it into generated source unquoted
+ */
+export function toIdentifier(value, label) {
+    if (!IDENTIFIER.test(value)) {
+        throw new Error(`Invalid ${label}: ${value}`);
+    }
+    return value;
+}
+/**
+ * Validate and quote a relative specifier before embedding it in generated imports
+ */
+export function toRelativeModuleSpecifier(value, label) {
+    if (value.length === 0) {
+        throw new Error(`Invalid ${label}: module specifier cannot be empty`);
+    }
+    if (value.includes('\\')) {
+        throw new Error(`Invalid ${label}: module specifier must use forward slashes`);
+    }
+    if (hasControlChar(value)) {
+        throw new Error(`Invalid ${label}: module specifier contains control characters`);
+    }
+    if (!value.startsWith('./') && !value.startsWith('../')) {
+        throw new Error(`Invalid ${label}: module specifier must be relative`);
+    }
+    return toStringLiteral(value);
+}
+/**
+ * Validate a nullable identifier list whilst preserving explicit null holes
+ */
+export function toIdentifierList(values, label) {
+    return values
+        .map((value, index) => value === null ? 'null' : toIdentifier(value, `${label}[${index}] identifier`))
+        .join(', ');
+}
+/**
+ * Escape text into a safe string literal for generated source
+ */
+export function toStringLiteral(value, quoteStyle = "'") {
+    return `${quoteStyle}${value
+        .replace(/\\/g, '\\\\')
+        .replace(new RegExp(quoteStyle, 'g'), `\\${quoteStyle}`)
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/\t/g, '\\t')}${quoteStyle}`;
+}
+/**
+ * Convert a string into a valid unquoted property key if possible, otherwise quote it
+ * as a string literal for generated source
+ */
+function toPropertyKey(value) {
+    return IDENTIFIER.test(value) ? value : toStringLiteral(value);
+}
+/**
+ * Check whether a value is a simple literal that can be safely inlined in generated
+ * source without risking syntax errors or readability issues, or whether it should
+ * be printed on multiple lines for clarity
+ */
+function isInlineValue(value) {
+    return (value === null ||
+        typeof value === 'boolean' ||
+        typeof value === 'number' ||
+        typeof value === 'string');
+}
+/**
+ * Emit readable ts source for generated config and manifest data
+ */
+export function toSourceLiteral(value, level = 0) {
+    if (value === null)
+        return 'null';
+    if (typeof value === 'string')
+        return toStringLiteral(value);
+    if (typeof value === 'boolean' || typeof value === 'number') {
+        return String(value);
+    }
+    if (typeof value === 'function')
+        return value.toString();
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return '[]';
+        const items = value.map(item => toSourceLiteral(item, level + 1));
+        const inline = value.every(isInlineValue) && items.join(', ').length <= 60;
+        if (inline)
+            return `[${items.join(', ')}]`;
+        return [
+            '[',
+            items.map(item => indent(item, level + 1)).join(',\n'),
+            `${INDENT.repeat(level)}]`,
+        ].join('\n');
+    }
+    if (typeof value === 'object') {
+        const entries = Object.entries(value);
+        if (entries.length === 0)
+            return '{}';
+        return [
+            '{',
+            entries
+                .map(([key, entryValue]) => {
+                const prefix = `${INDENT.repeat(level + 1)}${toPropertyKey(key)}: `;
+                if (typeof entryValue === 'function') {
+                    const source = entryValue.toString();
+                    if (source.startsWith(`${key}(`) || source.startsWith(`async ${key}(`)) {
+                        return indent(source, level + 1);
+                    }
+                    return `${prefix}${source.replace(/\n/g, `\n${INDENT.repeat(level + 1)}`)}`;
+                }
+                return `${prefix}${toSourceLiteral(entryValue, level + 1).replace(/\n/g, `\n${INDENT.repeat(level + 1)}`)}`;
+            })
+                .join(',\n'),
+            `${INDENT.repeat(level)}}`,
+        ].join('\n');
+    }
+    throw new Error(`Unsupported generated value type: ${typeof value}`);
+}
+/**
+ * Indent each line of a block of source code by the specified level for embedding in
+ * generated output
+ */
+function indent(value, level = 1) {
+    const prefix = INDENT.repeat(level);
+    return value
+        .split('\n')
+        .map(line => (line.length > 0 ? `${prefix}${line}` : line))
+        .join('\n');
+}

package/dist/internal/env/browser.js

@@ -1,12 +1,12 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { StrictMode, Suspense, useCallback, useEffect, useState, useTransition, } from 'react';
+import { StrictMode, Suspense, useCallback, useState, useTransition } from 'react';
 import { hydrateRoot } from 'react-dom/client';
 import { createFromFetch, createFromReadableStream, createTemporaryReferenceSet, encodeReply, setServerCallback, } from '@vitejs/plugin-rsc/browser';
 import { rscStream } from 'rsc-html-stream/client';
-import { RedirectBoundary } from '../navigation/redirect-boundary';
-import { Head } from '../render/head';
-import { RouterProvider } from '../router/router-provider';
-import { ErrorBoundary } from '../ui/error-boundary';
+import { RedirectBoundary } from '../navigation/redirect-boundary.js';
+import { Head } from '../render/head.js';
+import { RouterProvider } from '../router/router-provider.js';
+import { ErrorBoundary } from '../ui/error-boundary.js';
 /**
  * Browser RSC hydration entry point
  */
@@ -14,7 +14,9 @@ export async function browser() {
     const payload = await createFromReadableStream(rscStream, {
         unstable_allowPartialStream: true,
     });
-    let setPayload = () => { };
+    const payloadSetter = {
+        current: () => { },
+    };
     function A() {
         const [p, setP] = useState(payload);
         const [isPending, startTransition] = useTransition();
@@ -23,13 +25,10 @@ export async function browser() {
                 setP(payload);
             });
         }, []);
-        useEffect(() => {
-            // expose external setPayload - used inside
-            // server callback to update payload after
-            // action execution
-            setPayload = setPayloadInTransition;
-        }, [setPayloadInTransition]);
-        return (_jsx(RedirectBoundary, { children: _jsxs(RouterProvider, { setPayload: setPayloadInTransition, isNavigating: isPending, children: [
+        // make the latest payload updater available to action/hmr callbacks
+        // immediately during render, without waiting for an effect to run
+        payloadSetter.current = setPayloadInTransition;
+        return (_jsx(RedirectBoundary, { children: _jsxs(RouterProvider, { setPayload: setPayloadInTransition, isNavigating: isPending, url: p.url, children: [
                     _jsx(ErrorBoundary, { fallback: null, children: _jsx(Suspense, { fallback: null, children: _jsx(Head, { metadata: p.metadata }) }) }), p.root] }) }));
     }
     setServerCallback(async (id, args) => {
@@ -42,7 +41,7 @@ export async function browser() {
                 'x-rsc-action-id': id,
             },
         }), { temporaryReferences });
-        setPayload(payload);
+        payloadSetter.current(payload);
         const { ok, data } = payload.returnValue ?? {};
         if (!ok)
             throw data;
@@ -52,7 +51,12 @@ export async function browser() {
         formState: payload.formState,
     });
     import.meta.hot?.on?.('rsc:update', async () => {
-        const p = await createFromFetch(fetch(window.location.href, { headers: { Accept: 'text/x-component' } }));
-        setPayload(p);
+        try {
+            const p = await createFromFetch(fetch(window.location.href, { headers: { Accept: 'text/x-component' } }));
+            payloadSetter.current(p);
+        }
+        catch (err) {
+            console.error('[hmr] failed to refresh rsc payload', err);
+        }
     });
 }

package/dist/internal/env/request-context.d.ts

@@ -1,5 +1,5 @@
-import type { SolasRequest } from '../../types';
-import type { Cookies } from '../../utils/cookies';
+import type { SolasRequest } from '../../types.js';
+import type { Cookies } from '../../utils/cookies.js';
 export type RequestCache = {
     cookies?: Readonly<ReturnType<typeof Cookies.parse>>;
     headers?: ReadonlyMap<string, string>;

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

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

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

@@ -1,6 +1,7 @@
 import type { ReactFormState } from 'react-dom/client';
-import type { ImportMap, Manifest, RuntimeConfig, SolasRequest } from '../../types';
-import { Metadata } from '../metadata';
+import type { ImportMap, Manifest, RuntimeConfig } from '../../types.js';
+import { Metadata } from '../metadata.js';
+import { Prerender } from '../prerender.js';
 export type RSCPayload = {
     returnValue?: {
         ok: boolean;
@@ -9,31 +10,16 @@ export type RSCPayload = {
     formState?: ReactFormState;
     root: React.ReactNode;
     metadata?: Promise<Metadata.Item>;
+    url?: {
+        pathname?: string;
+        search?: string;
+    };
 };
-export declare function action(req: SolasRequest): Promise<{
-    returnValue: {
-        ok: boolean;
-        data: unknown;
-    } | undefined;
-    formState: ReactFormState | undefined;
-    temporaryReferences: unknown;
-}>;
-/**
- * Check if a request is an action request and reuse parsed FormData
- * when multipart action detection already had to inspect the body
- */
-export declare function maybeAction(req: Request): Promise<{
-    action: boolean;
-    formData: null;
-} | {
-    action: boolean;
-    formData: FormData;
-}>;
 /**
  * Create the object exported by the generated RSC entry. Uses the generated config,
  * 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): {
+export declare function createHandler(config: RuntimeConfig, manifest: Manifest, importMap: ImportMap, artifactManifest?: Prerender.Artifact.Manifest | null): {
     fetch(req: Request): Promise<Response>;
 };

package/dist/internal/env/rsc.js

@@ -1,19 +1,19 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import path from 'node:path';
-import { createTemporaryReferenceSet, decodeAction, decodeFormState, decodeReply, loadServerAction, renderToReadableStream, } from '@vitejs/plugin-rsc/rsc';
-import { Solas } from '../../solas';
-import { Logger } from '../../utils/logger';
-import { normalisePathname } from '../router/utils';
-import { getKnownDigest, isKnownError } from './utils';
-import { Metadata } from '../metadata';
-import { HttpException, isHttpException } from '../navigation/http-exception';
-import { Prerender } from '../prerender';
-import { Tree } from '../render/tree';
-import { createRouter } from '../router/create-router';
-import { Resolver } from '../router/resolver';
-import { Router } from '../router/router';
-import DefaultErr from '../ui/defaults/error';
-import { RequestContext } from './request-context';
+import { renderToReadableStream } from '@vitejs/plugin-rsc/rsc';
+import { Logger } from '../../utils/logger.js';
+import { Solas } from '../../solas.js';
+import { Metadata } from '../metadata.js';
+import { HttpException, isHttpException } from '../navigation/http-exception.js';
+import { Prerender } from '../prerender.js';
+import { Tree } from '../render/tree.js';
+import { createRouter } from '../router/create-router.js';
+import { Resolver } from '../router/resolver.js';
+import { Router } from '../router/router.js';
+import { normalisePathname } from '../router/utils.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';
 /**
  * Get the streamed RSC payload and response metadata for a single request.
  * Resolves the route match, collects metadata, and returns the stream,
@@ -42,6 +42,10 @@ async function getPayload(req, manifest, importMap, baseMetadata, returnValue, f
                 ] })),
             returnValue,
             formState,
+            url: {
+                pathname: url.pathname,
+                search: url.search,
+            },
         };
         return {
             // this path is a safety fallback when a prerender request
@@ -81,6 +85,10 @@ async function getPayload(req, manifest, importMap, baseMetadata, returnValue, f
         returnValue,
         formState,
         metadata,
+        url: {
+            pathname: url.pathname,
+            search: url.search,
+        },
     };
     // status code comes from route match error if any
     const status = isHttpException(match.error) ? match.error.status : 200;
@@ -136,6 +144,10 @@ async function getPayload(req, manifest, importMap, baseMetadata, returnValue, f
                     ] })),
                 returnValue,
                 formState,
+                url: {
+                    pathname: url.pathname,
+                    search: url.search,
+                },
             }, {
                 temporaryReferences,
             })),
@@ -144,83 +156,13 @@ async function getPayload(req, manifest, importMap, baseMetadata, returnValue, f
         };
     }
 }
-export async function action(req) {
-    let returnValue;
-    let formState;
-    let temporaryReferences;
-    const id = req.headers.get('x-rsc-action-id');
-    if (id) {
-        // x-rsc-action-id header exists when action is
-        // called via ReactClient.setServerCallback
-        const body = req.headers.get('content-type')?.startsWith('multipart/form-data')
-            ? await req.formData()
-            : await req.text();
-        temporaryReferences = createTemporaryReferenceSet();
-        const args = await decodeReply(body, {
-            temporaryReferences,
-        });
-        const action = await loadServerAction(id);
-        try {
-            const data = await action.apply(null, args);
-            returnValue = { ok: true, data };
-        }
-        catch (err) {
-            returnValue = { ok: false, data: err };
-        }
-    }
-    else {
-        // otherwise server function is called via
-        // <form action={...}>
-        // 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 formData = parsedFormData ?? (await req.formData());
-        const decodedAction = await decodeAction(formData);
-        const result = await decodedAction();
-        formState = await decodeFormState(result, formData);
-    }
-    return { returnValue, formState, temporaryReferences };
-}
-/**
- * Check if a request is an action request and reuse parsed FormData
- * when multipart action detection already had to inspect the body
- */
-export async function maybeAction(req) {
-    if (req.method !== 'POST')
-        return { action: false, formData: null };
-    if (req.headers.has('x-rsc-action-id'))
-        return { action: true, formData: null };
-    const contentType = req.headers.get('content-type') ?? '';
-    if (!contentType.startsWith('multipart/form-data')) {
-        return { action: false, formData: null };
-    }
-    try {
-        const formData = await req.clone().formData();
-        for (const key of formData.keys()) {
-            if (key === '$ACTION_KEY' ||
-                key.startsWith('$ACTION_') ||
-                key.startsWith('$ACTION_REF_')) {
-                return { action: true, formData };
-            }
-        }
-    }
-    catch {
-        return { action: false, formData: null };
-    }
-    return { action: false, formData: null };
-}
 /**
  * Create the object exported by the generated RSC entry. Uses the generated config,
  * route manifest, and import map to build the router once, then returns an object
  * with a fetch method that handles requests
  */
-export function createHandler(config, manifest, importMap) {
+export function createHandler(config, manifest, importMap, artifactManifest = null) {
     const prerenderPathMode = config.trailingSlash === 'always' ? 'always' : 'never';
-    const fullyPrerenderedRoutes = new Set(Object.values(manifest)
-        .flat()
-        .filter(entry => 'prerender' in entry && String(entry.prerender) === 'full')
-        .map(entry => normalisePathname(entry.__path, prerenderPathMode)));
     /**
      * Create the HTTP response for a single incoming request. Runs actions when needed,
      * converts the payload into component, HTML, or prerender artifact responses, and
@@ -233,7 +175,7 @@ export function createHandler(config, manifest, importMap) {
             returnValue: undefined,
         };
         if (req[Solas.Config.REQUEST_META].action)
-            opts = await action(req);
+            opts = await processActionRequest(req);
         const { stream: rscStream, status, ppr, } = await getPayload(req, manifest, importMap, config.metadata, opts.returnValue, opts.formState, opts.temporaryReferences);
         const stream = await rscStream;
         if (!req.headers.get('accept')?.includes('text/html')) {
@@ -268,10 +210,9 @@ export function createHandler(config, manifest, importMap) {
                 status,
             });
         }
-        const artifactManifest = runtimePpr
-            ? await Prerender.Artifact.loadManifest(Solas.Config.OUT_DIR)
+        const artifactManifestEntry = runtimePpr
+            ? (artifactManifest?.routes[lookupPath] ?? null)
             : null;
-        const artifactManifestEntry = artifactManifest?.routes[lookupPath] ?? null;
         let tryPrelude = false;
         if (artifactManifestEntry) {
             tryPrelude = artifactManifestEntry.mode === 'ppr';
@@ -334,36 +275,16 @@ export function createHandler(config, manifest, importMap) {
                 return Response.redirect(url.toString(), 308);
             }
             // fully prerendered html can be served straight from disk for normal
-            // document requests, but artifact generation must still hit the runtime path
+            // document requests, but build-time artifact requests must bypass
+            // this shortcut so they still render fresh output
             if (!import.meta.env.DEV &&
                 accept.includes('text/html') &&
                 req.headers.get(`x-${Solas.Config.SLUG}-prerender-artifact`) !== '1') {
-                const pathname = canonicalPath;
-                const lookupPath = normalisePathname(pathname, prerenderPathMode);
-                const routePath = lookupPath.replace(/^\//, '').replace(/\/$/, '');
-                let prerenderPath = null;
-                const artifactManifest = await Prerender.Artifact.loadManifest(Solas.Config.OUT_DIR);
-                const artifactManifestEntry = artifactManifest?.routes[lookupPath] ?? null;
-                const fullHtmlPath = lookupPath === '/'
-                    ? path.join(Solas.Config.OUT_DIR, 'index.html')
-                    : config.trailingSlash === 'always'
-                        ? path.join(Solas.Config.OUT_DIR, routePath, 'index.html')
-                        : path.join(Solas.Config.OUT_DIR, `${routePath}.html`);
-                if (fullyPrerenderedRoutes.has(lookupPath)) {
-                    prerenderPath = fullHtmlPath;
-                }
-                else if (artifactManifestEntry) {
-                    if (artifactManifestEntry.mode === 'full') {
-                        prerenderPath = fullHtmlPath;
-                    }
-                }
-                else {
-                    const artifactMetadata = await Prerender.Artifact.loadMetadata(Solas.Config.OUT_DIR, lookupPath);
-                    if (artifactMetadata &&
-                        Prerender.Artifact.isCompatible(artifactMetadata, lookupPath, 'full')) {
-                        prerenderPath = fullHtmlPath;
-                    }
-                }
+                const lookupPath = normalisePathname(canonicalPath, prerenderPathMode);
+                const fullPrerenderFilename = artifactManifest?.routes[lookupPath]?.fullPrerenderFilename;
+                const prerenderPath = fullPrerenderFilename
+                    ? Prerender.Artifact.getFilePath(Solas.Config.OUT_DIR, lookupPath, fullPrerenderFilename)
+                    : null;
                 if (prerenderPath) {
                     const res = await Router.serve(prerenderPath, req, config.precompress, {
                         // avoid shared or proxy caching unless users opt into public caching later

package/dist/internal/env/ssr.js

@@ -4,18 +4,18 @@ 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 { injectRSCPayload } from 'rsc-html-stream/server';
-import { Solas } from '../../solas';
-import { Logger } from '../../utils/logger';
-import { getKnownDigest } from './utils';
-import { RedirectBoundary } from '../navigation/redirect-boundary';
-import { Prerender } from '../prerender';
-import { Head } from '../render/head';
-import { RouterProvider } from '../router/router-provider';
-import { ErrorBoundary } from '../ui/error-boundary';
+import { Logger } from '../../utils/logger.js';
+import { Solas } from '../../solas.js';
+import { RedirectBoundary } from '../navigation/redirect-boundary.js';
+import { Prerender } from '../prerender.js';
+import { Head } from '../render/head.js';
+import { RouterProvider } from '../router/router-provider.js';
+import { ErrorBoundary } from '../ui/error-boundary.js';
+import { getKnownDigest } from './utils.js';
 const logger = new Logger();
 function A({ payloadPromise }) {
     const payload = use(payloadPromise);
-    return (_jsx(RedirectBoundary, { children: _jsxs(RouterProvider, { children: [
+    return (_jsx(RedirectBoundary, { children: _jsxs(RouterProvider, { url: payload.url, children: [
                 _jsx(ErrorBoundary, { fallback: null, children: _jsx(Suspense, { fallback: null, children: _jsx(Head, { metadata: payload.metadata }) }) }), payload.root] }) }));
 }
 /**

package/dist/internal/env/utils.js

@@ -1,5 +1,5 @@
-import { HTTP_EXCEPTION_DIGEST_PREFIX } from '../navigation/http-exception';
-import { REDIRECT_DIGEST_PREFIX } from '../navigation/redirect';
+import { HTTP_EXCEPTION_DIGEST_PREFIX } from '../navigation/http-exception.js';
+import { REDIRECT_DIGEST_PREFIX } from '../navigation/redirect.js';
 const possibilities = [HTTP_EXCEPTION_DIGEST_PREFIX, REDIRECT_DIGEST_PREFIX];
 export function getKnownDigest(err) {
     if (typeof err === 'object' &&

package/dist/internal/metadata.d.ts

@@ -1,5 +1,5 @@
-import type { HttpException } from './navigation/http-exception';
-import { Build } from './build';
+import type { HttpException } from './navigation/http-exception.js';
+import { 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,5 +1,5 @@
-import { Build } from './build';
-import { isHttpException } from './navigation/http-exception';
+import { Build } from './build.js';
+import { isHttpException } from './navigation/http-exception.js';
 const TITLE_TEMPLATE_STR = '%s';
 export { Metadata };
 var Metadata;
@@ -14,6 +14,18 @@ var Metadata;
         [Build.EntryKind['500']]: 40,
         [Build.EntryKind.LOADING]: 50,
     };
+    /**
+     * Check whether a value is a supported metadata primitive
+     */
+    function isTagValue(value) {
+        return (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean');
+    }
+    /**
+     * Convert supported metadata primitives to string for title handling
+     */
+    function toTitleString(value) {
+        return isTagValue(value) ? String(value) : undefined;
+    }
     class Collection {
         /**
          * The base metadata object
@@ -40,8 +52,8 @@ var Metadata;
             const metaMap = new Map();
             const linkMap = new Map();
             for (const item of items) {
-                if (item.title) {
-                    const titleStr = item.title.toString();
+                const titleStr = toTitleString(item.title);
+                if (titleStr !== undefined) {
                     if (titleStr.includes(TITLE_TEMPLATE_STR)) {
                         titleTemplate = titleStr;
                     }
@@ -119,10 +131,10 @@ var Metadata;
             if (items.length === 0)
                 return Collection.#clone(this.#base);
             let merged = Collection.#clone(this.#base);
-            const res = await Promise.allSettled(items.map(entry => entry.task));
+            const res = await Promise.allSettled(items.map(item => item.task));
             const ok = res
                 .filter((result) => result.status === 'fulfilled')
-                .map(result => result.value);
+                .map((result) => result.value);
             if (ok.length)
                 merged = Collection.#merge(merged, ...ok);
             return merged;

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

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

package/dist/internal/navigation/http-exception-boundary.js

@@ -1,7 +1,7 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Component } from 'react';
-import { HTTP_EXCEPTION_DIGEST_PREFIX, isHttpException, } from './http-exception';
+import { HTTP_EXCEPTION_DIGEST_PREFIX, isHttpException, } from './http-exception.js';
 function isSupportedStatusCode(value) {
     return value === 401 || value === 403 || value === 404 || value === 500;
 }

package/dist/internal/navigation/link.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useRef } from 'react';
-import { useRouter } from '../router/use-router';
+import { useRouter } from '../router/use-router.js';
 function guard(path, prefetcher) {
     const connection = window.navigator.connection;
     if (document.visibilityState === 'hidden')

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

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

package/dist/internal/navigation/redirect-boundary.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Component } from 'react';
-import { isRedirect, REDIRECT_DIGEST_PREFIX } from './redirect';
+import { isRedirect, REDIRECT_DIGEST_PREFIX } from './redirect.js';
 class Boundary extends Component {
     constructor(props) {
         super(props);

package/dist/internal/navigation/redirect.js

@@ -1,4 +1,4 @@
-import { Solas } from '../../solas';
+import { Solas } from '../../solas.js';
 /**
  * Redirect exception class to signal a redirect
  */