rwsdk 0.1.0-alpha.9 → 0.1.0

package/dist/runtime/client.d.ts

@@ -1,4 +1,5 @@
 import { type CallServerCallback } from "react-server-dom-webpack/client.browser";
+import { type HydrationOptions } from "react-dom/client";
 export type ActionResponse<Result> = {
     node: React.ReactNode;
     actionResult: Result;
@@ -9,7 +10,8 @@ type TransportContext = {
 export type Transport = (context: TransportContext) => CallServerCallback;
 export type CreateCallServer = (context: TransportContext) => <Result>(id: null | string, args: null | unknown[]) => Promise<Result>;
 export declare const fetchTransport: Transport;
-export declare const initClient: ({ transport, }?: {
+export declare const initClient: ({ transport, hydrateRootOptions, }?: {
     transport?: Transport;
+    hydrateRootOptions?: HydrationOptions;
 }) => Promise<void>;
 export {};

package/dist/runtime/client.js

@@ -21,7 +21,9 @@ export const fetchTransport = (transportContext) => {
     };
     return fetchCallServer;
 };
-export const initClient = async ({ transport = fetchTransport, } = {}) => {
+export const initClient = async ({ transport = fetchTransport, hydrateRootOptions, } = {}) => {
+    const React = await import("react");
+    const { hydrateRoot } = await import("react-dom/client");
     const transportContext = {
         setRscPayload: () => { },
     };
@@ -37,25 +39,27 @@ export const initClient = async ({ transport = fetchTransport, } = {}) => {
         callServer,
         upgradeToRealtime,
     };
-    const rootEl = document.getElementById("root");
+    const rootEl = document.getElementById("hydrate-root");
     if (!rootEl) {
-        throw new Error('no element with id "root"');
+        throw new Error('no element with id "hydrate-root"');
     }
-    const React = await import("react");
-    const { hydrateRoot } = await import("react-dom/client");
-    const { createFromReadableStream } = await import("react-server-dom-webpack/client.browser");
-    const { rscStream } = await import("rsc-html-stream/client");
     let rscPayload;
-    rscPayload ??= createFromReadableStream(rscStream, {
-        callServer,
-    });
+    // context(justinvdm, 18 Jun 2025): We inject the RSC payload
+    // unless render(Document, [...], { rscPayload: false }) was used.
+    if (globalThis.__FLIGHT_DATA) {
+        const { createFromReadableStream } = await import("react-server-dom-webpack/client.browser");
+        const { rscStream } = await import("rsc-html-stream/client");
+        rscPayload = createFromReadableStream(rscStream, {
+            callServer,
+        });
+    }
     function Content() {
         const [streamData, setStreamData] = React.useState(rscPayload);
         const [_isPending, startTransition] = React.useTransition();
         transportContext.setRscPayload = (v) => startTransition(() => setStreamData(v));
         return _jsx(_Fragment, { children: React.use(streamData).node });
     }
-    hydrateRoot(rootEl, _jsx(Content, {}));
+    hydrateRoot(rootEl, _jsx(Content, {}), hydrateRootOptions);
     if (import.meta.hot) {
         import.meta.hot.on("rsc:update", (e) => {
             console.log("[rwsdk] hot update", e.file);

package/dist/runtime/clientNavigation.d.ts

@@ -0,0 +1,3 @@
+export declare function initClientNavigation(opts?: {
+    onNavigate: () => void;
+}): void;

package/dist/runtime/clientNavigation.js

@@ -0,0 +1,43 @@
+export function initClientNavigation(opts = {
+    onNavigate: async function onNavigate() {
+        // @ts-expect-error
+        await globalThis.__rsc_callServer();
+    },
+}) {
+    // Intercept all anchor tag clicks
+    document.addEventListener("click", async function handleClickEvent(event) {
+        // should this only work for left click?
+        if (event.button !== 0) {
+            return;
+        }
+        if (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) {
+            return;
+        }
+        const target = event.target;
+        const link = target.closest("a");
+        if (!link) {
+            return;
+        }
+        const href = link.getAttribute("href");
+        if (!href) {
+            return;
+        }
+        // Skip if target="_blank" or similar
+        if (link.target && link.target !== "_self") {
+            return;
+        }
+        // Skip if download attribute
+        if (link.hasAttribute("download")) {
+            return;
+        }
+        // Prevent default navigation
+        event.preventDefault();
+        // push this to the history stack.
+        window.history.pushState({ path: href }, "", window.location.origin + href);
+        await opts.onNavigate();
+    }, true);
+    // Handle browser back/forward buttons
+    window.addEventListener("popstate", async function handlePopState() {
+        await opts.onNavigate();
+    });
+}

package/dist/runtime/entries/client.d.ts

@@ -1,3 +1,4 @@
 export * from "../client";
 export * from "../register/client";
 export * from "../lib/streams/consumeEventStream";
+export * from "../clientNavigation";

package/dist/runtime/entries/client.js

@@ -1,3 +1,4 @@
 export * from "../client";
 export * from "../register/client";
 export * from "../lib/streams/consumeEventStream";
+export * from "../clientNavigation";

package/dist/runtime/entries/worker.d.ts

@@ -5,3 +5,5 @@ export * from "../script";
 export * from "../lib/utils";
 export * from "../requestInfo/types";
 export * from "../requestInfo/worker";
+export * from "../render/renderToString";
+export * from "../render/renderToStream";

package/dist/runtime/entries/worker.js

@@ -5,3 +5,5 @@ export * from "../script";
 export * from "../lib/utils";
 export * from "../requestInfo/types";
 export * from "../requestInfo/worker";
+export * from "../render/renderToString";
+export * from "../render/renderToStream";

package/dist/runtime/imports/ClientOnly.d.ts

@@ -0,0 +1,3 @@
+export declare const ClientOnly: ({ children }: {
+    children: React.ReactNode;
+}) => import("react").ReactNode;

package/dist/runtime/imports/ClientOnly.js

@@ -0,0 +1,8 @@
+import { useEffect, useState } from "react";
+export const ClientOnly = ({ children }) => {
+    const [didUpdate, setDidUpdate] = useState(false);
+    useEffect(() => {
+        setDidUpdate(true);
+    }, []);
+    return didUpdate ? children : null;
+};

package/dist/runtime/imports/NoSSRStub.d.ts

@@ -0,0 +1 @@
+export declare const NoSSRStub: () => import("react/jsx-runtime").JSX.Element;

package/dist/runtime/imports/NoSSRStub.js

@@ -0,0 +1,4 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ClientOnly } from "./ClientOnly";
+export const NoSSRStub = () => _jsx(ClientOnly, { children: null });

package/dist/runtime/imports/client.js

@@ -1,3 +1,4 @@
+import React from "react";
 import memoize from "lodash/memoize";
 export const loadModule = memoize(async (id) => {
     if (import.meta.env.DEV && !process.env.PREVIEW) {
@@ -15,6 +16,18 @@ export const loadModule = memoize(async (id) => {
 // context(justinvdm, 2 Dec 2024): re memoize(): React relies on the same promise instance being returned for the same id
 export const clientWebpackRequire = memoize(async (id) => {
     const [file, name] = id.split("#");
-    const module = await loadModule(file);
-    return { [id]: module[name] };
+    const promisedModule = loadModule(file);
+    const promisedComponent = promisedModule.then((module) => module[name]);
+    const didSSR = globalThis.__RWSDK_CONTEXT?.rw?.ssr;
+    if (didSSR) {
+        const awaitedComponent = await promisedComponent;
+        return { [id]: awaitedComponent };
+    }
+    const { ClientOnly } = await import("./ClientOnly");
+    const promisedDefault = promisedComponent.then((Component) => ({
+        default: Component,
+    }));
+    const Lazy = React.lazy(() => promisedDefault);
+    const Wrapped = () => React.createElement(ClientOnly, null, React.createElement(Lazy));
+    return { [id]: Wrapped };
 });

package/dist/runtime/imports/worker.d.ts

@@ -1,5 +1,5 @@
 export declare const loadServerModule: ((id: string) => Promise<any>) & import("lodash").MemoizedFunction;
 export declare const getServerModuleExport: (id: string) => Promise<any>;
-export declare const serverWebpackRequire: ((id: string) => Promise<{
+export declare const ssrWebpackRequire: ((id: string) => Promise<{
     [x: string]: any;
 }>) & import("lodash").MemoizedFunction;

package/dist/runtime/imports/worker.js

@@ -1,4 +1,6 @@
 import memoize from "lodash/memoize";
+import { requestInfo } from "../requestInfo/worker";
+import { ssrWebpackRequire as baseSsrWebpackRequire } from "rwsdk/__ssr_bridge";
 export const loadServerModule = memoize(async (id) => {
     const { useServerLookup } = await import("virtual:use-server-lookup");
     const moduleFn = useServerLookup[id];
@@ -12,9 +14,9 @@ export const getServerModuleExport = async (id) => {
     const module = await loadServerModule(file);
     return module[name];
 };
-// context(justinvdm, 2 Dec 2024): re memoize(): React relies on the same promise instance being returned for the same id
-export const serverWebpackRequire = memoize(async (id) => {
-    const [file, name] = id.split("#");
-    const module = await loadServerModule(file);
-    return { [id]: module[name] };
+export const ssrWebpackRequire = memoize(async (id) => {
+    if (!requestInfo.rw.ssr) {
+        return { [id]: () => null };
+    }
+    return baseSsrWebpackRequire(id);
 });

package/dist/runtime/lib/db/DOWorkerDialect.d.ts

@@ -0,0 +1,29 @@
+import { SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, Driver, DatabaseConnection } from "kysely";
+export declare class DOWorkerDialect {
+    config: {
+        stub: any;
+    };
+    constructor(config: {
+        stub: any;
+    });
+    createAdapter(): SqliteAdapter;
+    createDriver(): DOWorkerDriver;
+    createQueryCompiler(): SqliteQueryCompiler;
+    createIntrospector(db: any): SqliteIntrospector;
+}
+declare class DOWorkerDriver implements Driver {
+    config: {
+        stub: any;
+    };
+    constructor(config: {
+        stub: any;
+    });
+    init(): Promise<void>;
+    acquireConnection(): Promise<DatabaseConnection>;
+    beginTransaction(conn: any): Promise<any>;
+    commitTransaction(conn: any): Promise<any>;
+    rollbackTransaction(conn: any): Promise<any>;
+    releaseConnection(_conn: any): Promise<void>;
+    destroy(): Promise<void>;
+}
+export {};

package/dist/runtime/lib/db/DOWorkerDialect.js

@@ -0,0 +1,66 @@
+import debug from "../debug";
+import { SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, } from "kysely";
+const log = debug("sdk:db:do-worker-dialect");
+export class DOWorkerDialect {
+    constructor(config) {
+        this.config = config;
+    }
+    createAdapter() {
+        return new SqliteAdapter();
+    }
+    createDriver() {
+        return new DOWorkerDriver(this.config);
+    }
+    createQueryCompiler() {
+        return new SqliteQueryCompiler();
+    }
+    createIntrospector(db) {
+        return new SqliteIntrospector(db);
+    }
+}
+class DOWorkerDriver {
+    constructor(config) {
+        this.config = config;
+    }
+    async init() { }
+    async acquireConnection() {
+        return new DOWorkerConnection(this.config.stub.kyselyExecuteQuery);
+    }
+    async beginTransaction(conn) {
+        return await conn.beginTransaction();
+    }
+    async commitTransaction(conn) {
+        return await conn.commitTransaction();
+    }
+    async rollbackTransaction(conn) {
+        return await conn.rollbackTransaction();
+    }
+    async releaseConnection(_conn) { }
+    async destroy() { }
+}
+class DOWorkerConnection {
+    constructor(executeQuery) {
+        this._executeQuery = executeQuery;
+    }
+    async executeQuery(compiledQuery) {
+        log("Forwarding query to Durable Object: %s", compiledQuery.sql);
+        // Call the DO's kyselyExecuteQuery method
+        const result = await this._executeQuery({
+            sql: compiledQuery.sql,
+            parameters: compiledQuery.parameters,
+        });
+        return result;
+    }
+    async beginTransaction() {
+        throw new Error("Transactions are not supported yet.");
+    }
+    async commitTransaction() {
+        throw new Error("Transactions are not supported yet.");
+    }
+    async rollbackTransaction() {
+        throw new Error("Transactions are not supported yet.");
+    }
+    async *streamQuery(_compiledQuery, _chunkSize) {
+        throw new Error("DO Driver does not support streaming");
+    }
+}

package/dist/runtime/lib/db/SqliteDurableObject.d.ts

@@ -0,0 +1,14 @@
+import { DurableObject } from "cloudflare:workers";
+import { Kysely, QueryResult } from "kysely";
+export declare class SqliteDurableObject<T = any> extends DurableObject {
+    migrations: Record<string, any>;
+    kysely: Kysely<T>;
+    private initialized;
+    private migrationTableName;
+    constructor(ctx: DurableObjectState, env: any, migrations: Record<string, any>, migrationTableName?: string);
+    private initialize;
+    kyselyExecuteQuery<R>(compiledQuery: {
+        sql: string;
+        parameters: readonly unknown[];
+    }): Promise<QueryResult<R>>;
+}

package/dist/runtime/lib/db/SqliteDurableObject.js

@@ -0,0 +1,42 @@
+import { DODialect } from "kysely-do";
+import { DurableObject } from "cloudflare:workers";
+import { Kysely } from "kysely";
+import { createMigrator } from "./index.js";
+import debug from "../debug.js";
+const log = debug("sdk:do-db");
+// Base class for Durable Objects that need Kysely database access
+export class SqliteDurableObject extends DurableObject {
+    constructor(ctx, env, migrations, migrationTableName = "__migrations") {
+        super(ctx, env);
+        this.initialized = false;
+        this.migrations = migrations;
+        this.migrationTableName = migrationTableName;
+        this.kysely = new Kysely({
+            dialect: new DODialect({ ctx }),
+        });
+    }
+    async initialize() {
+        if (this.initialized) {
+            log("Database already initialized, skipping");
+            return;
+        }
+        log("Initializing Durable Object database");
+        const migrator = createMigrator(this.kysely, this.migrations, this.migrationTableName);
+        await migrator.migrateToLatest();
+        this.initialized = true;
+        log("Database initialization complete");
+    }
+    // RPC method for executing queries - must be on prototype for RPC to work
+    async kyselyExecuteQuery(compiledQuery) {
+        await this.initialize();
+        log("Executing SQL: %s with params: %o", compiledQuery.sql, compiledQuery.parameters);
+        // Forward to the internal Kysely database
+        const result = await this.kysely.executeQuery({
+            sql: compiledQuery.sql,
+            parameters: compiledQuery.parameters,
+            query: {},
+            queryId: {},
+        });
+        return result;
+    }
+}

package/dist/runtime/lib/db/create.d.ts

@@ -0,0 +1,3 @@
+import { Kysely } from "kysely";
+export declare function createDurableObjectDb<T>(durableObjectBinding: any, name?: string): Kysely<T>;
+export declare function createDb<T>(durableObjectBinding: any, name?: string): Kysely<T>;

package/dist/runtime/lib/db/create.js

@@ -0,0 +1,36 @@
+import { Kysely } from "kysely";
+import { requestInfo } from "../../requestInfo/worker.js";
+import { DOWorkerDialect } from "./SqliteDurableObject.js";
+export function createDurableObjectDb(durableObjectBinding, name = "main") {
+    const durableObjectId = durableObjectBinding.idFromName(name);
+    const stub = durableObjectBinding.get(durableObjectId);
+    return new Kysely({
+        dialect: new DOWorkerDialect({ stub }),
+    });
+}
+export function createDb(durableObjectBinding, name = "main") {
+    // Create a cache key from the binding and name
+    const cacheKey = `${durableObjectBinding}_${name}`;
+    // Return a proxy that lazily creates and caches the database instance
+    return new Proxy({}, {
+        get(target, prop, receiver) {
+            if (!requestInfo.rw.databases) {
+                requestInfo.rw.databases = new Map();
+            }
+            // Check if we have a cached instance
+            let db = requestInfo.rw.databases.get(cacheKey);
+            if (!db) {
+                // Create the database instance and cache it
+                db = createDurableObjectDb(durableObjectBinding, name);
+                requestInfo.rw.databases.set(cacheKey, db);
+            }
+            // Forward the property access to the actual database instance
+            const value = db[prop];
+            // If it's a function, bind it to the database instance
+            if (typeof value === "function") {
+                return value.bind(db);
+            }
+            return value;
+        },
+    });
+}

package/dist/runtime/lib/db/createDb.d.ts

@@ -0,0 +1,2 @@
+import { Kysely } from "kysely";
+export declare function createDb<T>(durableObjectBinding: any, name?: string): Kysely<T>;

package/dist/runtime/lib/db/createDb.js

@@ -0,0 +1,27 @@
+import { Kysely } from "kysely";
+import { requestInfo } from "../../requestInfo/worker.js";
+import { DOWorkerDialect } from "./DOWorkerDialect.js";
+const createDurableObjectDb = (durableObjectBinding, name = "main") => {
+    const durableObjectId = durableObjectBinding.idFromName(name);
+    const stub = durableObjectBinding.get(durableObjectId);
+    return new Kysely({
+        dialect: new DOWorkerDialect({ stub }),
+    });
+};
+export function createDb(durableObjectBinding, name = "main") {
+    const cacheKey = `${durableObjectBinding}_${name}`;
+    return new Proxy({}, {
+        get(target, prop, receiver) {
+            let db = requestInfo.rw.databases.get(cacheKey);
+            if (!db) {
+                db = createDurableObjectDb(durableObjectBinding, name);
+                requestInfo.rw.databases.set(cacheKey, db);
+            }
+            const value = db[prop];
+            if (typeof value === "function") {
+                return value.bind(db);
+            }
+            return value;
+        },
+    });
+}

package/dist/runtime/lib/db/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./migrations.js";
+export * from "./SqliteDurableObject.js";
+export * from "./createDb.js";

package/dist/runtime/lib/db/index.js

@@ -0,0 +1,3 @@
+export * from "./migrations.js";
+export * from "./SqliteDurableObject.js";
+export * from "./createDb.js";

package/dist/runtime/lib/db/logger.d.ts

@@ -0,0 +1,2 @@
+declare const debug: (namespace: string) => (...args: any[]) => void;
+export default debug;

package/dist/runtime/lib/db/logger.js

@@ -0,0 +1,41 @@
+// 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;
+    // Split by comma and check each pattern
+    const patterns = debug.split(",").map((p) => p.trim());
+    for (const pattern of patterns) {
+        // Handle exclusions (patterns starting with -)
+        if (pattern.startsWith("-")) {
+            const excludePattern = pattern.slice(1);
+            if (matchesPattern(namespace, excludePattern)) {
+                return false;
+            }
+            continue;
+        }
+        // Check if namespace matches this pattern
+        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);
+}
+// Factory function that creates a debugger for a given namespace
+const debug = (namespace) => {
+    return (...args) => {
+        if (isEnabled(namespace)) {
+            console.log(`[${namespace}]`, ...args);
+        }
+    };
+};
+// Export the factory function as default (like the real debug package)
+export default debug;

package/dist/runtime/lib/db/migrations.d.ts

@@ -0,0 +1,23 @@
+import { Kysely, Migration, Migrator, MigrationProvider } from "kysely";
+/**
+ * A custom MigrationProvider that works with in-memory migrations
+ * rather than reading from files.
+ */
+export declare class InMemoryMigrationProvider implements MigrationProvider {
+    private migrations;
+    constructor(migrations: Record<string, Migration>);
+    getMigrations(): Promise<Record<string, Migration>>;
+}
+/**
+ * Helper function to create a migrator using Kysely's built-in Migrator.
+ *
+ * @example
+ * ```typescript
+ * const migrator = createMigrator(db, migrations, "__my_migrations");
+ * const result = await migrator.migrateToLatest();
+ * if (result.error) {
+ *   throw new Error(`Migration failed: ${result.error}`);
+ * }
+ * ```
+ */
+export declare function createMigrator(db: Kysely<any>, migrations: Record<string, Migration>, migrationTableName?: string): Migrator;

package/dist/runtime/lib/db/migrations.js

@@ -0,0 +1,34 @@
+import { Migrator } from "kysely";
+/**
+ * A custom MigrationProvider that works with in-memory migrations
+ * rather than reading from files.
+ */
+export class InMemoryMigrationProvider {
+    constructor(migrations) {
+        this.migrations = migrations;
+    }
+    async getMigrations() {
+        return this.migrations;
+    }
+}
+/**
+ * Helper function to create a migrator using Kysely's built-in Migrator.
+ *
+ * @example
+ * ```typescript
+ * const migrator = createMigrator(db, migrations, "__my_migrations");
+ * const result = await migrator.migrateToLatest();
+ * if (result.error) {
+ *   throw new Error(`Migration failed: ${result.error}`);
+ * }
+ * ```
+ */
+export function createMigrator(db, migrations, migrationTableName = "__rwsdk_migrations") {
+    return new Migrator({
+        db,
+        provider: new InMemoryMigrationProvider(migrations),
+        migrationTableName,
+        // Use a custom lock table name based on the migration table name
+        migrationLockTableName: `${migrationTableName}_lock`,
+    });
+}

package/dist/runtime/lib/db/types.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,2 @@
+declare const debug: (namespace: string) => (...args: any[]) => void;
+export default debug;

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/router.d.ts

@@ -1,5 +1,6 @@
 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;
 };
@@ -11,7 +12,9 @@ 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>;
@@ -43,9 +46,11 @@ export declare function render<T extends RequestInfo = RequestInfo>(Document: Re
 /**
  * @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;
+    rscPayload?: boolean;
+    ssr?: boolean;
 }): Route<T>[];
 export declare const isClientReference: (Component: React.FC<any>) => boolean;
 export {};