@jk2908/solas 0.3.0 → 0.3.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.3.2 - 2026-04-21
+
+- Fixed PPR flight transport and closed-connection handling by replacing `rsc-html-stream` with the local runtime transport.
+- Fixed prerender artifact manifest handling for dynamic params by writing the final built artifact manifest and using it for runtime artifact lookups.
+
+## 0.3.1 - 2026-04-07
+
+- Fixed `useSearchParams()` client builds.
+- Reworked the code generators to keep the source templates readable while still emitting tidy generated files.
+- Added a shared template dedent helper for generated source and tightened nested object and route map indentation.
+- Made generated config output emit logger code only when a logger level is configured.
+
 ## 0.3.0 - 2026-04-07
 
 - Fixed `useSearchParams()` hydration so query-driven ui uses the initial request url on first render.

package/dist/cli/build.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The build command does more than just run vite build - it also handles prerendering and
+ * precompressing assets. This is because prerendering needs to run against the built
+ * server entry to ensure the same code paths as preview, and precompressing needs
+ * to include the prerendered html and json files
+ */
+export declare function build(): Promise<void>;

package/dist/cli/build.js

@@ -0,0 +1,183 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { Compress } from '../utils/compress.js';
+import { Logger } from '../utils/logger.js';
+import { Prerender } from '../internal/prerender.js';
+import { Solas } from '../solas.js';
+const logger = new Logger();
+/**
+ * The build command does more than just run vite build - it also handles prerendering and
+ * precompressing assets. This is because prerendering needs to run against the built
+ * server entry to ensure the same code paths as preview, and precompressing needs
+ * to include the prerendered html and json files
+ */
+export async function build() {
+    // build and prerender should both run in production mode
+    process.env.NODE_ENV = 'production';
+    const cwd = process.cwd();
+    const manifestPath = path.join(cwd, Solas.Config.GENERATED_DIR, 'build.json');
+    // run vite build
+    logger.info('[build]', 'running vite build...');
+    const vite = Bun.spawnSync(['bunx', '--bun', 'vite', 'build', '--mode', 'production'], {
+        cwd,
+        stdout: 'inherit',
+        stderr: 'inherit',
+        env: { ...process.env, NODE_ENV: 'production' },
+    });
+    if (vite.exitCode !== 0) {
+        logger.error('[build] vite build failed');
+        process.exit(1);
+    }
+    // read build manifest
+    let manifest;
+    try {
+        const raw = await fs.readFile(manifestPath, 'utf-8');
+        manifest = JSON.parse(raw);
+    }
+    catch (err) {
+        logger.error('[build] failed to read build manifest', err);
+        process.exit(1);
+    }
+    const outDir = path.resolve(cwd, Solas.Config.OUT_DIR);
+    const rscDir = path.join(outDir, 'rsc');
+    const artifactRoot = Prerender.Artifact.getRootPath(outDir);
+    // clear old prerender artifacts so routes that have switched modes
+    // do not keep stale metadata from a previous build
+    await fs.rm(artifactRoot, { recursive: true, force: true });
+    // prerender routes
+    if (manifest.prerenderRoutes.length > 0) {
+        const timeout = Prerender.Build.getTimeout();
+        const concurrency = Prerender.Build.getConcurrency();
+        // track the extra prerender files we write for preview
+        const artifactManifest = {};
+        // keep in-flight artifact writes bounded so result handling does not block on one route at a time
+        const pendingWrites = new Set();
+        logger.info('[prerender]', `prerendering ${manifest.prerenderRoutes.length} routes (timeout: ${timeout}ms, concurrency: ${concurrency})...`);
+        // load the built server entry and render each prerendered route through it
+        const rscEntry = path.join(rscDir, 'index.js');
+        const { default: app } = await import(/* @vite-ignore */ rscEntry);
+        async function enqueueWrite(task) {
+            const write = task().finally(() => {
+                pendingWrites.delete(write);
+            });
+            pendingWrites.add(write);
+            if (pendingWrites.size >= concurrency) {
+                await Promise.race(pendingWrites);
+            }
+        }
+        // run prerender through the built app so build output uses the same path as preview
+        for await (const result of Prerender.Build.run(app, manifest.prerenderRoutes, {
+            timeout,
+            concurrency,
+            origin: manifest.url,
+        })) {
+            const route = result.route;
+            if ('error' in result) {
+                logger.error(`[prerender]: Failed ${route}: ${result.error}. This often means unresolved async work (for example external fetches or dynamic rendering in full mode)`);
+                continue;
+            }
+            if ('status' in result) {
+                logger.warn(`[prerender]: Skipped ${route}: ${result.status}`);
+                continue;
+            }
+            const artifact = result.artifact;
+            const artifactDir = Prerender.Artifact.getPath(outDir, route);
+            await enqueueWrite(async () => {
+                try {
+                    if (artifact.mode === 'ppr') {
+                        // for ppr save the shell now and keep the postponed state for later
+                        await fs.mkdir(artifactDir, { recursive: true });
+                        const writes = [
+                            Bun.write(path.join(artifactDir, 'prelude.html'), artifact.html),
+                            Bun.write(path.join(artifactDir, 'metadata.json'), JSON.stringify({
+                                schema: artifact.schema,
+                                route: artifact.route,
+                                createdAt: artifact.createdAt,
+                                mode: artifact.mode,
+                            })),
+                        ];
+                        if (artifact.postponed !== undefined) {
+                            writes.push(Bun.write(path.join(artifactDir, 'postponed.json'), JSON.stringify(artifact.postponed)));
+                        }
+                        await Promise.all(writes);
+                        artifactManifest[route] = {
+                            mode: artifact.mode,
+                            files: artifact.postponed !== undefined
+                                ? ['metadata', 'prelude', 'postponed']
+                                : ['metadata', 'prelude'],
+                        };
+                        logger.info('[prerender:artifacts]', JSON.stringify({
+                            route,
+                            prelude: artifact.html,
+                            postponed: artifact.postponed ?? null,
+                            metadata: {
+                                schema: artifact.schema,
+                                route: artifact.route,
+                                createdAt: artifact.createdAt,
+                                mode: artifact.mode,
+                            },
+                        }));
+                        logger.info('[prerender]', `${route} (ppr)`);
+                        return;
+                    }
+                    // full prerender still keeps metadata so preview knows to serve saved html
+                    await fs.mkdir(artifactDir, { recursive: true });
+                    const fullPrerenderFilename = Prerender.Artifact.FULL_PRERENDER_FILENAME;
+                    await Promise.all([
+                        Bun.write(path.join(artifactDir, 'metadata.json'), JSON.stringify({
+                            schema: artifact.schema,
+                            route: artifact.route,
+                            createdAt: artifact.createdAt,
+                            mode: artifact.mode,
+                        })),
+                        Bun.write(Prerender.Artifact.getFilePath(outDir, route, fullPrerenderFilename), artifact.html),
+                    ]);
+                    artifactManifest[route] = {
+                        mode: artifact.mode,
+                        files: ['metadata', 'html'],
+                    };
+                    logger.info(`[prerender]: ${route} (full)`);
+                }
+                catch (err) {
+                    logger.error(`[prerender]: Failed ${route}: ${err}. This often means unresolved async work (for example external fetches or dynamic rendering in full mode).`);
+                }
+            });
+        }
+        await Promise.all(pendingWrites);
+        // write one manifest for the saved prerender files after all routes finish
+        await fs.mkdir(artifactRoot, { recursive: true });
+        await Bun.write(Prerender.Artifact.getManifestPath(outDir), JSON.stringify({
+            routes: artifactManifest,
+        }));
+    }
+    // sitemap
+    if (manifest.sitemapRoutes.length > 0 && manifest.url) {
+        const origin = manifest.url.replace(/\/$/, '');
+        const urls = manifest.sitemapRoutes
+            .map(route => `  <url><loc>${origin}${route}</loc></url>`)
+            .join('\n');
+        const sitemap = [
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+            urls,
+            '</urlset>',
+        ].join('\n');
+        await Bun.write(path.join(outDir, 'sitemap.xml'), sitemap);
+        logger.info('[sitemap]', `generated ${manifest.sitemapRoutes.length} urls`);
+    }
+    // precompress
+    if (manifest.precompress) {
+        logger.info('[precompress]', 'compressing assets...');
+        // compress after prerender so generated html and json are included too
+        for await (const { input, compressed } of Compress.run(outDir, {
+            filter: f => /\.(js|css|html|svg|json|txt)$/.test(f),
+        })) {
+            await Bun.write(`${input}.br`, compressed);
+            logger.info('[precompress]', `${path.basename(input)}.br`);
+        }
+    }
+    // cleanup
+    // this file is only needed while the build command is running
+    await fs.unlink(manifestPath).catch(() => { });
+    logger.info('[build]', 'done');
+}

package/dist/cli/dev.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Start the vite development server
+ */
+export declare function dev(): Promise<void>;

package/dist/cli/dev.js

@@ -0,0 +1,13 @@
+/**
+ * Start the vite development server
+ */
+export async function dev() {
+    const proc = Bun.spawn(['bunx', '--bun', 'vite', 'dev'], {
+        cwd: process.cwd(),
+        stdout: 'inherit',
+        stderr: 'inherit',
+        stdin: 'inherit',
+        env: { ...process.env, NODE_ENV: 'development' },
+    });
+    await proc.exited;
+}

package/dist/cli/preview.d.ts

@@ -0,0 +1 @@
+export declare function preview(): Promise<void>;

package/dist/cli/preview.js

@@ -0,0 +1,47 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { Logger } from '../utils/logger.js';
+import { Solas } from '../solas.js';
+const logger = new Logger();
+const DEFAULT_PREVIEW_PORT = 4173;
+const [, , , ...args] = process.argv;
+export async function preview() {
+    // preview should behave like production, not like vite dev
+    process.env.NODE_ENV = 'production';
+    const cwd = process.cwd();
+    const outDir = path.resolve(cwd, Solas.Config.OUT_DIR);
+    const rscDir = path.join(outDir, 'rsc');
+    const rscEntry = path.join(rscDir, 'index.js');
+    const portFlagIndex = args.findIndex(arg => arg === '--port' || arg === '-p');
+    const parsedPort = portFlagIndex >= 0 && args[portFlagIndex + 1]
+        ? Number(args[portFlagIndex + 1])
+        : DEFAULT_PREVIEW_PORT;
+    // fail fast if the port is invalid
+    if (!Number.isInteger(parsedPort) || parsedPort <= 0 || parsedPort > 65535) {
+        logger.error(`[preview] invalid port: ${args[portFlagIndex + 1] ?? 'undefined'}`);
+        process.exit(1);
+    }
+    // the built server entry handles routing, prerendered html, and ssr here
+    try {
+        await fs.access(rscEntry);
+    }
+    catch (err) {
+        logger.error(`[preview] missing ${path.relative(cwd, rscEntry)} - run \`${Solas.Config.SLUG} build\` from this project directory first`, err);
+        process.exit(1);
+    }
+    const { default: app } = await import(/* @vite-ignore */ rscEntry);
+    try {
+        // keep the preview server thin and let the app handle requests
+        Bun.serve({
+            port: parsedPort,
+            fetch: app.fetch,
+        });
+    }
+    catch (err) {
+        logger.error(`[preview] failed to start on port ${parsedPort}: ${err}`);
+        process.exit(1);
+    }
+    logger.info('[preview]', `server running at http://localhost:${parsedPort}`);
+    // keep the process running after the server starts
+    await new Promise(() => { });
+}

package/dist/cli.js

@@ -1,244 +1,10 @@
 #!/usr/bin/env bun
-import fs from 'node:fs/promises';
-import path from 'node:path';
+import { build } from './cli/build.js';
+import { dev } from './cli/dev.js';
+import { preview } from './cli/preview.js';
 import { Solas } from './solas.js';
-import { Compress } from './utils/compress.js';
-import { Logger } from './utils/logger.js';
-import { Prerender } from './internal/prerender.js';
-const logger = new Logger();
-const DEFAULT_PREVIEW_PORT = 4173;
-/**
- * The build command does more than just run vite build - it also handles prerendering and
- * precompressing assets. This is because prerendering needs to run against the built
- * server entry to ensure the same code paths as preview, and precompressing needs
- * to include the prerendered html and json files
- */
-async function build() {
-    // build and prerender should both run in production mode
-    process.env.NODE_ENV = 'production';
-    const cwd = process.cwd();
-    const manifestPath = path.join(cwd, Solas.Config.GENERATED_DIR, 'build.json');
-    // run vite build
-    logger.info('[build]', 'running vite build...');
-    const vite = Bun.spawnSync(['bunx', '--bun', 'vite', 'build', '--mode', 'production'], {
-        cwd,
-        stdout: 'inherit',
-        stderr: 'inherit',
-        env: { ...process.env, NODE_ENV: 'production' },
-    });
-    if (vite.exitCode !== 0) {
-        logger.error('[build] vite build failed');
-        process.exit(1);
-    }
-    // read build manifest
-    let manifest;
-    try {
-        const raw = await fs.readFile(manifestPath, 'utf-8');
-        manifest = JSON.parse(raw);
-    }
-    catch (err) {
-        logger.error('[build] failed to read build manifest', err);
-        process.exit(1);
-    }
-    const outDir = path.resolve(cwd, Solas.Config.OUT_DIR);
-    const rscDir = path.join(outDir, 'rsc');
-    const artifactRoot = Prerender.Artifact.getRootPath(outDir);
-    // clear old prerender artifacts so routes that have switched modes
-    // do not keep stale metadata from a previous build
-    await fs.rm(artifactRoot, { recursive: true, force: true });
-    // prerender routes
-    if (manifest.prerenderRoutes.length > 0) {
-        const timeout = Prerender.Build.getTimeout();
-        const concurrency = Prerender.Build.getConcurrency();
-        // track the extra prerender files we write for preview
-        const artifactManifestRoutes = {};
-        // keep in-flight artifact writes bounded so result handling does not block on one route at a time
-        const pendingWrites = new Set();
-        logger.info('[prerender]', `prerendering ${manifest.prerenderRoutes.length} routes (timeout: ${timeout}ms, concurrency: ${concurrency})...`);
-        // load the built server entry and render each prerendered route through it
-        const rscEntry = path.join(rscDir, 'index.js');
-        const { default: app } = await import(/* @vite-ignore */ rscEntry);
-        async function enqueueWrite(task) {
-            const write = task().finally(() => {
-                pendingWrites.delete(write);
-            });
-            pendingWrites.add(write);
-            if (pendingWrites.size >= concurrency) {
-                await Promise.race(pendingWrites);
-            }
-        }
-        // run prerender through the built app so build output uses the same path as preview
-        for await (const result of Prerender.Build.run(app, manifest.prerenderRoutes, {
-            timeout,
-            concurrency,
-            origin: manifest.url,
-        })) {
-            const route = result.route;
-            if ('error' in result) {
-                logger.error(`[prerender]: Failed ${route}: ${result.error}. This often means unresolved async work (for example external fetches or dynamic rendering in full mode)`);
-                continue;
-            }
-            if ('status' in result) {
-                logger.warn(`[prerender]: Skipped ${route}: ${result.status}`);
-                continue;
-            }
-            const artifact = result.artifact;
-            const artifactDir = Prerender.Artifact.getPath(outDir, route);
-            await enqueueWrite(async () => {
-                try {
-                    if (artifact.mode === 'ppr') {
-                        // for ppr save the shell now and keep the postponed state for later
-                        await fs.mkdir(artifactDir, { recursive: true });
-                        const writes = [
-                            Bun.write(path.join(artifactDir, 'prelude.html'), artifact.html),
-                            Bun.write(path.join(artifactDir, 'metadata.json'), JSON.stringify({
-                                schema: artifact.schema,
-                                route: artifact.route,
-                                createdAt: artifact.createdAt,
-                                mode: artifact.mode,
-                            })),
-                        ];
-                        if (artifact.postponed !== undefined) {
-                            writes.push(Bun.write(path.join(artifactDir, 'postponed.json'), JSON.stringify(artifact.postponed)));
-                        }
-                        await Promise.all(writes);
-                        artifactManifestRoutes[route] = {
-                            mode: artifact.mode,
-                            createdAt: artifact.createdAt,
-                            files: artifact.postponed !== undefined
-                                ? ['metadata', 'prelude', 'postponed']
-                                : ['metadata', 'prelude'],
-                        };
-                        logger.info('[prerender:artifacts]', JSON.stringify({
-                            route,
-                            prelude: artifact.html,
-                            postponed: artifact.postponed ?? null,
-                            metadata: {
-                                schema: artifact.schema,
-                                route: artifact.route,
-                                createdAt: artifact.createdAt,
-                                mode: artifact.mode,
-                            },
-                        }));
-                        logger.info('[prerender]', `${route} (ppr)`);
-                        return;
-                    }
-                    // full prerender still keeps metadata so preview knows to serve saved html
-                    await fs.mkdir(artifactDir, { recursive: true });
-                    const fullPrerenderFilename = Prerender.Artifact.getFullHtmlFileName(artifact.html);
-                    await Promise.all([
-                        Bun.write(path.join(artifactDir, 'metadata.json'), JSON.stringify({
-                            schema: artifact.schema,
-                            route: artifact.route,
-                            createdAt: artifact.createdAt,
-                            mode: artifact.mode,
-                        })),
-                        Bun.write(Prerender.Artifact.getFilePath(outDir, route, fullPrerenderFilename), artifact.html),
-                    ]);
-                    artifactManifestRoutes[route] = {
-                        mode: artifact.mode,
-                        createdAt: artifact.createdAt,
-                        files: ['metadata', 'html'],
-                        fullPrerenderFilename,
-                    };
-                    logger.info(`[prerender]: ${route} (full)`);
-                }
-                catch (err) {
-                    logger.error(`[prerender]: Failed ${route}: ${err}. This often means unresolved async work (for example external fetches or dynamic rendering in full mode).`);
-                }
-            });
-        }
-        await Promise.all(pendingWrites);
-        // write one manifest for the saved prerender files after all routes finish
-        await fs.mkdir(artifactRoot, { recursive: true });
-        await Bun.write(Prerender.Artifact.getManifestPath(outDir), JSON.stringify({
-            generatedAt: Date.now(),
-            routes: artifactManifestRoutes,
-        }));
-    }
-    // sitemap
-    if (manifest.sitemapRoutes.length > 0 && manifest.url) {
-        const origin = manifest.url.replace(/\/$/, '');
-        const urls = manifest.sitemapRoutes
-            .map(route => `  <url><loc>${origin}${route}</loc></url>`)
-            .join('\n');
-        const sitemap = [
-            '<?xml version="1.0" encoding="UTF-8"?>',
-            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
-            urls,
-            '</urlset>',
-        ].join('\n');
-        await Bun.write(path.join(outDir, 'sitemap.xml'), sitemap);
-        logger.info('[sitemap]', `generated ${manifest.sitemapRoutes.length} urls`);
-    }
-    // precompress
-    if (manifest.precompress) {
-        logger.info('[precompress]', 'compressing assets...');
-        // compress after prerender so generated html and json are included too
-        for await (const { input, compressed } of Compress.run(outDir, {
-            filter: f => /\.(js|css|html|svg|json|txt)$/.test(f),
-        })) {
-            await Bun.write(`${input}.br`, compressed);
-            logger.info('[precompress]', `${path.basename(input)}.br`);
-        }
-    }
-    // cleanup
-    // this file is only needed while the build command is running
-    await fs.unlink(manifestPath).catch(() => { });
-    logger.info('[build]', 'done');
-}
-async function dev() {
-    const proc = Bun.spawn(['bunx', '--bun', 'vite', 'dev'], {
-        cwd: process.cwd(),
-        stdout: 'inherit',
-        stderr: 'inherit',
-        stdin: 'inherit',
-        env: { ...process.env, NODE_ENV: 'development' },
-    });
-    await proc.exited;
-}
-async function preview() {
-    // preview should behave like production, not like vite dev
-    process.env.NODE_ENV = 'production';
-    const cwd = process.cwd();
-    const outDir = path.resolve(cwd, Solas.Config.OUT_DIR);
-    const rscDir = path.join(outDir, 'rsc');
-    const rscEntry = path.join(rscDir, 'index.js');
-    const portFlagIndex = args.findIndex(arg => arg === '--port' || arg === '-p');
-    const parsedPort = portFlagIndex >= 0 && args[portFlagIndex + 1]
-        ? Number(args[portFlagIndex + 1])
-        : DEFAULT_PREVIEW_PORT;
-    // fail fast if the port is invalid
-    if (!Number.isInteger(parsedPort) || parsedPort <= 0 || parsedPort > 65535) {
-        logger.error(`[preview] invalid port: ${args[portFlagIndex + 1] ?? 'undefined'}`);
-        process.exit(1);
-    }
-    // the built server entry handles routing, prerendered html, and ssr here
-    try {
-        await fs.access(rscEntry);
-    }
-    catch (err) {
-        logger.error(`[preview] missing ${path.relative(cwd, rscEntry)} - run \`${Solas.Config.SLUG} build\` from this project directory first`, err);
-        process.exit(1);
-    }
-    const { default: app } = await import(/* @vite-ignore */ rscEntry);
-    try {
-        // keep the preview server thin and let the app handle requests
-        Bun.serve({
-            port: parsedPort,
-            fetch: app.fetch,
-        });
-    }
-    catch (err) {
-        logger.error(`[preview] failed to start on port ${parsedPort}: ${err}`);
-        process.exit(1);
-    }
-    logger.info('[preview]', `server running at http://localhost:${parsedPort}`);
-    // keep the process running after the server starts
-    await new Promise(() => { });
-}
 // read the subcommand once and dispatch below
-const [, , command, ...args] = process.argv;
+const [, , command] = process.argv;
 switch (command) {
     case 'build':
         await build();

package/dist/index.js

@@ -10,6 +10,7 @@ import { writeConfig } from './internal/codegen/config.js';
 import { writeBrowserEntry, writeRSCEntry, writeSSREntry, } from './internal/codegen/environments.js';
 import { writeManifest } from './internal/codegen/manifest.js';
 import { writeMaps } from './internal/codegen/maps.js';
+import { writeTypes } from './internal/codegen/types.js';
 import { Solas } from './solas.js';
 const DEFAULT_CONFIG = {
     precompress: true,
@@ -94,6 +95,7 @@ function solas(c) {
             ['config.ts', writeConfig(config)],
             ['manifest.ts', writeManifest(manifest)],
             ['maps.ts', writeMaps(imports, modules)],
+            [`${Solas.Config.SLUG}.d.ts`, writeTypes(manifest)],
             [Solas.Config.ENTRY_RSC, writeRSCEntry()],
             [Solas.Config.ENTRY_SSR, writeSSREntry()],
             [Solas.Config.ENTRY_BROWSER, writeBrowserEntry()],

package/dist/internal/browser-router/link.d.ts

@@ -0,0 +1,17 @@
+import { BrowserRouter } from './router.js';
+type AnchorProps = React.ComponentPropsWithRef<'a'> & {
+    href: string;
+};
+type BaseProps = {
+    prefetch?: 'intent' | 'hover' | 'none';
+} & AnchorProps;
+type Props = BaseProps & BrowserRouter.LinkProps;
+/**
+ * A link component that navigates to a given target
+ * @param href - the route target to navigate to
+ * @param prefetch - when to prefetch the linked page, defaults to 'none'
+ * @param rest - other props to pass to the underlying anchor element
+ * @returns a link element that navigates to the given target
+ */
+export declare function Link(props: Props): React.JSX.Element;
+export {};

package/dist/internal/{navigation → browser-router}/link.js

@@ -1,7 +1,8 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useRef } from 'react';
-import { useRouter } from '../router/use-router.js';
+import { BrowserRouter } from './router.js';
+import { useRouter } from './use-router.js';
 function guard(path, prefetcher) {
     const connection = window.navigator.connection;
     if (document.visibilityState === 'hidden')
@@ -12,22 +13,22 @@ function guard(path, prefetcher) {
         return;
     prefetcher(path);
 }
-/**
- * A link component that navigates to a given href
- * @param href - the href to navigate to
- * @param prefetch - when to prefetch the linked page, defaults to 'none'
- * @param rest - other props to pass to the underlying anchor element
- * @returns a link element that navigates to the given href
- */
-export function Link({ children, href, prefetch = 'none', ...rest }) {
+export function Link({ children, href, params, prefetch = 'none', query, ...rest }) {
     const { go, prefetch: prefetcher } = useRouter();
     const timer = useRef(null);
+    const handled = useRef(false);
+    const target = BrowserRouter.toTarget(href, params, query);
     // clear any pending hover-prefetch timer on unmount
     useEffect(() => () => {
         if (timer.current)
             clearTimeout(timer.current);
     }, []);
-    return (_jsx("a", { ...rest, href: href, onClick: e => {
+    useEffect(() => {
+        handled.current =
+            BrowserRouter.isHashOnlyTarget(target) ||
+                BrowserRouter.isExternalTarget(target, window.location.origin);
+    }, [target]);
+    return (_jsx("a", { ...rest, href: target, onClick: e => {
             rest.onClick?.(e);
             if (e.defaultPrevented)
                 return;
@@ -40,33 +41,38 @@ export function Link({ children, href, prefetch = 'none', ...rest }) {
                 return;
             if (rest.download)
                 return;
-            const to = new URL(href, window.location.origin);
-            if (to.origin !== window.location.origin)
+            if (handled.current)
                 return;
             e.preventDefault();
-            go(to.pathname + to.search + to.hash);
+            go(href, { params, query });
         }, onFocus: e => {
             rest.onFocus?.(e);
             if (e.defaultPrevented)
                 return;
             if (prefetch !== 'intent')
                 return;
-            guard(href, prefetcher);
+            if (handled.current)
+                return;
+            guard(target, prefetcher);
         }, onTouchStart: e => {
             rest.onTouchStart?.(e);
             if (e.defaultPrevented)
                 return;
             if (prefetch !== 'intent')
                 return;
-            guard(href, prefetcher);
+            if (handled.current)
+                return;
+            guard(target, prefetcher);
         }, onMouseEnter: e => {
             rest.onMouseEnter?.(e);
             if (e.defaultPrevented)
                 return;
             if (prefetch !== 'hover')
                 return;
+            if (handled.current)
+                return;
             timer.current = setTimeout(() => {
-                guard(href, prefetcher);
+                guard(target, prefetcher);
             }, 100);
         }, onMouseLeave: e => {
             rest.onMouseLeave?.(e);