@kasperrt/smolter 0.0.0-stage → 0.0.1-rc.1

package/dist/internal/preact/link.js

@@ -0,0 +1,28 @@
+/**
+ * Preact components and typed data hooks. Import from smolter/preact.
+ * @module
+ */
+import { internalURL } from "../core/index.js";
+import { useRouter } from "./context.js";
+import { createElement } from "./runtime.js";
+/** Render an anchor that handles internal navigation and preserves native modified clicks. */
+export function Link({ href, replace, onClick, ...props }) {
+    const router = useRouter();
+    const click = (event) => {
+        onClick?.(event);
+        if (event.defaultPrevented ||
+            event.button ||
+            event.metaKey ||
+            event.ctrlKey ||
+            event.altKey ||
+            event.shiftKey ||
+            props.download !== undefined ||
+            (props.target && props.target !== "_self"))
+            return;
+        if (!internalURL(router.getSnapshot().url, href))
+            return;
+        event.preventDefault();
+        void router.navigate(href, { replace });
+    };
+    return createElement("a", { ...props, href, onClick: click });
+}

package/dist/internal/preact/routes.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Preact components and typed data hooks. Import from smolter/preact.
+ * @module
+ */
+import type { RouteModule } from "../core/index.ts";
+import type { ComponentType, ReactNode } from "./runtime.ts";
+/** Renderable route module with optional loading and error components. */
+export interface ViewModule extends RouteModule {
+    default?: ComponentType;
+    HydrateFallback?: ComponentType;
+    ErrorBoundary?: ComponentType<ErrorProps>;
+}
+/** Normalized route error supplied to an ErrorBoundary component. */
+export interface ErrorProps {
+    error: Error;
+}
+/** Fallback content used when no matching component can be rendered. */
+export interface RoutesProps {
+    fallback?: ReactNode;
+}
+/** Renders the first matching registered module. */
+export declare function Routes({ fallback }: RoutesProps): ReactNode;

package/dist/internal/preact/routes.js

@@ -0,0 +1,22 @@
+/**
+ * Preact components and typed data hooks. Import from smolter/preact.
+ * @module
+ */
+import { useRouter, useSnapshot } from "./context.js";
+import { createElement, useMemo } from "./runtime.js";
+/** Renders the first matching registered module. */
+export function Routes({ fallback = null }) {
+    const router = useRouter();
+    const state = useSnapshot((snapshot) => snapshot);
+    const module = router.routes.find((route) => route.path === state.path);
+    const component = state.error
+        ? module?.ErrorBoundary
+        : state.state === "loading" && !state.loaded
+            ? module?.HydrateFallback
+            : module?.default;
+    const element = useMemo(() => component &&
+        createElement(component, {
+            error: state.error,
+        }), [component, state.error]);
+    return element ?? state.error?.message ?? fallback;
+}

package/dist/internal/preact/runtime.d.ts

@@ -0,0 +1,2 @@
+export type { AnchorHTMLAttributes, ComponentType, FormHTMLAttributes, MouseEvent, ReactNode, } from "preact/compat";
+export { createContext, createElement, useContext, useEffect, useMemo, useSyncExternalStore, } from "preact/compat";

package/dist/internal/preact/runtime.js

@@ -0,0 +1 @@
+export { createContext, createElement, useContext, useEffect, useMemo, useSyncExternalStore, } from "preact/compat";

package/dist/internal/react/context.d.ts

@@ -0,0 +1,18 @@
+/**
+ * React components and typed data hooks. Import from smolter/react.
+ * @module
+ */
+import type { Router, Snapshot } from "../core/index.ts";
+import type { ReactNode } from "./runtime.ts";
+/** Router instance and children rendered within its context. */
+export interface RouterProviderProps {
+    router: Router;
+    children?: ReactNode;
+}
+/** Provide a router to descendant hooks and connect its browser lifecycle. */
+export declare function RouterProvider({ router, children, }: RouterProviderProps): ReactNode;
+/** Hooks require a RouterProvider. */
+export declare function useRouter(): Router;
+type SnapshotSelector<T> = (snapshot: Snapshot) => T;
+export declare function useSnapshot<T>(select: SnapshotSelector<T>): T;
+export {};

package/dist/internal/react/context.js

@@ -0,0 +1,20 @@
+/**
+ * React components and typed data hooks. Import from smolter/react.
+ * @module
+ */
+import { createContext, createElement, useContext, useEffect, useSyncExternalStore, } from "./runtime.js";
+const RouterContext = createContext(undefined);
+/** Provide a router to descendant hooks and connect its browser lifecycle. */
+export function RouterProvider({ router, children, }) {
+    useEffect(router.start, [router]);
+    return createElement(RouterContext.Provider, { value: router }, children);
+}
+/** Hooks require a RouterProvider. */
+export function useRouter() {
+    return useContext(RouterContext);
+}
+export function useSnapshot(select) {
+    const router = useRouter();
+    const getSnapshot = () => select(router.getSnapshot());
+    return useSyncExternalStore(router.subscribe, getSnapshot, getSnapshot);
+}

package/dist/internal/react/fetcher.d.ts

@@ -0,0 +1,22 @@
+/**
+ * React components and typed data hooks. Import from smolter/react.
+ * @module
+ */
+import type { AnyDataFunction, DataFunction, DataOf, FetcherSnapshot, Result, Route as RouteDefinition, RouteModule, SubmitOptions } from "../core/index.ts";
+import { type FormProps } from "./form.ts";
+import type { ComponentType } from "./runtime.ts";
+/** Action method and optional explicit route URL for a fetcher submission. */
+export interface FetcherSubmitOptions extends SubmitOptions {
+    action?: string;
+}
+/** Typed independent request state, methods, and a bound Form component. */
+export interface TypedFetcher<T> extends Omit<FetcherSnapshot, "data"> {
+    data?: T;
+    Form: ComponentType<FormProps>;
+    load: (url?: string) => Promise<Result>;
+    submit: (body: FormData, options?: FetcherSubmitOptions) => Promise<Result>;
+}
+/** Create a fetcher for independent route reads and mutations; its data stays local. */
+export declare function useFetcher<T extends RouteModule>(route: RouteDefinition<T>): TypedFetcher<DataOf<Extract<T["action"] | T["clientAction"], AnyDataFunction>> | DataOf<Extract<T["loader"] | T["clientLoader"], AnyDataFunction>>>;
+/** Create a fetcher for independent route reads and mutations; its data stays local. */
+export declare function useFetcher<T extends AnyDataFunction = DataFunction>(): TypedFetcher<DataOf<T>>;

package/dist/internal/react/fetcher.js

@@ -0,0 +1,28 @@
+/**
+ * React components and typed data hooks. Import from smolter/react.
+ * @module
+ */
+import { useRouter } from "./context.js";
+import { Form } from "./form.js";
+import { createElement, useEffect, useMemo, useSyncExternalStore, } from "./runtime.js";
+/** Create a fetcher for independent route reads and mutations; its data stays local. */
+export function useFetcher(route) {
+    const router = useRouter();
+    const path = route?.path;
+    const fetcher = useMemo(() => {
+        const store = router.createFetcher();
+        const target = () => {
+            const snapshot = router.getSnapshot();
+            return path === undefined || path === snapshot.path ? snapshot.url : path;
+        };
+        return {
+            ...store,
+            Form: (props) => createElement(Form, { action: target(), ...props, fetcher: store }),
+            load: (url) => store.load(url ?? target()),
+            submit: (body, options) => store.submit(options?.action ?? target(), body, options),
+        };
+    }, [router, path]);
+    useEffect(() => fetcher.dispose, [fetcher]);
+    const state = useSyncExternalStore(fetcher.subscribe, fetcher.getSnapshot, fetcher.getSnapshot);
+    return { ...fetcher, ...state };
+}

package/dist/internal/react/form.d.ts

@@ -0,0 +1,17 @@
+/**
+ * React components and typed data hooks. Import from smolter/react.
+ * @module
+ */
+import type { Fetcher } from "../core/index.ts";
+import type { FormHTMLAttributes, ReactNode } from "./runtime.ts";
+/** Form attributes with GET loader requests or POST, PUT, PATCH, and DELETE actions. */
+export interface FormProps extends Omit<FormHTMLAttributes<HTMLFormElement>, "action" | "method"> {
+    action?: string;
+    method?: "get" | "post" | "put" | "patch" | "delete";
+}
+interface InternalFormProps extends FormProps {
+    fetcher?: Fetcher;
+}
+/** Submit form data to a registered route without a document reload. */
+export declare function Form({ action, method, fetcher, onSubmit, ...props }: InternalFormProps): ReactNode;
+export {};

package/dist/internal/react/form.js

@@ -0,0 +1,41 @@
+/**
+ * React components and typed data hooks. Import from smolter/react.
+ * @module
+ */
+import { internalURL } from "../core/index.js";
+import { useRouter } from "./context.js";
+import { createElement } from "./runtime.js";
+/** Submit form data to a registered route without a document reload. */
+export function Form({ action, method = "post", fetcher, onSubmit, ...props }) {
+    const router = useRouter();
+    const submit = (event) => {
+        onSubmit?.(event);
+        if (event.defaultPrevented)
+            return;
+        const submitter = event.nativeEvent.submitter;
+        const target = internalURL(router.getSnapshot().url, submitter?.getAttribute("formaction") ?? action);
+        if (!target)
+            return;
+        event.preventDefault();
+        const data = new FormData(event.currentTarget, submitter);
+        const verb = (submitter?.getAttribute("formmethod") ?? method).toUpperCase();
+        if (verb === "GET") {
+            const search = new URLSearchParams();
+            for (const [key, value] of data)
+                search.append(key, typeof value === "string" ? value : value.name);
+            target.search = String(search);
+            void (fetcher ? fetcher.load : router.navigate)(target.href);
+            return;
+        }
+        const options = {
+            method: verb,
+        };
+        void (fetcher ?? router).submit(target.href, data, options);
+    };
+    return createElement("form", {
+        ...props,
+        action,
+        method: method === "get" ? "get" : "post",
+        onSubmit: submit,
+    });
+}

package/dist/internal/react/hooks.d.ts

@@ -0,0 +1,21 @@
+/**
+ * React components and typed data hooks. Import from smolter/react.
+ * @module
+ */
+import type { AnyDataFunction, DataOf, RouteModule, Router, Snapshot } from "../core/index.ts";
+/** A route module or loader function used for data inference. */
+export type LoaderSource = RouteModule | AnyDataFunction;
+/** Infer server and client loader data from a route module or function. */
+export type LoaderData<T> = T extends AnyDataFunction ? DataOf<T> : T extends RouteModule ? DataOf<Extract<T["loader"] | T["clientLoader"], AnyDataFunction>> : unknown;
+/** Infer server and client action data from a route module or function. */
+export type ActionData<T> = T extends AnyDataFunction ? DataOf<T> : T extends RouteModule ? DataOf<Extract<T["action"] | T["clientAction"], AnyDataFunction>> : unknown;
+/** Pass a route for inference, or use useLoaderData<typeof loader>() in its module. */
+export declare function useLoaderData<T extends LoaderSource = RouteModule>(route?: T): LoaderData<T> | undefined;
+/** Read the last page action result, optionally inferring its type from a route. */
+export declare function useActionData<T extends LoaderSource = RouteModule>(route?: T): ActionData<T> | undefined;
+/** Read path parameters for the active route. */
+export declare function useParams(): Snapshot["params"];
+/** Read the current path, search, and hash together with the navigate function. */
+export declare function useLocation(): readonly [string, Router["navigate"]];
+/** Get the function that revalidates the current loader subject to shouldRevalidate. */
+export declare function useRevalidator(): Router["revalidate"];

package/dist/internal/react/hooks.js

@@ -0,0 +1,35 @@
+/**
+ * React components and typed data hooks. Import from smolter/react.
+ * @module
+ */
+import { useRouter, useSnapshot } from "./context.js";
+function useData(key, route) {
+    const path = route?.path;
+    return useSnapshot((snapshot) => {
+        if (path !== undefined && path !== snapshot.path)
+            return undefined;
+        return snapshot[key];
+    });
+}
+/** Pass a route for inference, or use useLoaderData<typeof loader>() in its module. */
+export function useLoaderData(route) {
+    return useData("data", route);
+}
+/** Read the last page action result, optionally inferring its type from a route. */
+export function useActionData(route) {
+    return useData("actionData", route);
+}
+/** Read path parameters for the active route. */
+export function useParams() {
+    return useSnapshot((snapshot) => snapshot.params);
+}
+/** Read the current path, search, and hash together with the navigate function. */
+export function useLocation() {
+    const router = useRouter();
+    const url = useSnapshot((snapshot) => snapshot.url);
+    return [url.replace(/^\w+:\/\/[^/]+/, ""), router.navigate];
+}
+/** Get the function that revalidates the current loader subject to shouldRevalidate. */
+export function useRevalidator() {
+    return useRouter().revalidate;
+}

package/dist/internal/react/index.d.ts

@@ -0,0 +1,9 @@
+/** Framework components and typed data hooks. @module */
+export type * from "../core/index.ts";
+export { createRouter, defineRoute } from "../core/index.ts";
+export { RouterProvider, type RouterProviderProps, useRouter, } from "./context.ts";
+export * from "./fetcher.ts";
+export * from "./form.ts";
+export * from "./hooks.ts";
+export * from "./link.ts";
+export * from "./routes.ts";

package/dist/internal/react/index.js

@@ -0,0 +1,7 @@
+export { createRouter, defineRoute } from "../core/index.js";
+export { RouterProvider, useRouter, } from "./context.js";
+export * from "./fetcher.js";
+export * from "./form.js";
+export * from "./hooks.js";
+export * from "./link.js";
+export * from "./routes.js";

package/dist/internal/react/link.d.ts

@@ -0,0 +1,12 @@
+/**
+ * React components and typed data hooks. Import from smolter/react.
+ * @module
+ */
+import type { AnchorHTMLAttributes, ReactNode } from "./runtime.ts";
+/** Anchor attributes with internal navigation and optional history replacement. */
+export interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    href: string;
+    replace?: boolean;
+}
+/** Render an anchor that handles internal navigation and preserves native modified clicks. */
+export declare function Link({ href, replace, onClick, ...props }: LinkProps): ReactNode;

package/dist/internal/react/link.js

@@ -0,0 +1,28 @@
+/**
+ * React components and typed data hooks. Import from smolter/react.
+ * @module
+ */
+import { internalURL } from "../core/index.js";
+import { useRouter } from "./context.js";
+import { createElement } from "./runtime.js";
+/** Render an anchor that handles internal navigation and preserves native modified clicks. */
+export function Link({ href, replace, onClick, ...props }) {
+    const router = useRouter();
+    const click = (event) => {
+        onClick?.(event);
+        if (event.defaultPrevented ||
+            event.button ||
+            event.metaKey ||
+            event.ctrlKey ||
+            event.altKey ||
+            event.shiftKey ||
+            props.download !== undefined ||
+            (props.target && props.target !== "_self"))
+            return;
+        if (!internalURL(router.getSnapshot().url, href))
+            return;
+        event.preventDefault();
+        void router.navigate(href, { replace });
+    };
+    return createElement("a", { ...props, href, onClick: click });
+}

package/dist/internal/react/routes.d.ts

@@ -0,0 +1,22 @@
+/**
+ * React components and typed data hooks. Import from smolter/react.
+ * @module
+ */
+import type { RouteModule } from "../core/index.ts";
+import type { ComponentType, ReactNode } from "./runtime.ts";
+/** Renderable route module with optional loading and error components. */
+export interface ViewModule extends RouteModule {
+    default?: ComponentType;
+    HydrateFallback?: ComponentType;
+    ErrorBoundary?: ComponentType<ErrorProps>;
+}
+/** Normalized route error supplied to an ErrorBoundary component. */
+export interface ErrorProps {
+    error: Error;
+}
+/** Fallback content used when no matching component can be rendered. */
+export interface RoutesProps {
+    fallback?: ReactNode;
+}
+/** Renders the first matching registered module. */
+export declare function Routes({ fallback }: RoutesProps): ReactNode;

package/dist/internal/react/routes.js

@@ -0,0 +1,22 @@
+/**
+ * React components and typed data hooks. Import from smolter/react.
+ * @module
+ */
+import { useRouter, useSnapshot } from "./context.js";
+import { createElement, useMemo } from "./runtime.js";
+/** Renders the first matching registered module. */
+export function Routes({ fallback = null }) {
+    const router = useRouter();
+    const state = useSnapshot((snapshot) => snapshot);
+    const module = router.routes.find((route) => route.path === state.path);
+    const component = state.error
+        ? module?.ErrorBoundary
+        : state.state === "loading" && !state.loaded
+            ? module?.HydrateFallback
+            : module?.default;
+    const element = useMemo(() => component &&
+        createElement(component, {
+            error: state.error,
+        }), [component, state.error]);
+    return element ?? state.error?.message ?? fallback;
+}

package/dist/internal/react/runtime.d.ts

@@ -0,0 +1,2 @@
+export type { AnchorHTMLAttributes, ComponentType, FormHTMLAttributes, MouseEvent, ReactNode, } from "react";
+export { createContext, createElement, useContext, useEffect, useMemo, useSyncExternalStore, } from "react";

package/dist/internal/react/runtime.js

@@ -0,0 +1,2 @@
+// @deno-types="npm:@types/react@19.3.0"
+export { createContext, createElement, useContext, useEffect, useMemo, useSyncExternalStore, } from "react";

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

@@ -0,0 +1,11 @@
+/**
+ * Request-scoped server rendering and HTTP data dispatch.
+ * @module
+ */
+import { type Route, type Router, type Snapshot } from "../core/index.ts";
+/** Create one router per server request, await this, then render the provider. */
+export declare function loadRouter(routes: readonly Route[], input: string | Request): Promise<Router>;
+/** Safe inside a script element. Data must be JSON serializable; error stacks and causes are omitted. */
+export declare function serialize(snapshot: Snapshot): string;
+/** Dispatch an HTTP data request to a registered server loader or action. */
+export declare function handleRequest(routes: readonly Route[], request: Request): Promise<Response>;

package/dist/internal/server/index.js

@@ -0,0 +1,81 @@
+/**
+ * Request-scoped server rendering and HTTP data dispatch.
+ * @module
+ */
+import { createRouter, matchRoutes, safeWrapAsync, } from "../core/index.js";
+/** Create one router per server request, await this, then render the provider. */
+export async function loadRouter(routes, input) {
+    const url = typeof input === "string" ? input : input.url;
+    const wrap = (handler) => {
+        if (!handler || typeof input === "string")
+            return handler;
+        return (args) => {
+            const signal = AbortSignal.any([input.signal, args.signal]);
+            const request = new Request(args.request, { signal });
+            input.headers.forEach((value, name) => {
+                if (!request.headers.has(name))
+                    request.headers.set(name, value);
+            });
+            return handler({ ...args, request, signal });
+        };
+    };
+    const serverRoutes = routes.map((route) => ({
+        ...route,
+        clientLoader: undefined,
+        clientAction: undefined,
+        loader: wrap(route.loader),
+        action: wrap(route.action),
+    }));
+    const router = createRouter(serverRoutes, { url });
+    await router.navigate(url);
+    const snapshot = router.getSnapshot();
+    if (!snapshot.error &&
+        snapshot.data === undefined &&
+        routes.some((route) => route.path === snapshot.path && route.clientLoader && !route.loader)) {
+        return createRouter(serverRoutes, {
+            url,
+            hydrationData: { ...snapshot, loaded: false, state: "loading" },
+        });
+    }
+    return router;
+}
+/** Safe inside a script element. Data must be JSON serializable; error stacks and causes are omitted. */
+export function serialize(snapshot) {
+    return JSON.stringify({
+        ...snapshot,
+        error: snapshot.error && {
+            name: snapshot.error.name,
+            message: snapshot.error.message,
+        },
+    })
+        .replace(/</g, "\\u003c")
+        .replace(/\u2028/g, "\\u2028")
+        .replace(/\u2029/g, "\\u2029");
+}
+/** Dispatch an HTTP data request to a registered server loader or action. */
+export async function handleRequest(routes, request) {
+    const match = matchRoutes(routes, new URL(request.url).pathname);
+    const reading = request.method === "GET";
+    if (!match)
+        return Response.json({ error: "No route" }, { status: 404 });
+    if (!reading && !["POST", "PUT", "PATCH", "DELETE"].includes(request.method))
+        return Response.json({ error: "Method not allowed" }, { status: 405 });
+    const handler = reading ? match.route.loader : match.route.action;
+    if (!handler)
+        return Response.json({ error: `No ${reading ? "loader" : "action"}` }, { status: 405 });
+    const result = await safeWrapAsync(() => handler({ request, params: match.params, signal: request.signal }));
+    const error = result.error ?? (result.data instanceof Error && result.data);
+    if (error)
+        return Response.json({ error: error.message }, { status: 500 });
+    if (result.data instanceof Response) {
+        const location = result.data.headers.get("Location");
+        if (location)
+            return new Response(null, {
+                headers: { "X-Smolter-Redirect": location },
+            });
+        return result.data;
+    }
+    return Response.json(result.data ?? null, {
+        headers: { "Cache-Control": "no-store" },
+    });
+}

package/dist/internal/vite/index.d.ts

@@ -0,0 +1,10 @@
+import { type Plugin } from "vite";
+export interface FileRouterOptions {
+    directory?: string;
+    clientRoutes?: string;
+    serverRoutes?: string;
+}
+/** Build-time flat route discovery and the optional server data transport. */
+export declare function routerPlugin({ directory, clientRoutes, serverRoutes, }?: FileRouterOptions): Plugin;
+/** File routing is the default; this alias keeps configuration explicit. */
+export declare const fileRouter: typeof routerPlugin;

package/dist/internal/vite/index.js

@@ -0,0 +1,132 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { flatRoutes } from "../files/index.js";
+import { transformWithOxc } from "vite";
+import { configureTransport } from "./transport.js";
+/** Build-time flat route discovery and the optional server data transport. */
+export function routerPlugin({ directory = "src/routes", clientRoutes, serverRoutes, } = {}) {
+    let root;
+    let projectRoot;
+    const publicId = "virtual:smolter/routes";
+    const virtualId = `\0${publicId}`;
+    const suffix = "?smolter-client";
+    return {
+        name: "smolter-flat-routes",
+        enforce: "pre",
+        configResolved(config) {
+            projectRoot = config.root;
+            root = resolve(config.root, directory);
+        },
+        resolveId(id) {
+            if (id === publicId)
+                return virtualId;
+        },
+        async load(id, options) {
+            if (id.endsWith(suffix)) {
+                const file = id.slice(0, -suffix.length);
+                const transformed = await transformWithOxc(await readFile(file, "utf8"), file);
+                const ast = this.parse(transformed.code);
+                const edits = [];
+                for (const statement of ast.body) {
+                    if (statement.type === "ExportAllDeclaration") {
+                        return this.error(`Use explicit named exports in ${file}; export * cannot be safely split between server and browser.`);
+                    }
+                    if (statement.type !== "ExportNamedDeclaration")
+                        continue;
+                    const server = statement.specifiers.filter((specifier) => {
+                        const name = specifier.exported.type === "Identifier"
+                            ? specifier.exported.name
+                            : specifier.exported.value;
+                        return name === "loader" || name === "action";
+                    });
+                    if (!server.length) {
+                        const declaration = statement.declaration;
+                        const name = declaration?.type === "FunctionDeclaration"
+                            ? declaration.id?.name
+                            : undefined;
+                        const variables = declaration?.type === "VariableDeclaration"
+                            ? declaration.declarations
+                            : [];
+                        if (name === "loader" ||
+                            name === "action" ||
+                            variables.some((item) => item.id.type === "Identifier" &&
+                                ["loader", "action"].includes(item.id.name))) {
+                            return this.error(`Re-export loader/action from separate files in ${file}; inline server handlers cannot enter a browser module.`);
+                        }
+                        continue;
+                    }
+                    if (!statement.source ||
+                        server.length !== statement.specifiers.length) {
+                        return this.error(`Use separate export { loader } / export { action } statements in ${file}.`);
+                    }
+                    edits.push([statement.start, statement.end]);
+                }
+                let code = transformed.code;
+                for (const [start, end] of edits.reverse())
+                    code = code.slice(0, start) + code.slice(end);
+                return { code, map: null };
+            }
+            if (id !== virtualId)
+                return;
+            if (clientRoutes || serverRoutes) {
+                if (!clientRoutes || !serverRoutes)
+                    return this.error("Specify both clientRoutes and serverRoutes for manual routing.");
+                const entry = resolve(projectRoot, options?.ssr ? serverRoutes : clientRoutes).replaceAll("\\", "/");
+                return `export { routes as default } from ${JSON.stringify(entry)};`;
+            }
+            const routes = await flatRoutes(root);
+            if (routes instanceof Error)
+                return this.error(routes.message);
+            const imports = [];
+            const definitions = [];
+            for (const [index, route] of routes.entries()) {
+                this.addWatchFile(route.file);
+                const file = route.file.replaceAll("\\", "/");
+                const transformed = await transformWithOxc(await readFile(file, "utf8"), file);
+                const ast = this.parse(transformed.code);
+                const handlers = {};
+                for (const statement of ast.body) {
+                    if (statement.type !== "ExportNamedDeclaration")
+                        continue;
+                    for (const specifier of statement.specifiers) {
+                        const name = specifier.exported.type === "Identifier"
+                            ? specifier.exported.name
+                            : specifier.exported.value;
+                        if (name === "loader" || name === "action")
+                            handlers[name] = true;
+                    }
+                }
+                imports.push(`import * as route${index} from ${JSON.stringify(file + (options?.ssr ? "" : suffix))};`);
+                definitions.push(options?.ssr || !Object.keys(handlers).length
+                    ? `{ ...route${index}, path: ${JSON.stringify(route.path)} }`
+                    : `serverRoute(${JSON.stringify(route.path)}, route${index}, ${JSON.stringify(handlers)})`);
+            }
+            if (!options?.ssr &&
+                definitions.some((definition) => definition.startsWith("serverRoute(")))
+                imports.unshift('import { serverRoute } from "smolter/client";');
+            return `${imports.join("\n")}\nexport default [${definitions.join(",\n")}];\n`;
+        },
+        configureServer(server) {
+            server.watcher.add(root);
+            const refresh = (file) => {
+                if (!file.startsWith(`${root}/`))
+                    return;
+                const module = server.moduleGraph.getModuleById(virtualId);
+                if (module)
+                    server.moduleGraph.invalidateModule(module);
+                server.ws.send({ type: "full-reload" });
+            };
+            server.watcher.on("add", refresh);
+            server.watcher.on("change", refresh);
+            server.watcher.on("unlink", refresh);
+            server.httpServer?.once("close", () => {
+                server.watcher.off("add", refresh);
+                server.watcher.off("change", refresh);
+                server.watcher.off("unlink", refresh);
+            });
+            configureTransport(server, publicId);
+        },
+    };
+}
+/** File routing is the default; this alias keeps configuration explicit. */
+export const fileRouter = routerPlugin;