rwsdk 1.0.0-beta.2-test.20250930092748 → 1.0.0-beta.21

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

@@ -1,7 +1,13 @@
-import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
+// context(justinvdm, 14 Aug 2025): `react-server-dom-webpack` uses this globa ___webpack_require__ global,
+// so we need to import our client entry point (which sets it), before importing
+// prettier-ignore
 import { initClient } from "../../client/client";
-import { packMessage, unpackMessage, } from "./protocol";
+// prettier-ignore
+import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
+// prettier-ignore
 import { MESSAGE_TYPE } from "./shared";
+// prettier-ignore
+import { packMessage, unpackMessage, } from "./protocol";
 const DEFAULT_KEY = "default";
 export const initRealtimeClient = ({ key = DEFAULT_KEY, handleResponse, } = {}) => {
     const transport = realtimeTransport({ key, handleResponse });

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

@@ -1,33 +1,28 @@
-import type { Kysely } from "kysely";
 import React from "react";
 import { RequestInfo } from "../requestInfo/types";
-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>>;
-    scriptsToBeLoaded: Set<string>;
-    pageRouteResolved: PromiseWithResolvers<void> | undefined;
-    actionResult?: unknown;
-};
+import type { DocumentProps, LayoutProps } from "./types.js";
 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 | void>;
 type RouteHandler<T extends RequestInfo = RequestInfo> = RouteFunction<T> | RouteComponent<T> | [...RouteMiddleware<T>[], RouteFunction<T> | RouteComponent<T>];
+declare const METHOD_VERBS: readonly ["delete", "get", "head", "patch", "post", "put"];
+export type MethodVerb = (typeof METHOD_VERBS)[number];
+export type MethodHandlers<T extends RequestInfo = RequestInfo> = {
+    [K in MethodVerb]?: RouteHandler<T>;
+} & {
+    config?: {
+        disable405?: true;
+        disableOptions?: true;
+    };
+    custom?: {
+        [method: string]: RouteHandler<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>;
+    handler: RouteHandler<T> | MethodHandlers<T>;
     layouts?: React.FC<LayoutProps<T>>[];
 };
 export declare function matchPath<T extends RequestInfo = RequestInfo>(routePath: string, requestPath: string): T["params"] | null;
@@ -42,7 +37,7 @@ export declare function defineRoutes<T extends RequestInfo = RequestInfo>(routes
         rscActionHandler: (request: Request) => Promise<unknown>;
     }) => Response | Promise<Response>;
 };
-export declare function route<T extends RequestInfo = RequestInfo>(path: string, handler: RouteHandler<T>): RouteDefinition<T>;
+export declare function route<T extends RequestInfo = RequestInfo>(path: string, handler: RouteHandler<T> | MethodHandlers<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>;

package/dist/runtime/lib/router.js

@@ -1,5 +1,6 @@
 import React from "react";
 import { isValidElementType } from "react-is";
+const METHOD_VERBS = ["delete", "get", "head", "patch", "post", "put"];
 export function matchPath(routePath, requestPath) {
     // Check for invalid pattern: multiple colons in a segment (e.g., /:param1:param2/)
     if (routePath.includes(":")) {
@@ -60,6 +61,38 @@ function flattenRoutes(routes) {
         return [...acc, route];
     }, []);
 }
+function isMethodHandlers(handler) {
+    return (typeof handler === "object" && handler !== null && !Array.isArray(handler));
+}
+function handleOptionsRequest(methodHandlers) {
+    const methods = new Set([
+        ...(methodHandlers.config?.disableOptions ? [] : ["OPTIONS"]),
+        ...METHOD_VERBS.filter((verb) => methodHandlers[verb]).map((verb) => verb.toUpperCase()),
+        ...Object.keys(methodHandlers.custom ?? {}).map((method) => method.toUpperCase()),
+    ]);
+    return new Response(null, {
+        status: 204,
+        headers: {
+            Allow: Array.from(methods).sort().join(", "),
+        },
+    });
+}
+function handleMethodNotAllowed(methodHandlers) {
+    const optionsResponse = handleOptionsRequest(methodHandlers);
+    return new Response("Method Not Allowed", {
+        status: 405,
+        headers: optionsResponse.headers,
+    });
+}
+function getHandlerForMethod(methodHandlers, method) {
+    const lowerMethod = method.toLowerCase();
+    // Check standard method verbs
+    if (METHOD_VERBS.includes(lowerMethod)) {
+        return methodHandlers[lowerMethod];
+    }
+    // Check custom methods (already normalized to lowercase)
+    return methodHandlers.custom?.[lowerMethod];
+}
 export function defineRoutes(routes) {
     const flattenedRoutes = flattenRoutes(routes);
     return {
@@ -125,9 +158,32 @@ export function defineRoutes(routes) {
                 if (!params) {
                     continue; // Not a match, keep going.
                 }
+                // Resolve handler if method-based routing
+                let handler;
+                if (isMethodHandlers(route.handler)) {
+                    const requestMethod = request.method;
+                    // Handle OPTIONS request
+                    if (requestMethod === "OPTIONS" &&
+                        !route.handler.config?.disableOptions) {
+                        return handleOptionsRequest(route.handler);
+                    }
+                    // Try to find handler for the request method
+                    handler = getHandlerForMethod(route.handler, requestMethod);
+                    if (!handler) {
+                        // Method not supported for this route
+                        if (!route.handler.config?.disable405) {
+                            return handleMethodNotAllowed(route.handler);
+                        }
+                        // If 405 is disabled, continue to next route
+                        continue;
+                    }
+                }
+                else {
+                    handler = route.handler;
+                }
                 // Found a match: run route-specific middlewares, then the final component, then stop.
                 return await runWithRequestInfoOverrides({ params }, async () => {
-                    const { routeMiddlewares, componentHandler } = parseHandlers(route.handler);
+                    const { routeMiddlewares, componentHandler } = parseHandlers(handler);
                     // Route-specific middlewares
                     for (const mw of routeMiddlewares) {
                         const result = await mw(getRequestInfo());
@@ -169,6 +225,16 @@ export function route(path, handler) {
     if (!path.endsWith("/")) {
         path = path + "/";
     }
+    // Normalize custom method keys to lowercase
+    if (isMethodHandlers(handler) && handler.custom) {
+        handler = {
+            ...handler,
+            custom: Object.fromEntries(Object.entries(handler.custom).map(([method, methodHandler]) => [
+                method.toLowerCase(),
+                methodHandler,
+            ])),
+        };
+    }
     return {
         path,
         handler,

package/dist/runtime/lib/router.test.js

@@ -71,6 +71,8 @@ describe("defineRoutes - Request Handling Behavior", () => {
                 ssr: true,
                 databases: new Map(),
                 scriptsToBeLoaded: new Set(),
+                entryScripts: new Set(),
+                inlineScripts: new Set(),
                 pageRouteResolved: undefined,
             },
             cf: {},
@@ -593,6 +595,245 @@ describe("defineRoutes - Request Handling Behavior", () => {
             expect(extractedParams).toEqual({ id: "123" });
         });
     });
+    describe("HTTP Method Routing", () => {
+        it("should route GET request to get handler", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "GET",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "GET",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("GET Response");
+        });
+        it("should route POST request to post handler", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "POST",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "POST",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("POST Response");
+        });
+        it("should return 405 for unsupported method with Allow header", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "DELETE",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "DELETE",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(405);
+            expect(await response.text()).toBe("Method Not Allowed");
+            expect(response.headers.get("Allow")).toBe("GET, OPTIONS, POST");
+        });
+        it("should handle OPTIONS request with Allow header", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "OPTIONS",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "OPTIONS",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(204);
+            expect(response.headers.get("Allow")).toBe("GET, OPTIONS, POST");
+        });
+        it("should support custom methods (case-insensitive)", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    custom: {
+                        report: () => new Response("REPORT Response"),
+                    },
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "REPORT",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "REPORT",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("REPORT Response");
+        });
+        it("should normalize custom method keys to lowercase", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    custom: {
+                        REPORT: () => new Response("REPORT Response"),
+                    },
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "report",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "report",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("REPORT Response");
+        });
+        it("should disable 405 when config.disable405 is true", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    config: {
+                        disable405: true,
+                    },
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "POST",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "POST",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(404);
+            expect(await response.text()).toBe("Not Found");
+        });
+        it("should disable OPTIONS when config.disableOptions is true", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                    config: {
+                        disableOptions: true,
+                    },
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "OPTIONS",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "OPTIONS",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(405);
+            expect(await response.text()).toBe("Method Not Allowed");
+            expect(response.headers.get("Allow")).toBe("GET, POST");
+        });
+        it("should support middleware arrays in method handlers", async () => {
+            const executionOrder = [];
+            const authMiddleware = () => {
+                executionOrder.push("authMiddleware");
+            };
+            const getHandler = () => {
+                executionOrder.push("getHandler");
+                return new Response("GET Response");
+            };
+            const router = defineRoutes([
+                route("/test/", {
+                    get: [authMiddleware, getHandler],
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "GET",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "GET",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(executionOrder).toEqual(["authMiddleware", "getHandler"]);
+            expect(await response.text()).toBe("GET Response");
+        });
+    });
     describe("Edge Cases", () => {
         it("should handle middleware-only apps with RSC actions", async () => {
             const executionOrder = [];

package/dist/runtime/lib/{rwContext.d.ts → types.d.ts}

@@ -1,4 +1,5 @@
 import { type Kysely } from "kysely";
+import React from "react";
 import { type RequestInfo } from "../requestInfo/types.js";
 export type RwContext = {
     nonce: string;

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

@@ -1,4 +1,4 @@
-import { type DocumentProps } from "../lib/router.js";
+import { type DocumentProps } from "../lib/types.js";
 import { type RequestInfo } from "../requestInfo/types.js";
 export declare const renderDocumentHtmlStream: ({ rscPayloadStream, Document, requestInfo, shouldSSR, onError, }: {
     rscPayloadStream: ReadableStream;

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

@@ -1,10 +1,12 @@
 import { FC, ReactElement } from "react";
-import { DocumentProps } from "../lib/router";
+import { DocumentProps } from "../lib/types.js";
+import { type PartialRequestInfo } from "../requestInfo/types";
 export interface RenderToStreamOptions {
     Document?: FC<DocumentProps>;
     ssr?: boolean;
     injectRSCPayload?: boolean;
     onError?: (error: unknown) => void;
+    requestInfo?: PartialRequestInfo;
 }
 export declare const IdentityDocument: FC<DocumentProps>;
-export declare const renderToStream: (element: ReactElement, { ssr: shouldSSR, Document, injectRSCPayload: shouldInjectRSCPayload, onError, }?: RenderToStreamOptions) => Promise<ReadableStream>;
+export declare const renderToStream: (element: ReactElement, { ssr: shouldSSR, Document, injectRSCPayload: shouldInjectRSCPayload, requestInfo: givenRequestInfo, onError, }?: RenderToStreamOptions) => Promise<ReadableStream>;

package/dist/runtime/render/renderToStream.js

@@ -1,10 +1,29 @@
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { injectRSCPayload } from "rsc-html-stream/server";
-import { requestInfo } from "../requestInfo/worker";
+import { constructWithDefaultRequestInfo } from "../requestInfo/utils";
+import { getRequestInfo } from "../requestInfo/worker";
 import { renderDocumentHtmlStream } from "./renderDocumentHtmlStream";
 import { renderToRscStream } from "./renderToRscStream";
 export const IdentityDocument = ({ children }) => (_jsx(_Fragment, { children: children }));
-export const renderToStream = async (element, { ssr: shouldSSR = true, Document = IdentityDocument, injectRSCPayload: shouldInjectRSCPayload = true, onError = () => { }, } = {}) => {
+export const renderToStream = async (element, { ssr: shouldSSR = true, Document = IdentityDocument, injectRSCPayload: shouldInjectRSCPayload = true, requestInfo: givenRequestInfo, onError = () => { }, } = {}) => {
+    // Try to get the context requestInfo from the async store.
+    let contextRequestInfo;
+    try {
+        contextRequestInfo = getRequestInfo();
+    }
+    catch (e) {
+        // No requestInfo detected from store.
+    }
+    // Construct requestInfo with defaults where overrides take precedence.
+    // If provided, `givenRequestInfo` will override values from context requestInfo if it exists
+    const requestInfo = constructWithDefaultRequestInfo({
+        ...contextRequestInfo,
+        ...givenRequestInfo,
+        rw: {
+            ...contextRequestInfo?.rw,
+            ...givenRequestInfo?.rw,
+        },
+    });
     let rscStream = renderToRscStream({
         input: {
             node: element,

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

@@ -1,7 +1,9 @@
 import { FC, ReactElement } from "react";
-import { DocumentProps } from "../lib/router";
+import { DocumentProps } from "../lib/types.js";
+import { type PartialRequestInfo } from "../requestInfo/types";
 export interface RenderToStringOptions {
     Document?: FC<DocumentProps>;
     injectRSCPayload?: boolean;
+    requestInfo?: PartialRequestInfo;
 }
 export declare const renderToString: (element: ReactElement, options?: RenderToStringOptions) => Promise<string>;

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

@@ -1,4 +1,4 @@
-import { RwContext } from "../lib/router";
+import { RwContext } from "../lib/types.js";
 export interface DefaultAppContext {
 }
 export interface RequestInfo<Params = any, AppContext = DefaultAppContext> {
@@ -12,3 +12,6 @@ export interface RequestInfo<Params = any, AppContext = DefaultAppContext> {
     };
     isAction: boolean;
 }
+export type PartialRequestInfo<Params = any, AppContext = DefaultAppContext> = Omit<Partial<RequestInfo<Params, AppContext>>, "rw"> & {
+    rw?: Partial<RwContext>;
+};

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

@@ -0,0 +1,9 @@
+import { FC } from "react";
+import { type DocumentProps } from "../lib/types";
+import { type PartialRequestInfo, type RequestInfo } from "./types";
+export declare const DefaultRequestInfoDocument: FC<DocumentProps>;
+/**
+ * Constructs a generic requestInfo that can be used as defaults.
+ * Allows for passing in overrides to initialize with defaults.
+ */
+export declare const constructWithDefaultRequestInfo: (overrides?: PartialRequestInfo) => RequestInfo;

package/dist/runtime/requestInfo/utils.js

@@ -0,0 +1,44 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { generateNonce } from "../lib/utils";
+export const DefaultRequestInfoDocument = ({ children }) => (_jsx(_Fragment, { children: children }));
+/**
+ * Constructs a generic requestInfo that can be used as defaults.
+ * Allows for passing in overrides to initialize with defaults.
+ */
+export const constructWithDefaultRequestInfo = (overrides = {}) => {
+    const { rw: rwOverrides, ...otherRequestInfoOverrides } = overrides;
+    const defaultRequestInfo = {
+        request: new Request("http://localhost/"),
+        params: {},
+        ctx: {},
+        cf: {
+            waitUntil: () => { },
+            passThroughOnException: () => { },
+            props: {},
+        },
+        response: {
+            status: 200,
+            headers: new Headers(),
+        },
+        isAction: false,
+        rw: {
+            Document: DefaultRequestInfoDocument,
+            nonce: generateNonce(),
+            rscPayload: true,
+            ssr: true,
+            databases: new Map(),
+            scriptsToBeLoaded: new Set(),
+            entryScripts: new Set(),
+            inlineScripts: new Set(),
+            pageRouteResolved: undefined,
+        },
+    };
+    return {
+        ...defaultRequestInfo,
+        ...otherRequestInfoOverrides,
+        rw: {
+            ...defaultRequestInfo.rw,
+            ...rwOverrides,
+        },
+    };
+};

package/dist/runtime/requestInfo/worker.js

@@ -1,6 +1,7 @@
 import { AsyncLocalStorage } from "async_hooks";
-const requestInfoDeferred = Promise.withResolvers();
-const requestInfoStore = new AsyncLocalStorage();
+import { defineRwState } from "rwsdk/__state";
+const requestInfoDeferred = defineRwState("requestInfoDeferred", () => Promise.withResolvers());
+const requestInfoStore = defineRwState("requestInfoStore", () => new AsyncLocalStorage());
 const requestInfoBase = {};
 const REQUEST_INFO_KEYS = ["request", "params", "ctx", "rw", "cf", "response"];
 REQUEST_INFO_KEYS.forEach((key) => {

package/dist/runtime/script.d.ts

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

package/dist/runtime/script.js

@@ -1,11 +1,2 @@
 import { env } from "cloudflare:workers";
-import { defineApp } from "./worker";
-export const defineScript = (fn) => {
-    const app = defineApp([
-        async () => {
-            await fn({ env: env });
-            return new Response("Done!");
-        },
-    ]);
-    return app;
-};
+export const defineScript = (fn) => () => fn({ env: env });

package/dist/runtime/state.d.ts

@@ -0,0 +1,3 @@
+export declare function defineRwState<T>(key: string, initializer: () => T): T;
+export declare function getRwState<T>(key: string): T | undefined;
+export declare function setRwState<T>(key: string, value: T): void;

package/dist/runtime/state.js

@@ -0,0 +1,13 @@
+const state = {};
+export function defineRwState(key, initializer) {
+    if (!(key in state)) {
+        state[key] = initializer();
+    }
+    return state[key];
+}
+export function getRwState(key) {
+    return state[key];
+}
+export function setRwState(key, value) {
+    state[key] = value;
+}

package/dist/runtime/worker.js

@@ -23,6 +23,29 @@ export const defineApp = (routes) => {
                 url.pathname = url.pathname.slice("/assets/".length);
                 return env.ASSETS.fetch(new Request(url.toString(), request));
             }
+            else if (import.meta.env.VITE_IS_DEV_SERVER &&
+                new URL(request.url).pathname === "/__worker-run") {
+                const url = new URL(request.url);
+                const scriptPath = url.searchParams.get("script");
+                if (!scriptPath) {
+                    return new Response("Missing 'script' query parameter", {
+                        status: 400,
+                    });
+                }
+                try {
+                    const scriptModule = await import(/* @vite-ignore */ scriptPath);
+                    if (scriptModule.default) {
+                        await scriptModule.default(request, env, cf);
+                    }
+                    return new Response("Script executed successfully");
+                }
+                catch (e) {
+                    console.error(`Error executing script: ${scriptPath}\n\n${e.stack}`);
+                    return new Response(`Error executing script: ${e.message}`, {
+                        status: 500,
+                    });
+                }
+            }
             else if (import.meta.env.VITE_IS_DEV_SERVER &&
                 request.url.includes("/__vite_preamble__")) {
                 return new Response('import RefreshRuntime from "/@react-refresh"; RefreshRuntime.injectIntoGlobalHook(window); window.$RefreshReg$ = () => {}; window.$RefreshSig$ = () => (type) => type; window.__vite_plugin_react_preamble_installed__ = true;', {
@@ -43,6 +66,8 @@ export const defineApp = (routes) => {
                     ssr: true,
                     databases: new Map(),
                     scriptsToBeLoaded: new Set(),
+                    entryScripts: new Set(),
+                    inlineScripts: new Set(),
                     pageRouteResolved: undefined,
                 };
                 const userResponseInit = {