rwsdk 0.1.16 → 0.1.17

package/dist/runtime/lib/debug.js

@@ -0,0 +1,36 @@
+// Simple debug function with DEBUG environment variable filtering
+// Supports patterns like: DEBUG=passkey:* or DEBUG=passkey:database,passkey:functions
+function isEnabled(namespace) {
+    const debug = process.env.DEBUG;
+    if (!debug)
+        return false;
+    const patterns = debug.split(",").map((p) => p.trim());
+    for (const pattern of patterns) {
+        if (pattern.startsWith("-")) {
+            const excludePattern = pattern.slice(1);
+            if (matchesPattern(namespace, excludePattern)) {
+                return false;
+            }
+            continue;
+        }
+        if (matchesPattern(namespace, pattern)) {
+            return true;
+        }
+    }
+    return false;
+}
+function matchesPattern(namespace, pattern) {
+    // Convert pattern to regex (handle * wildcards)
+    const regex = pattern
+        .replace(/\*/g, ".*") // * becomes .*
+        .replace(/:/g, "\\:"); // escape colons
+    return new RegExp(`^${regex}$`).test(namespace);
+}
+const debug = (namespace) => {
+    return (...args) => {
+        if (isEnabled(namespace)) {
+            console.log(`[${namespace}]`, ...args);
+        }
+    };
+};
+export default debug;

package/dist/runtime/lib/links.d.ts

@@ -0,0 +1,14 @@
+type ParseRoute<T extends string> = T extends `${infer Start}:${infer Param}/${infer Rest}` ? {
+    [K in Param]: string;
+} & ParseRoute<Rest> : T extends `${infer Start}:${infer Param}` ? {
+    [K in Param]: string;
+} : T extends `${infer Start}*${infer Rest}` ? {
+    $0: string;
+} & ParseRoute<Rest> : T extends `${infer Start}*` ? {
+    $0: string;
+} : {};
+type LinkFunction<T extends readonly string[]> = {
+    <Path extends T[number]>(path: Path, params?: ParseRoute<Path> extends Record<string, never> ? undefined : ParseRoute<Path>): string;
+};
+export declare function defineLinks<const T extends readonly string[]>(routes: T): LinkFunction<T>;
+export {};

package/dist/runtime/lib/links.js

@@ -0,0 +1,38 @@
+export function defineLinks(routes) {
+    // Validate routes at runtime
+    routes.forEach((route) => {
+        if (typeof route !== "string") {
+            throw new Error(`Invalid route: ${route}. Routes must be strings.`);
+        }
+    });
+    return (path, params) => {
+        if (!routes.includes(path)) {
+            throw new Error(`Invalid route: ${path}`);
+        }
+        if (!params)
+            return path;
+        let result = path;
+        // Replace named parameters
+        for (const [key, value] of Object.entries(params)) {
+            if (key.startsWith("$")) {
+                // Replace each star with its corresponding $ parameter
+                const starIndex = parseInt(key.slice(1));
+                const stars = result.match(/\*/g) || [];
+                if (starIndex >= stars.length) {
+                    throw new Error(`Parameter ${key} has no corresponding * in route`);
+                }
+                // Replace the nth star with the value
+                let count = 0;
+                result = result.replace(/\*/g, (match) => count++ === starIndex ? value : match);
+            }
+            else {
+                // Handle named parameters
+                if (typeof value !== "string") {
+                    throw new Error(`Parameter ${key} must be a string`);
+                }
+                result = result.replace(`:${key}`, value);
+            }
+        }
+        return result;
+    };
+}

package/dist/runtime/lib/realtime/client.d.ts

@@ -0,0 +1,7 @@
+import { type Transport } from "../../client";
+export declare const initRealtimeClient: ({ key, }?: {
+    key?: string;
+}) => Promise<void>;
+export declare const realtimeTransport: ({ key }: {
+    key?: string;
+}) => Transport;

package/dist/runtime/lib/realtime/client.js

@@ -0,0 +1,166 @@
+import { initClient } from "../../client";
+import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
+import { MESSAGE_TYPE } from "./shared";
+const DEFAULT_KEY = "default";
+export const initRealtimeClient = ({ key = DEFAULT_KEY, } = {}) => {
+    const transport = realtimeTransport({ key });
+    return initClient({ transport });
+};
+export const realtimeTransport = ({ key = DEFAULT_KEY }) => (transportContext) => {
+    let ws = null;
+    let isConnected = false;
+    const clientId = crypto.randomUUID();
+    const clientUrl = new URL(window.location.href);
+    const isHttps = clientUrl.protocol === "https:";
+    clientUrl.protocol = "";
+    clientUrl.host = "";
+    const setupWebSocket = () => {
+        if (ws)
+            return;
+        const protocol = isHttps ? "wss" : "ws";
+        ws = new WebSocket(`${protocol}://${window.location.host}/__realtime?` +
+            `key=${encodeURIComponent(key)}&` +
+            `url=${encodeURIComponent(clientUrl.toString())}&` +
+            `clientId=${encodeURIComponent(clientId)}`);
+        ws.binaryType = "arraybuffer";
+        ws.addEventListener("open", () => {
+            isConnected = true;
+        });
+        ws.addEventListener("error", (event) => {
+            console.error("[Realtime] WebSocket error", event);
+        });
+        ws.addEventListener("message", (event) => {
+            const data = new Uint8Array(event.data);
+            const messageType = data[0];
+            if (messageType === MESSAGE_TYPE.RSC_START) {
+                const decoder = new TextDecoder();
+                const rscId = decoder.decode(data.slice(1, 37)); // Extract RSC stream ID
+                const stream = new ReadableStream({
+                    start(controller) {
+                        ws.addEventListener("message", function streamHandler(event) {
+                            const data = new Uint8Array(event.data);
+                            const messageType = data[0];
+                            // Extract the RSC stream ID and verify it matches
+                            const responseId = decoder.decode(data.slice(1, 37));
+                            if (responseId !== rscId) {
+                                return; // Not for this stream
+                            }
+                            const payload = data.slice(37);
+                            if (messageType === MESSAGE_TYPE.RSC_CHUNK) {
+                                controller.enqueue(payload);
+                            }
+                            else if (messageType === MESSAGE_TYPE.RSC_END) {
+                                controller.close();
+                                ws.removeEventListener("message", streamHandler);
+                            }
+                        });
+                    },
+                });
+                const rscPayload = createFromReadableStream(stream, {
+                    callServer: realtimeCallServer,
+                });
+                transportContext.setRscPayload(rscPayload);
+            }
+        });
+        ws.addEventListener("close", () => {
+            console.warn("[Realtime] WebSocket closed, attempting to reconnect...");
+            ws = null;
+            isConnected = false;
+            setTimeout(setupWebSocket, 5000);
+        });
+    };
+    const ensureWs = () => {
+        if (!ws && isConnected) {
+            throw new Error("Inconsistent state: WebSocket is null but marked as connected");
+        }
+        if (!ws || !isConnected) {
+            throw new Error("WebSocket is not connected");
+        }
+        return ws;
+    };
+    const realtimeCallServer = async (id, args) => {
+        try {
+            const socket = ensureWs();
+            const { encodeReply } = await import("react-server-dom-webpack/client.browser");
+            // Note(peterp, 2025-07-02): We need to send the "current URL" per message,
+            // in case the user has enabled client side navigation.
+            const clientUrl = new URL(window.location.href);
+            clientUrl.protocol = "";
+            clientUrl.host = "";
+            const encodedArgs = args != null ? await encodeReply(args) : null;
+            const requestId = crypto.randomUUID();
+            const messageData = JSON.stringify({
+                id,
+                args: encodedArgs,
+                requestId,
+                clientUrl,
+            });
+            const encoder = new TextEncoder();
+            const messageBytes = encoder.encode(messageData);
+            const message = new Uint8Array(messageBytes.length + 1);
+            message[0] = MESSAGE_TYPE.ACTION_REQUEST;
+            message.set(messageBytes, 1);
+            socket.send(message);
+            return new Promise(async (resolve, reject) => {
+                const stream = new ReadableStream({
+                    start(controller) {
+                        const messageHandler = (event) => {
+                            const data = new Uint8Array(event.data);
+                            const messageType = data[0];
+                            // First byte is message type
+                            // Next 36 bytes (or fixed size) should be UUID as requestId
+                            // Remaining bytes are the payload
+                            // Extract the requestId from the message
+                            const decoder = new TextDecoder();
+                            const responseId = decoder.decode(data.slice(1, 37)); // Assuming UUID is 36 chars
+                            // Only process messages meant for this request
+                            if (responseId !== requestId) {
+                                return;
+                            }
+                            // The actual payload starts after the requestId
+                            const payload = data.slice(37);
+                            if (messageType === MESSAGE_TYPE.ACTION_CHUNK) {
+                                controller.enqueue(payload);
+                            }
+                            else if (messageType === MESSAGE_TYPE.ACTION_END) {
+                                controller.close();
+                                socket.removeEventListener("message", messageHandler);
+                            }
+                            else if (messageType === MESSAGE_TYPE.ACTION_ERROR) {
+                                const errorJson = decoder.decode(payload);
+                                let errorMsg = "Unknown error";
+                                try {
+                                    const errorObj = JSON.parse(errorJson);
+                                    errorMsg = errorObj.error || errorMsg;
+                                }
+                                catch (e) {
+                                    // Use default error message
+                                }
+                                controller.error(new Error(errorMsg));
+                                socket.removeEventListener("message", messageHandler);
+                            }
+                        };
+                        socket.addEventListener("message", messageHandler);
+                    },
+                });
+                const rscPayload = createFromReadableStream(stream, {
+                    callServer: realtimeCallServer,
+                });
+                transportContext.setRscPayload(rscPayload);
+                try {
+                    const result = await rscPayload;
+                    resolve(result.actionResult);
+                }
+                catch (rscPayloadError) {
+                    reject(rscPayloadError);
+                }
+            });
+        }
+        catch (e) {
+            console.error("[Realtime] Error calling server", e);
+            return null;
+        }
+    };
+    setupWebSocket();
+    return realtimeCallServer;
+};

package/dist/runtime/lib/realtime/constants.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_REALTIME_KEY = "default";

package/dist/runtime/lib/realtime/constants.js

@@ -0,0 +1 @@
+export const DEFAULT_REALTIME_KEY = "default";

package/dist/runtime/lib/realtime/durableObject.d.ts

@@ -0,0 +1,29 @@
+import { DurableObject } from "cloudflare:workers";
+interface ClientInfo {
+    url: string;
+    clientId: string;
+    cookieHeaders: string;
+}
+export declare class RealtimeDurableObject extends DurableObject {
+    state: DurableObjectState;
+    env: Env;
+    storage: DurableObjectStorage;
+    clientInfoCache: Map<string, ClientInfo>;
+    constructor(state: DurableObjectState, env: Env);
+    fetch(request: Request): Promise<Response>;
+    private createClientInfo;
+    private storeClientInfo;
+    private getClientInfo;
+    private handleWebSocket;
+    webSocketMessage(ws: WebSocket, data: ArrayBuffer): Promise<void>;
+    private streamResponse;
+    private handleAction;
+    private determineSockets;
+    render({ include, exclude, }?: {
+        include?: string[];
+        exclude?: string[];
+    }): Promise<void>;
+    private removeClientInfo;
+    webSocketClose(ws: WebSocket): Promise<void>;
+}
+export {};

package/dist/runtime/lib/realtime/durableObject.js

@@ -0,0 +1,187 @@
+import { DurableObject } from "cloudflare:workers";
+import { MESSAGE_TYPE } from "./shared";
+import { validateUpgradeRequest } from "./validateUpgradeRequest";
+export class RealtimeDurableObject extends DurableObject {
+    constructor(state, env) {
+        super(state, env);
+        this.state = state;
+        this.env = env;
+        this.storage = state.storage;
+        this.clientInfoCache = new Map();
+    }
+    async fetch(request) {
+        const validation = validateUpgradeRequest(request);
+        if (!validation.valid) {
+            return validation.response;
+        }
+        const url = new URL(request.url);
+        const clientInfo = this.createClientInfo(url, request);
+        return this.handleWebSocket(request, clientInfo);
+    }
+    createClientInfo(url, request) {
+        return {
+            url: url.searchParams.get("url"),
+            clientId: url.searchParams.get("clientId"),
+            cookieHeaders: request.headers.get("Cookie") || "",
+        };
+    }
+    async storeClientInfo(clientInfo) {
+        this.clientInfoCache.set(clientInfo.clientId, clientInfo);
+        await this.storage.put(`client:${clientInfo.clientId}`, clientInfo);
+    }
+    async getClientInfo(clientId) {
+        const cachedInfo = this.clientInfoCache.get(clientId);
+        if (cachedInfo) {
+            return cachedInfo;
+        }
+        const clientInfo = await this.storage.get(`client:${clientId}`);
+        if (!clientInfo) {
+            throw new Error(`Client info not found for clientId: ${clientId}`);
+        }
+        this.clientInfoCache.set(clientId, clientInfo);
+        return clientInfo;
+    }
+    async handleWebSocket(request, clientInfo) {
+        const { 0: client, 1: server } = new WebSocketPair();
+        await this.storeClientInfo(clientInfo);
+        server.serializeAttachment(clientInfo.clientId);
+        this.state.acceptWebSocket(server);
+        return new Response(null, { status: 101, webSocket: client });
+    }
+    async webSocketMessage(ws, data) {
+        const clientId = ws.deserializeAttachment();
+        const clientInfo = await this.getClientInfo(clientId);
+        const message = new Uint8Array(data);
+        const messageType = message[0];
+        if (messageType === MESSAGE_TYPE.ACTION_REQUEST) {
+            const decoder = new TextDecoder();
+            const jsonData = decoder.decode(message.slice(1));
+            const { id, args, requestId, clientUrl } = JSON.parse(jsonData);
+            try {
+                await this.handleAction(ws, id, args, clientInfo, requestId, clientUrl);
+            }
+            catch (error) {
+                const encoder = new TextEncoder();
+                const requestIdBytes = encoder.encode(requestId);
+                const errorData = JSON.stringify({
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                const errorBytes = encoder.encode(errorData);
+                const errorResponse = new Uint8Array(1 + requestIdBytes.length + errorBytes.length);
+                errorResponse[0] = MESSAGE_TYPE.ACTION_ERROR;
+                errorResponse.set(requestIdBytes, 1);
+                errorResponse.set(errorBytes, 1 + requestIdBytes.length);
+                ws.send(errorResponse);
+            }
+        }
+    }
+    async streamResponse(response, ws, messageTypes, streamId) {
+        const reader = response.body.getReader();
+        const encoder = new TextEncoder();
+        const streamIdBytes = encoder.encode(streamId);
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    const endMessage = new Uint8Array(1 + streamIdBytes.length);
+                    endMessage[0] = messageTypes.end;
+                    endMessage.set(streamIdBytes, 1);
+                    ws.send(endMessage);
+                    break;
+                }
+                const chunkMessage = new Uint8Array(1 + streamIdBytes.length + value.length);
+                chunkMessage[0] = messageTypes.chunk;
+                chunkMessage.set(streamIdBytes, 1);
+                chunkMessage.set(value, 1 + streamIdBytes.length);
+                ws.send(chunkMessage);
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    async handleAction(ws, id, args, clientInfo, requestId, clientUrl) {
+        const url = new URL(clientUrl);
+        url.searchParams.set("__rsc", "");
+        if (id != null) {
+            url.searchParams.set("__rsc_action_id", id);
+        }
+        const response = await fetch(url.toString(), {
+            method: "POST",
+            body: args,
+            headers: {
+                "Content-Type": "application/json",
+                Cookie: clientInfo.cookieHeaders,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Action failed: ${response.statusText}`);
+        }
+        this.render({
+            exclude: [clientInfo.clientId],
+        });
+        await this.streamResponse(response, ws, {
+            chunk: MESSAGE_TYPE.ACTION_CHUNK,
+            end: MESSAGE_TYPE.ACTION_END,
+        }, requestId);
+    }
+    async determineSockets({ include = [], exclude = [], } = {}) {
+        const sockets = Array.from(this.state.getWebSockets());
+        const includeSet = include.length > 0 ? new Set(include) : null;
+        const excludeSet = exclude.length > 0 ? new Set(exclude) : null;
+        const results = [];
+        for (const socket of sockets) {
+            const clientId = socket.deserializeAttachment();
+            if (excludeSet?.has(clientId)) {
+                continue;
+            }
+            if (includeSet && !includeSet.has(clientId)) {
+                continue;
+            }
+            const clientInfo = await this.getClientInfo(clientId);
+            results.push({ socket, clientInfo });
+        }
+        return results;
+    }
+    async render({ include, exclude, } = {}) {
+        const sockets = await this.determineSockets({ include, exclude });
+        if (sockets.length === 0)
+            return;
+        await Promise.all(sockets.map(async ({ socket, clientInfo }) => {
+            try {
+                const url = new URL(clientInfo.url);
+                url.searchParams.set("__rsc", "true");
+                const response = await fetch(url.toString(), {
+                    headers: {
+                        "Content-Type": "application/json",
+                        Cookie: clientInfo.cookieHeaders,
+                    },
+                });
+                if (!response.ok) {
+                    console.error(`Failed to fetch RSC update: ${response.statusText}`);
+                    return;
+                }
+                const rscId = crypto.randomUUID();
+                const startMessage = new Uint8Array(1 + 36);
+                startMessage[0] = MESSAGE_TYPE.RSC_START;
+                startMessage.set(new TextEncoder().encode(rscId), 1);
+                socket.send(startMessage);
+                await this.streamResponse(response, socket, {
+                    chunk: MESSAGE_TYPE.RSC_CHUNK,
+                    end: MESSAGE_TYPE.RSC_END,
+                }, rscId);
+            }
+            catch (err) {
+                console.error("Failed to process socket:", err);
+            }
+        }));
+    }
+    async removeClientInfo(clientId) {
+        this.clientInfoCache.delete(clientId);
+        await this.storage.delete(`client:${clientId}`);
+    }
+    async webSocketClose(ws) {
+        const clientId = ws.deserializeAttachment();
+        await this.removeClientInfo(clientId);
+    }
+}

package/dist/runtime/lib/realtime/renderRealtimeClients.d.ts

@@ -0,0 +1,7 @@
+import { RealtimeDurableObject } from "./durableObject";
+export declare const renderRealtimeClients: ({ durableObjectNamespace, key, include, exclude, }: {
+    durableObjectNamespace: DurableObjectNamespace<RealtimeDurableObject>;
+    key?: string;
+    include?: string[];
+    exclude?: string[];
+}) => Promise<void>;

package/dist/runtime/lib/realtime/renderRealtimeClients.js

@@ -0,0 +1,6 @@
+import { DEFAULT_REALTIME_KEY } from "./constants";
+export const renderRealtimeClients = async ({ durableObjectNamespace, key = DEFAULT_REALTIME_KEY, include, exclude, }) => {
+    const id = durableObjectNamespace.idFromName(key);
+    const durableObject = durableObjectNamespace.get(id);
+    await durableObject.render({ include, exclude });
+};

package/dist/runtime/lib/realtime/shared.d.ts

@@ -0,0 +1,10 @@
+export declare const MESSAGE_TYPE: {
+    readonly RSC_START: 0;
+    readonly RSC_CHUNK: 1;
+    readonly RSC_END: 2;
+    readonly ACTION_REQUEST: 3;
+    readonly ACTION_RESPONSE: 4;
+    readonly ACTION_ERROR: 5;
+    readonly ACTION_CHUNK: 6;
+    readonly ACTION_END: 7;
+};

package/dist/runtime/lib/realtime/shared.js

@@ -0,0 +1,10 @@
+export const MESSAGE_TYPE = {
+    RSC_START: 0,
+    RSC_CHUNK: 1,
+    RSC_END: 2,
+    ACTION_REQUEST: 3,
+    ACTION_RESPONSE: 4,
+    ACTION_ERROR: 5,
+    ACTION_CHUNK: 6,
+    ACTION_END: 7,
+};

package/dist/runtime/lib/realtime/validateUpgradeRequest.d.ts

@@ -0,0 +1,6 @@
+export declare const validateUpgradeRequest: (request: Request) => {
+    valid: false;
+    response: Response;
+} | {
+    valid: true;
+};

package/dist/runtime/lib/realtime/validateUpgradeRequest.js

@@ -0,0 +1,29 @@
+export const validateUpgradeRequest = (request) => {
+    if (request.headers.get("Upgrade") !== "websocket") {
+        return {
+            valid: false,
+            response: new Response("Expected WebSocket", { status: 400 }),
+        };
+    }
+    const requestOrigin = request.headers.get("Origin");
+    if (!requestOrigin) {
+        return {
+            valid: false,
+            response: new Response("Invalid origin", { status: 403 }),
+        };
+    }
+    const requestOriginUrl = new URL(requestOrigin);
+    const url = new URL(request.url);
+    // context(justinvdm, 19 Mar 2025): Origin header doesnt include port, yet
+    // the request url does for non-standard ports.
+    if (requestOriginUrl.protocol === url.protocol &&
+        requestOriginUrl.hostname === url.hostname) {
+        return {
+            valid: true,
+        };
+    }
+    return {
+        valid: false,
+        response: new Response("Invalid origin", { status: 403 }),
+    };
+};

package/dist/runtime/lib/realtime/worker.d.ts

@@ -0,0 +1,3 @@
+import type { RealtimeDurableObject } from "./durableObject";
+export { renderRealtimeClients } from "./renderRealtimeClients";
+export declare const realtimeRoute: (getDurableObjectNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<RealtimeDurableObject>) => import("../router").RouteDefinition<import("../../requestInfo/types").RequestInfo<any, import("../../requestInfo/types").DefaultAppContext>>;

package/dist/runtime/lib/realtime/worker.js

@@ -0,0 +1,16 @@
+import { route } from "../../entries/router";
+import { validateUpgradeRequest } from "./validateUpgradeRequest";
+import { DEFAULT_REALTIME_KEY } from "./constants";
+import { env } from "cloudflare:workers";
+export { renderRealtimeClients } from "./renderRealtimeClients";
+export const realtimeRoute = (getDurableObjectNamespace) => route("/__realtime", async function ({ request }) {
+    const validation = validateUpgradeRequest(request);
+    if (!validation.valid) {
+        return validation.response;
+    }
+    const url = new URL(request.url);
+    const key = url.searchParams.get("key") || DEFAULT_REALTIME_KEY;
+    const id = getDurableObjectNamespace(env).idFromName(key);
+    const durableObject = getDurableObjectNamespace(env).get(id);
+    return durableObject.fetch(request);
+});

package/dist/runtime/lib/router.d.ts

@@ -0,0 +1,56 @@
+import React from "react";
+import { RequestInfo } from "../requestInfo/types";
+import type { Kysely } from "kysely";
+export type DocumentProps<T extends RequestInfo = RequestInfo> = T & {
+    children: React.ReactNode;
+};
+export type LayoutProps<T extends RequestInfo = RequestInfo> = {
+    children?: React.ReactNode;
+    requestInfo?: T;
+};
+export type RwContext = {
+    nonce: string;
+    Document: React.FC<DocumentProps<any>>;
+    rscPayload: boolean;
+    ssr: boolean;
+    layouts?: React.FC<LayoutProps<any>>[];
+    databases: Map<string, Kysely<any>>;
+};
+export type RouteMiddleware<T extends RequestInfo = RequestInfo> = (requestInfo: T) => Response | Promise<Response> | void | Promise<void> | Promise<Response | void>;
+type RouteFunction<T extends RequestInfo = RequestInfo> = (requestInfo: T) => Response | Promise<Response>;
+type MaybePromise<T> = T | Promise<T>;
+type RouteComponent<T extends RequestInfo = RequestInfo> = (requestInfo: T) => MaybePromise<React.JSX.Element | Response>;
+type RouteHandler<T extends RequestInfo = RequestInfo> = RouteFunction<T> | RouteComponent<T> | [...RouteMiddleware<T>[], RouteFunction<T> | RouteComponent<T>];
+export type Route<T extends RequestInfo = RequestInfo> = RouteMiddleware<T> | RouteDefinition<T> | Array<Route<T>>;
+export type RouteDefinition<T extends RequestInfo = RequestInfo> = {
+    path: string;
+    handler: RouteHandler<T>;
+    layouts?: React.FC<LayoutProps<T>>[];
+};
+export declare function matchPath<T extends RequestInfo = RequestInfo>(routePath: string, requestPath: string): T["params"] | null;
+export declare function defineRoutes<T extends RequestInfo = RequestInfo>(routes: Route<T>[]): {
+    routes: Route<T>[];
+    handle: ({ request, renderPage, getRequestInfo, onError, runWithRequestInfoOverrides, }: {
+        request: Request;
+        renderPage: (requestInfo: T, Page: React.FC, onError: (error: unknown) => void) => Promise<Response>;
+        getRequestInfo: () => T;
+        onError: (error: unknown) => void;
+        runWithRequestInfoOverrides: <Result>(overrides: Partial<T>, fn: () => Promise<Result>) => Promise<Result>;
+    }) => Response | Promise<Response>;
+};
+export declare function route<T extends RequestInfo = RequestInfo>(path: string, handler: RouteHandler<T>): RouteDefinition<T>;
+export declare function index<T extends RequestInfo = RequestInfo>(handler: RouteHandler<T>): RouteDefinition<T>;
+export declare function prefix<T extends RequestInfo = RequestInfo>(prefixPath: string, routes: Route<T>[]): Route<T>[];
+export declare function layout<T extends RequestInfo = RequestInfo>(LayoutComponent: React.FC<LayoutProps<T>>, routes: Route<T>[]): Route<T>[];
+export declare function render<T extends RequestInfo = RequestInfo>(Document: React.FC<DocumentProps<T>>, routes: Route<T>[], 
+/**
+ * @param options - Configuration options for rendering.
+ * @param options.rscPayload - Toggle the RSC payload that's appended to the Document. Disabling this will mean that interactivity no longer works.
+ * @param options.ssr - Disable sever side rendering for all these routes. This only allow client side rendering`, which requires `rscPayload` to be enabled.
+ */
+options?: {
+    rscPayload?: boolean;
+    ssr?: boolean;
+}): Route<T>[];
+export declare const isClientReference: (Component: React.FC<any>) => boolean;
+export {};