rwsdk 1.0.0-alpha.9 → 1.0.0-beta.1

package/dist/runtime/lib/db/typeInference/database.d.ts

@@ -1,9 +1,9 @@
 import { Kysely } from "kysely";
-import { ExecutedBuilder, Prettify, ProcessAlteredTable, UnionToTuple } from "./utils";
-import { CreateTableBuilder } from "./builders/createTable";
 import { AlterTableBuilder } from "./builders/alterTable";
+import { CreateTableBuilder } from "./builders/createTable";
 import { DropTableBuilder } from "./builders/dropTable";
 import { SchemaBuilder } from "./builders/schema";
+import { ExecutedBuilder, Prettify, ProcessAlteredTable, UnionToTuple } from "./utils";
 export interface InferenceBuilder {
     schema: SchemaBuilder;
 }

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

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import { memoizeOnId } from "./memoizeOnId";
 describe("memoizeOnId", () => {
     it("should call the function only once for the same id", () => {

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

@@ -1,7 +1,7 @@
-import { initClient } from "../../client/client";
 import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
-import { MESSAGE_TYPE } from "./shared";
+import { initClient } from "../../client/client";
 import { packMessage, unpackMessage, } from "./protocol";
+import { MESSAGE_TYPE } from "./shared";
 const DEFAULT_KEY = "default";
 export const initRealtimeClient = ({ key = DEFAULT_KEY, handleResponse, } = {}) => {
     const transport = realtimeTransport({ key, handleResponse });

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

@@ -1,7 +1,7 @@
 import { DurableObject } from "cloudflare:workers";
+import { packMessage, unpackMessage, } from "./protocol";
 import { MESSAGE_TYPE } from "./shared";
 import { validateUpgradeRequest } from "./validateUpgradeRequest";
-import { packMessage, unpackMessage, } from "./protocol";
 export class RealtimeDurableObject extends DurableObject {
     constructor(state, env) {
         super(state, env);

package/dist/runtime/lib/realtime/protocol.test.js

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { packMessage, unpackMessage } from "./protocol";
 import { MESSAGE_TYPE } from "./shared";
 describe("Realtime Protocol pack/unpack", () => {

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

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { MESSAGE_TYPE } from "./shared";
 describe("Realtime Shared Constants", () => {
     it("MESSAGE_TYPE should match snapshot", () => {

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

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { validateUpgradeRequest } from "./validateUpgradeRequest";
 describe("validateUpgradeRequest", () => {
     it("should return valid for a correct WebSocket upgrade request", () => {

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

@@ -1,7 +1,7 @@
+import { env } from "cloudflare:workers";
 import { route } from "../../entries/router";
-import { validateUpgradeRequest } from "./validateUpgradeRequest";
 import { DEFAULT_REALTIME_KEY } from "./constants";
-import { env } from "cloudflare:workers";
+import { validateUpgradeRequest } from "./validateUpgradeRequest";
 export { renderRealtimeClients } from "./renderRealtimeClients";
 export const realtimeRoute = (getDurableObjectNamespace) => route("/__realtime", async function ({ request }) {
     const validation = validateUpgradeRequest(request);

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

@@ -1,6 +1,6 @@
+import type { Kysely } from "kysely";
 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;
 };

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

@@ -1,6 +1,6 @@
-import { describe, it, expect } from "vitest";
 import React from "react";
-import { matchPath, defineRoutes, route, render, layout, prefix, } from "./router";
+import { describe, expect, it } from "vitest";
+import { defineRoutes, layout, matchPath, prefix, render, route, } from "./router";
 describe("matchPath", () => {
     // Test case 1: Static paths
     it("should match static paths", () => {
@@ -64,7 +64,6 @@ describe("defineRoutes - Request Handling Behavior", () => {
             request: new Request("http://localhost:3000/"),
             params: {},
             ctx: {},
-            headers: new Headers(),
             rw: {
                 nonce: "test-nonce",
                 Document: () => React.createElement("html"),

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

@@ -1,5 +1,5 @@
-import { type RequestInfo } from "../requestInfo/types.js";
 import { type Kysely } from "kysely";
+import { type RequestInfo } from "../requestInfo/types.js";
 export type RwContext = {
     nonce: string;
     Document: React.FC<DocumentProps<any>>;

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

@@ -0,0 +1,18 @@
+/**
+ * A utility to orchestrate and interleave two ReadableStreams (a document shell and an app shell)
+ * based on a set of markers within their content. This is designed to solve a specific
+ * race condition in streaming Server-Side Rendering (SSR) with Suspense.
+ *
+ * The logic is as follows:
+ * 1. Stream the document until a start marker is found.
+ * 2. Switch to the app stream and stream it until an end marker is found. This is the non-suspended shell.
+ * 3. Switch back to the document stream and stream it until the closing body tag. This sends the client script.
+ * 4. Switch back to the app stream and stream the remainder (the suspended content).
+ * 5. Switch back to the document stream and stream the remainder (closing body and html tags).
+ *
+ * @param outerHtml The stream for the document shell (`<Document>`).
+ * @param innerHtml The stream for the application's content.
+ * @param startMarker The marker in the document to start injecting the app.
+ * @param endMarker The marker in the app stream that signals the end of the initial, non-suspended render.
+ */
+export declare function stitchDocumentAndAppStreams(outerHtml: ReadableStream<Uint8Array>, innerHtml: ReadableStream<Uint8Array>, startMarker: string, endMarker: string): ReadableStream<Uint8Array>;

package/dist/runtime/lib/stitchDocumentAndAppStreams.js

@@ -0,0 +1,143 @@
+/**
+ * A utility to orchestrate and interleave two ReadableStreams (a document shell and an app shell)
+ * based on a set of markers within their content. This is designed to solve a specific
+ * race condition in streaming Server-Side Rendering (SSR) with Suspense.
+ *
+ * The logic is as follows:
+ * 1. Stream the document until a start marker is found.
+ * 2. Switch to the app stream and stream it until an end marker is found. This is the non-suspended shell.
+ * 3. Switch back to the document stream and stream it until the closing body tag. This sends the client script.
+ * 4. Switch back to the app stream and stream the remainder (the suspended content).
+ * 5. Switch back to the document stream and stream the remainder (closing body and html tags).
+ *
+ * @param outerHtml The stream for the document shell (`<Document>`).
+ * @param innerHtml The stream for the application's content.
+ * @param startMarker The marker in the document to start injecting the app.
+ * @param endMarker The marker in the app stream that signals the end of the initial, non-suspended render.
+ */
+export function stitchDocumentAndAppStreams(outerHtml, innerHtml, startMarker, endMarker) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let outerReader;
+    let innerReader;
+    let buffer = "";
+    let outerBufferRemains = "";
+    let phase = "outer-head";
+    const pump = async (controller) => {
+        try {
+            if (phase === "outer-head") {
+                const { done, value } = await outerReader.read();
+                if (done) {
+                    if (buffer)
+                        controller.enqueue(encoder.encode(buffer));
+                    controller.close();
+                    return;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const markerIndex = buffer.indexOf(startMarker);
+                if (markerIndex !== -1) {
+                    controller.enqueue(encoder.encode(buffer.slice(0, markerIndex)));
+                    outerBufferRemains = buffer.slice(markerIndex + startMarker.length);
+                    buffer = "";
+                    phase = "inner-shell";
+                }
+                else {
+                    const flushIndex = buffer.lastIndexOf("\n");
+                    if (flushIndex !== -1) {
+                        controller.enqueue(encoder.encode(buffer.slice(0, flushIndex + 1)));
+                        buffer = buffer.slice(flushIndex + 1);
+                    }
+                }
+            }
+            else if (phase === "inner-shell") {
+                const { done, value } = await innerReader.read();
+                if (done) {
+                    if (buffer)
+                        controller.enqueue(encoder.encode(buffer));
+                    phase = "outer-tail";
+                }
+                else {
+                    buffer += decoder.decode(value, { stream: true });
+                    const markerIndex = buffer.indexOf(endMarker);
+                    if (markerIndex !== -1) {
+                        const endOfMarkerIndex = markerIndex + endMarker.length;
+                        controller.enqueue(encoder.encode(buffer.slice(0, endOfMarkerIndex)));
+                        buffer = buffer.slice(endOfMarkerIndex);
+                        phase = "outer-tail";
+                    }
+                    else {
+                        const flushIndex = buffer.lastIndexOf("\n");
+                        if (flushIndex !== -1) {
+                            controller.enqueue(encoder.encode(buffer.slice(0, flushIndex + 1)));
+                            buffer = buffer.slice(flushIndex + 1);
+                        }
+                    }
+                }
+            }
+            else if (phase === "outer-tail") {
+                if (outerBufferRemains) {
+                    buffer = outerBufferRemains;
+                    outerBufferRemains = "";
+                }
+                const { done, value } = await outerReader.read();
+                if (done) {
+                    if (buffer)
+                        controller.enqueue(encoder.encode(buffer));
+                    phase = "inner-suspended";
+                }
+                else {
+                    buffer += decoder.decode(value, { stream: true });
+                    const markerIndex = buffer.indexOf("</body>");
+                    if (markerIndex !== -1) {
+                        controller.enqueue(encoder.encode(buffer.slice(0, markerIndex)));
+                        buffer = buffer.slice(markerIndex);
+                        phase = "inner-suspended";
+                    }
+                    else {
+                        const flushIndex = buffer.lastIndexOf("\n");
+                        if (flushIndex !== -1) {
+                            controller.enqueue(encoder.encode(buffer.slice(0, flushIndex + 1)));
+                            buffer = buffer.slice(flushIndex + 1);
+                        }
+                    }
+                }
+            }
+            else if (phase === "inner-suspended") {
+                const { done, value } = await innerReader.read();
+                if (done) {
+                    phase = "outer-end";
+                }
+                else {
+                    controller.enqueue(value);
+                }
+            }
+            else if (phase === "outer-end") {
+                if (buffer) {
+                    controller.enqueue(encoder.encode(buffer));
+                    buffer = "";
+                }
+                const { done, value } = await outerReader.read();
+                if (done) {
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(value);
+            }
+            await pump(controller);
+        }
+        catch (e) {
+            controller.error(e);
+        }
+    };
+    return new ReadableStream({
+        start(controller) {
+            outerReader = outerHtml.getReader();
+            innerReader = innerHtml.getReader();
+            pump(controller).catch((e) => controller.error(e));
+        },
+        cancel(reason) {
+            outerReader?.cancel(reason);
+            innerReader?.cancel(reason);
+        },
+    });
+}

package/dist/runtime/lib/turnstile/useTurnstile.js

@@ -1,5 +1,5 @@
 "use client";
-import { useRef, useCallback } from "react";
+import { useCallback, useRef } from "react";
 export function useTurnstile(siteKey) {
     const containerRef = useRef(null);
     const resolverRef = useRef(Promise.withResolvers());

package/dist/runtime/lib/turnstile/verifyTurnstileToken.test.js

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import { verifyTurnstileToken } from "./verifyTurnstileToken";
 describe("verifyTurnstileToken", () => {
     it("should return true for a successful verification", async () => {

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

@@ -1,4 +1,4 @@
 export declare function registerServerReference(action: Function, id: string, name: string): Function;
-export declare function registerClientReference<Target extends Record<string, any>>(id: string, exportName: string, value: any): any;
+export declare function registerClientReference<Target extends Record<string, unknown>>(ssrModule: Target, id: string, exportName: string): {};
 export declare function __smokeTestActionHandler(timestamp?: number): Promise<unknown>;
 export declare function rscActionHandler(req: Request): Promise<unknown>;

package/dist/runtime/register/worker.js

@@ -1,4 +1,5 @@
-import { registerServerReference as baseRegisterServerReference, registerClientReference as baseRegisterClientReference, decodeReply, } from "react-server-dom-webpack/server.edge";
+import { isValidElementType } from "react-is";
+import { registerClientReference as baseRegisterClientReference, registerServerReference as baseRegisterServerReference, decodeReply, } from "react-server-dom-webpack/server.edge";
 import { getServerModuleExport } from "../imports/worker.js";
 import { requestInfo } from "../requestInfo/worker.js";
 export function registerServerReference(action, id, name) {
@@ -8,28 +9,39 @@ export function registerServerReference(action, id, name) {
     // Note: We no longer need to register in a Map since we use virtual lookup
     return baseRegisterServerReference(action, id, name);
 }
-export function registerClientReference(id, exportName, value) {
-    const wrappedValue = (value && typeof value === "function") || typeof value === "object"
-        ? value
-        : () => null;
-    const reference = baseRegisterClientReference({}, id, exportName);
-    reference.__rwsdk_clientReferenceId = `${id}#${exportName}`;
-    const finalDescriptors = Object.getOwnPropertyDescriptors(reference);
-    const idDescriptor = finalDescriptors.$$id;
-    if (idDescriptor && idDescriptor.hasOwnProperty("value")) {
-        const originalValue = idDescriptor.value;
-        finalDescriptors.$$id = {
-            configurable: idDescriptor.configurable,
-            enumerable: idDescriptor.enumerable,
-            get() {
-                requestInfo.rw.scriptsToBeLoaded.add(id);
-                return originalValue;
-            },
-        };
+const isComponent = (target) => isValidElementType(target) && target?.toString().includes("jsx");
+export function registerClientReference(ssrModule, id, exportName) {
+    const target = ssrModule[exportName] ?? {};
+    if (isValidElementType(target)) {
+        // This is the original logic from 'main'.
+        // For React components, we create a serializable reference for the RSC pass.
+        const reference = baseRegisterClientReference({}, id, exportName);
+        const finalDescriptors = Object.getOwnPropertyDescriptors(reference);
+        const idDescriptor = finalDescriptors.$$id;
+        if (idDescriptor) {
+            const originalValue = idDescriptor.value;
+            // Create a new accessor descriptor, NOT by spreading the old one.
+            finalDescriptors.$$id = {
+                enumerable: idDescriptor.enumerable,
+                configurable: idDescriptor.configurable,
+                get() {
+                    requestInfo.rw.scriptsToBeLoaded.add(id);
+                    return originalValue;
+                },
+            };
+        }
+        finalDescriptors.$$async = { value: true };
+        finalDescriptors.$$isClientReference = { value: true };
+        // context(justinvdm, 25 Sep 2025): We create a wrapper function to avoid
+        // getting the SSR component's property descriptors - otherwise
+        // this will take precedence over the client reference descriptors
+        const fn = typeof target === "function"
+            ? (...args) => target(...args)
+            : () => null;
+        return Object.defineProperties(fn, finalDescriptors);
     }
-    finalDescriptors.$$async = { value: true };
-    finalDescriptors.$$isClientReference = { value: true };
-    return Object.defineProperties(wrappedValue, finalDescriptors);
+    // For non-components, return the target object directly for use in SSR.
+    return target;
 }
 export async function __smokeTestActionHandler(timestamp) {
     await new Promise((resolve) => setTimeout(resolve, 0));

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

@@ -3,4 +3,4 @@ export declare const assembleDocument: ({ requestInfo, pageElement, shouldSSR, }
     requestInfo: RequestInfo;
     pageElement: React.ReactNode;
     shouldSSR: boolean;
-}) => import("react/jsx-runtime.js").JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/runtime/render/createThenableFromReadableStream.js

@@ -1,5 +1,5 @@
-import { createModuleMap } from "./createModuleMap.js";
 import ReactServerDom from "react-server-dom-webpack/client.edge";
+import { createModuleMap } from "./createModuleMap.js";
 const { createFromReadableStream } = ReactServerDom;
 export const createThenableFromReadableStream = (stream) => createFromReadableStream(stream, {
     serverConsumerManifest: {

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

@@ -1,6 +1,6 @@
-import type { RequestInfo } from "../requestInfo/types.js";
 import type { Manifest, ManifestChunk } from "../lib/manifest.js";
+import type { RequestInfo } from "../requestInfo/types.js";
 export declare function findScriptForModule(id: string, manifest: Manifest): ManifestChunk | undefined;
 export declare const Preloads: ({ requestInfo, }: {
     requestInfo: RequestInfo;
-}) => Promise<import("react/jsx-runtime.js").JSX.Element>;
+}) => Promise<import("react/jsx-runtime").JSX.Element>;

package/dist/runtime/render/renderDocumentHtmlStream.js

@@ -1,12 +1,12 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Preloads } from "./preloads.js";
 import { Stylesheets } from "./stylesheets.js";
-import { renderHtmlStream, createThenableFromReadableStream, } from "rwsdk/__ssr_bridge";
-import { injectHtmlAtMarker } from "../lib/injectHtmlAtMarker.js";
+import { createThenableFromReadableStream, renderHtmlStream, } from "rwsdk/__ssr_bridge";
+import { stitchDocumentAndAppStreams } from "../lib/stitchDocumentAndAppStreams.js";
 export const renderDocumentHtmlStream = async ({ rscPayloadStream, Document, requestInfo, shouldSSR, onError, }) => {
     // Extract the app node from the RSC payload
     const rscAppThenable = createThenableFromReadableStream(rscPayloadStream);
-    const { node: appNode } = (await rscAppThenable);
+    const { node: innerAppNode } = (await rscAppThenable);
     // todo(justinvdm, 18 Jun 2025): We can build on this later to allow users
     // surface context. e.g:
     // * we assign `user: requestInfo.clientCtx` here
@@ -21,7 +21,7 @@ export const renderDocumentHtmlStream = async ({ rscPayloadStream, Document, req
     // Create the outer document with a marker for injection
     const documentElement = (_jsxs(Document, { ...requestInfo, children: [_jsx("script", { nonce: requestInfo.rw.nonce, dangerouslySetInnerHTML: {
                     __html: `globalThis.__RWSDK_CONTEXT = ${JSON.stringify(clientContext)}`,
-                } }), _jsx(Stylesheets, { requestInfo: requestInfo }), _jsx(Preloads, { requestInfo: requestInfo }), _jsx("div", { id: "hydrate-root", dangerouslySetInnerHTML: { __html: "<!-- RWSDK_INJECT_APP_HTML -->" } })] }));
+                } }), _jsx(Stylesheets, { requestInfo: requestInfo }), _jsx(Preloads, { requestInfo: requestInfo }), _jsx("div", { id: "hydrate-root", children: _jsx("div", { id: "rwsdk-app-start" }) })] }));
     const outerHtmlStream = await renderHtmlStream({
         node: documentElement,
         requestInfo,
@@ -29,11 +29,11 @@ export const renderDocumentHtmlStream = async ({ rscPayloadStream, Document, req
         identifierPrefix: "__RWSDK_DOCUMENT__",
     });
     const appHtmlStream = await renderHtmlStream({
-        node: appNode,
+        node: innerAppNode,
         requestInfo,
         onError,
     });
     // Stitch the streams together
-    const stitchedStream = injectHtmlAtMarker(outerHtmlStream, appHtmlStream, "<!-- RWSDK_INJECT_APP_HTML -->");
+    const stitchedStream = stitchDocumentAndAppStreams(outerHtmlStream, appHtmlStream, '<div id="rwsdk-app-start"></div>', '<div id="rwsdk-app-end"></div>');
     return stitchedStream;
 };

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

@@ -4,4 +4,4 @@ export declare const renderHtmlStream: ({ node, identifierPrefix, requestInfo, o
     requestInfo: RequestInfo;
     onError: (error: unknown) => void;
     identifierPrefix?: string;
-}) => Promise<import("react-dom/server.js").ReactDOMServerReadableStream>;
+}) => Promise<import("react-dom/server").ReactDOMServerReadableStream>;

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

@@ -1,4 +1,7 @@
 export declare const renderToRscStream: ({ input, onError, }: {
-    input: any;
+    input: {
+        node: React.ReactNode;
+        actionResult: unknown;
+    };
     onError?: (error: unknown) => void;
 }) => ReadableStream;

package/dist/runtime/render/renderToRscStream.js

@@ -1,7 +1,17 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { renderToReadableStream as baseRenderToRscStream } from "react-server-dom-webpack/server.edge";
 import { createClientManifest } from "./createClientManifest.js";
 export const renderToRscStream = ({ input, onError, }) => {
-    return baseRenderToRscStream(input, createClientManifest(), {
+    const { node: inputNode, actionResult } = input;
+    // context(justinvdm, 2025-09-26): We add a marker here for our stitching logic in
+    // renderDocumentHtmlStream() to find and use. It needs to live here rather than there,
+    // since it needs to live in the RSC payload for hydration to work.
+    const wrappedNode = (_jsxs(_Fragment, { children: [inputNode, _jsx("div", { id: "rwsdk-app-end" })] }));
+    const wrappedInput = {
+        node: wrappedNode,
+        actionResult,
+    };
+    return baseRenderToRscStream(wrappedInput, createClientManifest(), {
         onError,
     });
 };

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

@@ -1,4 +1,4 @@
-import { ReactElement, FC } from "react";
+import { FC, ReactElement } from "react";
 import { DocumentProps } from "../lib/router";
 export interface RenderToStreamOptions {
     Document?: FC<DocumentProps>;

package/dist/runtime/render/renderToStream.js

@@ -1,8 +1,8 @@
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { renderToRscStream } from "./renderToRscStream";
-import { requestInfo } from "../requestInfo/worker";
 import { injectRSCPayload } from "rsc-html-stream/server";
+import { requestInfo } 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 = () => { }, } = {}) => {
     let rscStream = renderToRscStream({

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

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

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

@@ -5,8 +5,6 @@ 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.d.ts

@@ -1,4 +1,4 @@
-import { RequestInfo, DefaultAppContext } from "./types";
+import { DefaultAppContext, RequestInfo } from "./types";
 type DefaultRequestInfo = RequestInfo<DefaultAppContext>;
 export declare const requestInfo: DefaultRequestInfo;
 export declare function getRequestInfo(): RequestInfo;

package/dist/runtime/requestInfo/worker.js

@@ -2,15 +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",
-    "response",
-];
+const REQUEST_INFO_KEYS = ["request", "params", "ctx", "rw", "cf", "response"];
 REQUEST_INFO_KEYS.forEach((key) => {
     Object.defineProperty(requestInfoBase, key, {
         enumerable: true,

package/dist/runtime/script.js

@@ -1,5 +1,5 @@
-import { defineApp } from "./worker";
 import { env } from "cloudflare:workers";
+import { defineApp } from "./worker";
 export const defineScript = (fn) => {
     const app = defineApp([
         async () => {

package/dist/runtime/ssrBridge.d.ts

@@ -1,3 +1,3 @@
-export { renderHtmlStream } from "./render/renderHtmlStream";
 export { createThenableFromReadableStream } from "./render/createThenableFromReadableStream";
-export { ssrLoadModule, ssrGetModuleExport, ssrWebpackRequire, } from "./imports/ssr";
+export { renderHtmlStream } from "./render/renderHtmlStream";
+export { ssrGetModuleExport, ssrLoadModule, ssrWebpackRequire, } from "./imports/ssr";

package/dist/runtime/ssrBridge.js

@@ -7,6 +7,6 @@
 // import it through this bridge module, using the bare import path
 // `rwsdk/__ssr_bridge`. We have bundler logic (ssrBridgePlugin) that looks out
 // for imports to it.
-export { renderHtmlStream } from "./render/renderHtmlStream";
 export { createThenableFromReadableStream } from "./render/createThenableFromReadableStream";
-export { ssrLoadModule, ssrGetModuleExport, ssrWebpackRequire, } from "./imports/ssr";
+export { renderHtmlStream } from "./render/renderHtmlStream";
+export { ssrGetModuleExport, ssrLoadModule, ssrWebpackRequire, } from "./imports/ssr";

package/dist/runtime/worker.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { RequestInfo, DefaultAppContext } from "./requestInfo/types";
+import { DefaultAppContext, RequestInfo } from "./requestInfo/types";
 import { Route } from "./lib/router";
 export * from "./requestInfo/types";
 declare global {

package/dist/runtime/worker.js

@@ -1,14 +1,14 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { renderDocumentHtmlStream } from "./render/renderDocumentHtmlStream";
 import { normalizeActionResult } from "./render/normalizeActionResult";
+import { renderDocumentHtmlStream } from "./render/renderDocumentHtmlStream";
 import { renderToRscStream } from "./render/renderToRscStream";
-import { rscActionHandler } from "./register/worker";
 import { injectRSCPayload } from "rsc-html-stream/server";
 import { ErrorResponse } from "./error";
+import { rscActionHandler } from "./register/worker";
 import { getRequestInfo, runWithRequestInfo, runWithRequestInfoOverrides, } from "./requestInfo/worker";
+import { ssrWebpackRequire } from "./imports/worker";
 import { defineRoutes } from "./lib/router";
 import { generateNonce } from "./lib/utils";
-import { ssrWebpackRequire } from "./imports/worker";
 export * from "./requestInfo/types";
 export const defineApp = (routes) => {
     return {
@@ -36,7 +36,6 @@ export const defineApp = (routes) => {
                 const isRSCRequest = url.searchParams.has("__rsc") ||
                     request.headers.get("accept")?.includes("text/x-component");
                 const isAction = url.searchParams.has("__rsc_action_id");
-                const userHeaders = new Headers();
                 const rw = {
                     Document: DefaultDocument,
                     nonce: generateNonce(),
@@ -52,7 +51,6 @@ export const defineApp = (routes) => {
                 };
                 const outerRequestInfo = {
                     request,
-                    headers: userHeaders,
                     cf,
                     params: {},
                     ctx: {},
@@ -144,12 +142,6 @@ export const defineApp = (routes) => {
                 // context(justinvdm, 18 Mar 2025): In some cases, such as a .fetch() call to a durable object instance, or Response.redirect(),
                 // we need to return a mutable response object.
                 const mutableResponse = new Response(response.body, response);
-                // Merge user headers from the legacy headers object
-                for (const [key, value] of userHeaders.entries()) {
-                    if (!response.headers.has(key)) {
-                        mutableResponse.headers.set(key, value);
-                    }
-                }
                 // Merge headers from user response init (these take precedence)
                 if (userResponseInit.headers) {
                     const userResponseHeaders = new Headers(userResponseInit.headers);

package/dist/scripts/addon.d.mts

@@ -0,0 +1 @@
+export declare const addon: () => Promise<void>;