rwsdk 0.2.0-alpha.0 → 0.2.0-alpha.10

package/dist/lib/smokeTests/browser.mjs

@@ -8,7 +8,7 @@ import puppeteer from "puppeteer-core";
 import { takeScreenshot } from "./artifacts.mjs";
 import { RETRIES } from "./constants.mjs";
 import { $ } from "../$.mjs";
-import { fail } from "./utils.mjs";
+import { fail, withRetries } from "./utils.mjs";
 import { reportSmokeTestResult } from "./reporting.mjs";
 import { updateTestStatus } from "./state.mjs";
 import * as fs from "fs/promises";
@@ -404,7 +404,7 @@ export async function checkUrlSmoke(page, url, isRealtime, bail = false, skipCli
             ? "realtimeClientModuleStyles"
             : "initialClientModuleStyles";
         try {
-            await checkUrlStyles(page, "red");
+            await withRetries(() => checkUrlStyles(page, "red"), "URL styles check");
             updateTestStatus(env, urlStylesKey, "PASSED");
             log(`${phase} URL styles check passed`);
         }
@@ -420,7 +420,7 @@ export async function checkUrlSmoke(page, url, isRealtime, bail = false, skipCli
             }
         }
         try {
-            await checkClientModuleStyles(page, "blue");
+            await withRetries(() => checkClientModuleStyles(page, "blue"), "Client module styles check");
             updateTestStatus(env, clientModuleStylesKey, "PASSED");
             log(`${phase} client module styles check passed`);
         }
@@ -507,7 +507,14 @@ export async function checkUrlSmoke(page, url, isRealtime, bail = false, skipCli
                 await testClientComponentHmr(page, targetDir, phase, environment, bail);
                 // Test style HMR if style tests aren't skipped
                 if (!skipStyleTests) {
-                    await testStyleHMR(page, targetDir);
+                    await withRetries(() => testStyleHMR(page, targetDir), "Style HMR test", async () => {
+                        // This logic runs before each retry of testStyleHMR
+                        const urlStylePath = join(targetDir, "src", "app", "smokeTestUrlStyles.css");
+                        const clientStylePath = join(targetDir, "src", "app", "components", "smokeTestClientStyles.module.css");
+                        // Restore original styles before re-running HMR test
+                        await fs.writeFile(urlStylePath, urlStylesTemplate);
+                        await fs.writeFile(clientStylePath, clientStylesTemplate);
+                    });
                 }
                 else {
                     log("Skipping style HMR test as requested");
@@ -1182,9 +1189,9 @@ async function testStyleHMR(page, targetDir) {
     // Allow time for HMR to kick in
     await new Promise((resolve) => setTimeout(resolve, 5000));
     // Check URL-based stylesheet HMR
-    await checkUrlStyles(page, "green");
+    await withRetries(() => checkUrlStyles(page, "green"), "URL styles HMR check");
     // Check client-module stylesheet HMR
-    await checkClientModuleStyles(page, "green");
+    await withRetries(() => checkClientModuleStyles(page, "green"), "Client module styles HMR check");
     // Restore original styles
     await fs.writeFile(urlStylePath, urlStylesTemplate);
     await fs.writeFile(clientStylePath, clientStylesTemplate);

package/dist/lib/smokeTests/utils.d.mts

@@ -13,3 +13,12 @@ export declare function teardown(): Promise<void>;
  * Formats the path suffix from a custom path
  */
 export declare function formatPathSuffix(customPath?: string): string;
+/**
+ * Wraps an async function with retry logic.
+ * @param fn The async function to execute.
+ * @param description A description of the operation for logging.
+ * @param beforeRetry A function to run before each retry attempt.
+ * @param maxRetries The maximum number of retries.
+ * @param delay The delay between retries in milliseconds.
+ */
+export declare function withRetries<T>(fn: () => Promise<T>, description: string, beforeRetry?: () => Promise<void>, maxRetries?: number, delay?: number): Promise<T>;

package/dist/lib/smokeTests/utils.mjs

@@ -145,3 +145,32 @@ export function formatPathSuffix(customPath) {
     log("Formatted path suffix: %s", suffix);
     return suffix;
 }
+/**
+ * Wraps an async function with retry logic.
+ * @param fn The async function to execute.
+ * @param description A description of the operation for logging.
+ * @param beforeRetry A function to run before each retry attempt.
+ * @param maxRetries The maximum number of retries.
+ * @param delay The delay between retries in milliseconds.
+ */
+export async function withRetries(fn, description, beforeRetry, maxRetries = 5, delay = 2000) {
+    for (let i = 0; i < maxRetries; i++) {
+        try {
+            if (i > 0 && beforeRetry) {
+                log(`Running beforeRetry hook for "${description}"`);
+                await beforeRetry();
+            }
+            return await fn();
+        }
+        catch (error) {
+            log(`Attempt ${i + 1} of ${maxRetries} failed for "${description}": ${error instanceof Error ? error.message : String(error)}`);
+            if (i === maxRetries - 1) {
+                log(`All ${maxRetries} retries failed for "${description}".`);
+                throw error;
+            }
+            log(`Retrying in ${delay}ms...`);
+            await setTimeout(delay);
+        }
+    }
+    throw new Error("Retry loop failed unexpectedly.");
+}

package/dist/runtime/client.js

@@ -77,7 +77,9 @@ export const initClient = async ({ transport = fetchTransport, hydrateRootOption
         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 });
+        return (_jsx(_Fragment, { children: streamData
+                ? React.use(streamData).node
+                : null }));
     }
     hydrateRoot(rootEl, _jsx(Content, {}), {
         onUncaughtError: (error, { componentStack }) => {

package/dist/runtime/clientNavigation.js

@@ -1,3 +1,10 @@
+function saveScrollPosition(x, y) {
+    window.history.replaceState({
+        ...window.history.state,
+        scrollX: x,
+        scrollY: y,
+    }, "", window.location.href);
+}
 export function validateClickEvent(event, target) {
     // should this only work for left click?
     if (event.button !== 0) {
@@ -14,6 +21,9 @@ export function validateClickEvent(event, target) {
     if (!href) {
         return false;
     }
+    if (href.includes("#")) {
+        return false;
+    }
     // Skip if target="_blank" or similar
     if (link.target && link.target !== "_self") {
         return false;
@@ -28,70 +38,16 @@ export function validateClickEvent(event, target) {
     return true;
 }
 export function initClientNavigation(opts = {}) {
-    // Merge user options with defaults
     const options = {
         onNavigate: async function onNavigate() {
             // @ts-expect-error
             await globalThis.__rsc_callServer();
         },
         scrollToTop: true,
-        scrollBehavior: 'instant',
+        scrollBehavior: "instant",
         ...opts,
     };
-    // Prevent browser's automatic scroll restoration for popstate
-    if ('scrollRestoration' in history) {
-        history.scrollRestoration = 'manual';
-    }
-    // Set up scroll behavior management
-    let popStateWasCalled = false;
-    let savedScrollPosition = null;
-    const observer = new MutationObserver(() => {
-        if (popStateWasCalled && savedScrollPosition) {
-            // Restore scroll position for popstate navigation (always instant)
-            window.scrollTo({
-                top: savedScrollPosition.y,
-                left: savedScrollPosition.x,
-                behavior: 'instant',
-            });
-            savedScrollPosition = null;
-        }
-        else if (options.scrollToTop && !popStateWasCalled) {
-            // Scroll to top for anchor click navigation (configurable)
-            window.scrollTo({
-                top: 0,
-                left: 0,
-                behavior: options.scrollBehavior,
-            });
-            // Update the current history entry with the new scroll position (top)
-            // This ensures that if we navigate back and then forward again,
-            // we return to the top position, not some previous scroll position
-            window.history.replaceState({
-                ...window.history.state,
-                scrollX: 0,
-                scrollY: 0
-            }, "", window.location.href);
-        }
-        popStateWasCalled = false;
-    });
-    const handleScrollPopState = (event) => {
-        popStateWasCalled = true;
-        // Save the scroll position that the browser would have restored to
-        const state = event.state;
-        if (state && typeof state === 'object' && 'scrollX' in state && 'scrollY' in state) {
-            savedScrollPosition = { x: state.scrollX, y: state.scrollY };
-        }
-        else {
-            // Fallback: try to get scroll position from browser's session history
-            // This is a best effort since we can't directly access the browser's stored position
-            savedScrollPosition = { x: window.scrollX, y: window.scrollY };
-        }
-    };
-    const main = document.querySelector("main") || document.body;
-    if (main) {
-        window.addEventListener("popstate", handleScrollPopState);
-        observer.observe(main, { childList: true, subtree: true });
-    }
-    // Intercept all anchor tag clicks
+    history.scrollRestoration = "auto";
     document.addEventListener("click", async function handleClickEvent(event) {
         // Prevent default navigation
         if (!validateClickEvent(event, event.target)) {
@@ -101,17 +57,21 @@ export function initClientNavigation(opts = {}) {
         const el = event.target;
         const a = el.closest("a");
         const href = a?.getAttribute("href");
-        // Save current scroll position before navigating
-        window.history.replaceState({
-            path: window.location.pathname,
-            scrollX: window.scrollX,
-            scrollY: window.scrollY
-        }, "", window.location.href);
+        saveScrollPosition(window.scrollX, window.scrollY);
         window.history.pushState({ path: href }, "", window.location.origin + href);
         await options.onNavigate();
+        if (options.scrollToTop && history.scrollRestoration === "auto") {
+            window.scrollTo({
+                top: 0,
+                left: 0,
+                behavior: options.scrollBehavior,
+            });
+            saveScrollPosition(0, 0);
+        }
+        history.scrollRestoration = "auto";
     }, true);
-    // Handle browser back/forward buttons
     window.addEventListener("popstate", async function handlePopState() {
+        saveScrollPosition(window.scrollX, window.scrollY);
         await options.onNavigate();
     });
     // Return a handleResponse function for use with initClient

package/dist/runtime/clientNavigation.test.js

@@ -35,11 +35,10 @@ describe("clientNavigation", () => {
             closest: () => ({ getAttribute: () => undefined }),
         })).toBe(false);
     });
-    it("should not have a target attribute", () => {
+    it("should not include an #hash", () => {
         expect(validateClickEvent(mockEvent, {
             closest: () => ({
-                target: "_blank",
-                getAttribute: () => "/test",
+                getAttribute: () => "/test#hash",
                 hasAttribute: () => false,
             }),
         })).toBe(false);

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

@@ -1,23 +1,21 @@
-import { SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, Driver, DatabaseConnection } from "kysely";
+import { SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, Driver, DatabaseConnection, QueryResult } from "kysely";
+type DOWorkerDialectConfig = {
+    kyselyExecuteQuery: (compiledQuery: {
+        sql: string;
+        parameters: readonly unknown[];
+    }) => Promise<QueryResult<any>>;
+};
 export declare class DOWorkerDialect {
-    config: {
-        stub: any;
-    };
-    constructor(config: {
-        stub: any;
-    });
+    config: DOWorkerDialectConfig;
+    constructor(config: DOWorkerDialectConfig);
     createAdapter(): SqliteAdapter;
     createDriver(): DOWorkerDriver;
     createQueryCompiler(): SqliteQueryCompiler;
     createIntrospector(db: any): SqliteIntrospector;
 }
 declare class DOWorkerDriver implements Driver {
-    config: {
-        stub: any;
-    };
-    constructor(config: {
-        stub: any;
-    });
+    config: DOWorkerDialectConfig;
+    constructor(config: DOWorkerDialectConfig);
     init(): Promise<void>;
     acquireConnection(): Promise<DatabaseConnection>;
     beginTransaction(conn: any): Promise<any>;

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

@@ -24,7 +24,7 @@ class DOWorkerDriver {
     }
     async init() { }
     async acquireConnection() {
-        return new DOWorkerConnection(this.config.stub.kyselyExecuteQuery);
+        return new DOWorkerConnection(this.config.kyselyExecuteQuery);
     }
     async beginTransaction(conn) {
         return await conn.beginTransaction();

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

@@ -1,2 +1,3 @@
 import { Kysely } from "kysely";
-export declare function createDb<T>(durableObjectBinding: any, name?: string): Kysely<T>;
+import { type SqliteDurableObject } from "./index.js";
+export declare function createDb<T>(durableObjectBinding: DurableObjectNamespace<SqliteDurableObject>, name?: string): Kysely<T>;

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

@@ -1,40 +1,14 @@
 import { Kysely } from "kysely";
-import { requestInfo, waitForRequestInfo } from "../../requestInfo/worker.js";
 import { DOWorkerDialect } from "./DOWorkerDialect.js";
-const createDurableObjectDb = (durableObjectBinding, name = "main") => {
-    const durableObjectId = durableObjectBinding.idFromName(name);
-    const stub = durableObjectBinding.get(durableObjectId);
-    stub.initialize();
-    return new Kysely({
-        dialect: new DOWorkerDialect({ stub }),
-    });
-};
 export function createDb(durableObjectBinding, name = "main") {
-    const cacheKey = `${durableObjectBinding}_${name}`;
-    const doCreateDb = () => {
-        if (!requestInfo.rw) {
-            throw new Error(`
-  rwsdk: A database created using createDb() was accessed before requestInfo was available.
-
-  Please make sure database access is happening in a request handler or action handler.
-  `);
-        }
-        let db = requestInfo.rw.databases.get(cacheKey);
-        if (!db) {
-            db = createDurableObjectDb(durableObjectBinding, name);
-            requestInfo.rw.databases.set(cacheKey, db);
-        }
-        return db;
-    };
-    waitForRequestInfo().then(() => doCreateDb());
-    return new Proxy({}, {
-        get(target, prop, receiver) {
-            const db = doCreateDb();
-            const value = db[prop];
-            if (typeof value === "function") {
-                return value.bind(db);
-            }
-            return value;
-        },
+    return new Kysely({
+        dialect: new DOWorkerDialect({
+            kyselyExecuteQuery: (...args) => {
+                const durableObjectId = durableObjectBinding.idFromName(name);
+                const stub = durableObjectBinding.get(durableObjectId);
+                stub.initialize();
+                return stub.kyselyExecuteQuery(...args);
+            },
+        }),
     });
 }

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

@@ -2,3 +2,4 @@ export * from "./migrations.js";
 export * from "./SqliteDurableObject.js";
 export * from "./createDb.js";
 export type * from "./typeInference/database.js";
+export { sql } from "kysely";

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

@@ -1,3 +1,4 @@
 export * from "./migrations.js";
 export * from "./SqliteDurableObject.js";
 export * from "./createDb.js";
+export { sql } from "kysely";

package/dist/runtime/lib/manifest.js

@@ -4,10 +4,7 @@ export const getManifest = async (requestInfo) => {
         return manifest;
     }
     if (import.meta.env.VITE_IS_DEV_SERVER) {
-        const url = new URL(requestInfo.request.url);
-        url.searchParams.set("scripts", JSON.stringify(Array.from(requestInfo.rw.scriptsToBeLoaded)));
-        url.pathname = "/__rwsdk_manifest";
-        manifest = await fetch(url.toString()).then((res) => res.json());
+        manifest = {};
     }
     else {
         const { default: prodManifest } = await import("virtual:rwsdk:manifest.js");

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

@@ -16,11 +16,12 @@ export type RwContext = {
     layouts?: React.FC<LayoutProps<any>>[];
     databases: Map<string, Kysely<any>>;
     scriptsToBeLoaded: Set<string>;
+    pageRouteResolved: PromiseWithResolvers<void> | undefined;
 };
-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>;
+export type RouteMiddleware<T extends RequestInfo = RequestInfo> = (requestInfo: T) => MaybePromise<React.JSX.Element | Response | void>;
+type RouteFunction<T extends RequestInfo = RequestInfo> = (requestInfo: T) => MaybePromise<Response>;
 type MaybePromise<T> = T | Promise<T>;
-type RouteComponent<T extends RequestInfo = RequestInfo> = (requestInfo: T) => MaybePromise<React.JSX.Element | Response>;
+type RouteComponent<T extends RequestInfo = RequestInfo> = (requestInfo: T) => MaybePromise<React.JSX.Element | Response | void>;
 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> = {
@@ -42,6 +43,7 @@ export declare function defineRoutes<T extends RequestInfo = RequestInfo>(routes
 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 const wrapHandlerToThrowResponses: <T extends RequestInfo = RequestInfo>(handler: RouteFunction<T> | RouteComponent<T>) => RouteHandler<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>[], 
 /**
@@ -53,5 +55,5 @@ options?: {
     rscPayload?: boolean;
     ssr?: boolean;
 }): Route<T>[];
-export declare const isClientReference: (Component: React.FC<any>) => boolean;
+export declare const isClientReference: (value: any) => boolean;
 export {};

package/dist/runtime/lib/router.js

@@ -71,47 +71,109 @@ export function defineRoutes(routes) {
             if (path !== "/" && !path.endsWith("/")) {
                 path = path + "/";
             }
-            // Find matching route
-            let match = null;
-            for (const route of flattenedRoutes) {
-                if (typeof route === "function") {
-                    const r = await route(getRequestInfo());
-                    if (r instanceof Response) {
-                        return r;
-                    }
-                    continue;
-                }
-                const params = matchPath(route.path, path);
-                if (params) {
-                    match = { params, handler: route.handler, layouts: route.layouts };
-                    break;
-                }
+            // Flow below; helpers are declared after the main flow for readability
+            // 1) Global middlewares
+            // ----------------------
+            const globalResult = await handleGlobalMiddlewares();
+            if (globalResult) {
+                return globalResult;
             }
+            // 2) Match route
+            // ----------------------
+            const match = matchRoute();
             if (!match) {
                 // todo(peterp, 2025-01-28): Allow the user to define their own "not found" route.
                 return new Response("Not Found", { status: 404 });
             }
-            let { params, handler, layouts } = match;
-            return runWithRequestInfoOverrides({ params }, async () => {
+            return await runWithRequestInfoOverrides({ params: match.params }, async () => {
+                const { routeMiddlewares, componentHandler } = parseHandlers(match.handler);
+                // 3) Route-specific middlewares
+                // -----------------------------
+                const mwHandled = await handleRouteMiddlewares(routeMiddlewares);
+                if (mwHandled) {
+                    return mwHandled;
+                }
+                // 4) Final component (always last item)
+                // -------------------------------------
+                return await handleRouteComponent(componentHandler, match.layouts || []);
+            });
+            // --- Helpers ---
+            function parseHandlers(handler) {
                 const handlers = Array.isArray(handler) ? handler : [handler];
-                for (const h of handlers) {
-                    if (isRouteComponent(h)) {
-                        const requestInfo = getRequestInfo();
-                        const WrappedComponent = wrapWithLayouts(h, layouts || [], requestInfo);
-                        return await renderPage(requestInfo, WrappedComponent, onError);
+                const routeMiddlewares = handlers.slice(0, Math.max(handlers.length - 1, 0));
+                const componentHandler = handlers[handlers.length - 1];
+                return {
+                    routeMiddlewares: routeMiddlewares,
+                    componentHandler,
+                };
+            }
+            function renderElement(element) {
+                const requestInfo = getRequestInfo();
+                const Element = () => element;
+                return renderPage(requestInfo, Element, onError);
+            }
+            async function handleMiddlewareResult(result) {
+                if (result instanceof Response) {
+                    return result;
+                }
+                if (result && React.isValidElement(result)) {
+                    return await renderElement(result);
+                }
+                return undefined;
+            }
+            async function handleGlobalMiddlewares() {
+                for (const route of flattenedRoutes) {
+                    if (typeof route !== "function") {
+                        continue;
                     }
-                    else {
-                        const r = await h(getRequestInfo());
-                        if (r instanceof Response) {
-                            return r;
-                        }
+                    const result = await route(getRequestInfo());
+                    const handled = await handleMiddlewareResult(result);
+                    if (handled)
+                        return handled;
+                }
+                return undefined;
+            }
+            function matchRoute() {
+                for (const route of flattenedRoutes) {
+                    if (typeof route === "function")
+                        continue;
+                    const params = matchPath(route.path, path);
+                    if (params) {
+                        return { params, handler: route.handler, layouts: route.layouts };
                     }
                 }
-                // Add fallback return
+                return null;
+            }
+            async function handleRouteMiddlewares(mws) {
+                for (const mw of mws) {
+                    const result = await mw(getRequestInfo());
+                    const handled = await handleMiddlewareResult(result);
+                    if (handled)
+                        return handled;
+                }
+                return undefined;
+            }
+            async function handleRouteComponent(component, layouts) {
+                if (isRouteComponent(component)) {
+                    const requestInfo = getRequestInfo();
+                    const WrappedComponent = wrapWithLayouts(wrapHandlerToThrowResponses(component), layouts, requestInfo);
+                    if (!isClientReference(component)) {
+                        // context(justinvdm, 31 Jul 2025): We now know we're dealing with a page route,
+                        // so we create a deferred so that we can signal when we're done determining whether
+                        // we're returning a response or a react element
+                        requestInfo.rw.pageRouteResolved = Promise.withResolvers();
+                    }
+                    return await renderPage(requestInfo, WrappedComponent, onError);
+                }
+                // If the last handler is not a component, handle as middleware result (no layouts)
+                const tailResult = await component(getRequestInfo());
+                const handledTail = await handleMiddlewareResult(tailResult);
+                if (handledTail)
+                    return handledTail;
                 return new Response("Response not returned from route handler", {
                     status: 500,
                 });
-            });
+            }
         },
     };
 }
@@ -164,6 +226,28 @@ function wrapWithLayouts(Component, layouts = [], requestInfo) {
         return Wrapped;
     }, Component);
 }
+// context(justinvdm, 31 Jul 2025): We need to wrap the handler's that might
+// return react elements, so that it throws the response to bubble it up and
+// break out of react rendering context This way, we're able to return a
+// response from the handler while still staying within react rendering context
+export const wrapHandlerToThrowResponses = (handler) => {
+    if (isClientReference(handler) ||
+        !isRouteComponent(handler) ||
+        Object.prototype.hasOwnProperty.call(handler, "__rwsdk_route_component")) {
+        return handler;
+    }
+    const ComponentWrappedToThrowResponses = async (requestInfo) => {
+        const result = await handler(requestInfo);
+        if (result instanceof Response) {
+            requestInfo.rw.pageRouteResolved?.reject(result);
+            throw result;
+        }
+        requestInfo.rw.pageRouteResolved?.resolve();
+        return result;
+    };
+    ComponentWrappedToThrowResponses.__rwsdk_route_component = true;
+    return ComponentWrappedToThrowResponses;
+};
 export function layout(LayoutComponent, routes) {
     // Attach layouts directly to route definitions
     return routes.map((route) => {
@@ -202,9 +286,10 @@ options = {}) {
     return [documentMiddleware, ...routes];
 }
 function isRouteComponent(handler) {
-    return ((isValidElementType(handler) && handler.toString().includes("jsx")) ||
+    return (Object.prototype.hasOwnProperty.call(handler, "__rwsdk_route_component") ||
+        (isValidElementType(handler) && handler.toString().includes("jsx")) ||
         isClientReference(handler));
 }
-export const isClientReference = (Component) => {
-    return Object.prototype.hasOwnProperty.call(Component, "$$isClientReference");
+export const isClientReference = (value) => {
+    return Object.prototype.hasOwnProperty.call(value, "$$isClientReference");
 };

package/dist/runtime/render/stylesheets.d.ts

@@ -1,9 +1,4 @@
 import { type RequestInfo } from "../requestInfo/types.js";
-export type CssEntry = {
-    url: string;
-    content: string;
-    absolutePath: string;
-};
 export declare const Stylesheets: ({ requestInfo }: {
     requestInfo: RequestInfo;
 }) => import("react/jsx-runtime.js").JSX.Element;

package/dist/runtime/render/stylesheets.js

@@ -31,15 +31,5 @@ export const Stylesheets = ({ requestInfo }) => {
             allStylesheets.add(entry);
         }
     }
-    return (_jsx(_Fragment, { children: Array.from(allStylesheets).map((entry) => {
-            if (typeof entry === "string") {
-                return (_jsx("link", { rel: "stylesheet", href: entry, precedence: "first" }, entry));
-            }
-            if (import.meta.env.VITE_IS_DEV_SERVER) {
-                return (_jsx("style", { "data-vite-dev-id": entry.absolutePath, dangerouslySetInnerHTML: { __html: entry.content } }, entry.url));
-            }
-            else {
-                return (_jsx("link", { rel: "stylesheet", href: entry.url, precedence: "first" }, entry.url));
-            }
-        }) }));
+    return (_jsx(_Fragment, { children: Array.from(allStylesheets).map((href) => (_jsx("link", { rel: "stylesheet", href: href, precedence: "first" }, href))) }));
 };

package/dist/runtime/requestInfo/types.d.ts

@@ -5,7 +5,9 @@ export interface RequestInfo<Params = any, AppContext = DefaultAppContext> {
     request: Request;
     params: Params;
     ctx: AppContext;
+    /** @deprecated: Use `response.headers` instead */
     headers: Headers;
     rw: RwContext;
     cf: ExecutionContext;
+    response: ResponseInit;
 }

package/dist/runtime/requestInfo/worker.js

@@ -2,7 +2,7 @@ import { AsyncLocalStorage } from "async_hooks";
 const requestInfoDeferred = Promise.withResolvers();
 const requestInfoStore = new AsyncLocalStorage();
 const requestInfoBase = {};
-const REQUEST_INFO_KEYS = ["request", "params", "ctx", "headers", "rw", "cf"];
+const REQUEST_INFO_KEYS = ["request", "params", "ctx", "headers", "rw", "cf", "response"];
 REQUEST_INFO_KEYS.forEach((key) => {
     Object.defineProperty(requestInfoBase, key, {
         enumerable: true,

package/dist/runtime/script.d.ts

@@ -1,5 +1,5 @@
 export declare const defineScript: (fn: ({ env }: {
-    env: Cloudflare.Env;
+    env: Env;
 }) => Promise<unknown>) => {
     fetch: (request: Request, env: Env, cf: ExecutionContext) => Promise<Response>;
 };