npm - rwsdk - Versions diffs - 1.0.0-beta.4 → 1.0.0-beta.41 - Mend

rwsdk 1.0.0-beta.4 → 1.0.0-beta.41

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (139) hide show

package/dist/lib/constants.d.mts +1 -0
package/dist/lib/constants.mjs +7 -4
package/dist/lib/e2e/browser.mjs +6 -2
package/dist/lib/e2e/constants.d.mts +4 -0
package/dist/lib/e2e/constants.mjs +49 -12
package/dist/lib/e2e/dev.mjs +37 -49
package/dist/lib/e2e/environment.d.mts +2 -0
package/dist/lib/e2e/environment.mjs +201 -64
package/dist/lib/e2e/index.d.mts +1 -0
package/dist/lib/e2e/index.mjs +1 -0
package/dist/lib/e2e/poll.d.mts +1 -1
package/dist/lib/e2e/release.d.mts +1 -0
package/dist/lib/e2e/release.mjs +16 -32
package/dist/lib/e2e/tarball.mjs +2 -34
package/dist/lib/e2e/testHarness.d.mts +34 -3
package/dist/lib/e2e/testHarness.mjs +219 -90
package/dist/lib/e2e/utils.d.mts +1 -0
package/dist/lib/e2e/utils.mjs +15 -0
package/dist/runtime/client/client.d.ts +35 -0
package/dist/runtime/client/client.js +35 -0
package/dist/runtime/client/navigation.d.ts +49 -0
package/dist/runtime/client/navigation.js +80 -31
package/dist/runtime/entries/clientSSR.d.ts +1 -0
package/dist/runtime/entries/clientSSR.js +3 -0
package/dist/runtime/entries/no-react-server-ssr-bridge.d.ts +0 -0
package/dist/runtime/entries/no-react-server-ssr-bridge.js +2 -0
package/dist/runtime/entries/router.d.ts +1 -0
package/dist/runtime/entries/routerClient.d.ts +1 -0
package/dist/runtime/entries/routerClient.js +1 -0
package/dist/runtime/entries/worker.d.ts +2 -0
package/dist/runtime/entries/worker.js +2 -0
package/dist/runtime/imports/__mocks__/use-client-lookup.d.ts +6 -0
package/dist/runtime/imports/__mocks__/use-client-lookup.js +6 -0
package/dist/runtime/lib/db/SqliteDurableObject.d.ts +2 -2
package/dist/runtime/lib/db/SqliteDurableObject.js +2 -2
package/dist/runtime/lib/db/createDb.d.ts +1 -2
package/dist/runtime/lib/db/createDb.js +4 -0
package/dist/runtime/lib/db/typeInference/builders/alterTable.d.ts +13 -3
package/dist/runtime/lib/db/typeInference/builders/columnDefinition.d.ts +35 -21
package/dist/runtime/lib/db/typeInference/builders/createTable.d.ts +9 -2
package/dist/runtime/lib/db/typeInference/database.d.ts +16 -2
package/dist/runtime/lib/db/typeInference/typetests/alterTable.typetest.js +80 -5
package/dist/runtime/lib/db/typeInference/typetests/createTable.typetest.js +104 -2
package/dist/runtime/lib/db/typeInference/typetests/testUtils.d.ts +1 -0
package/dist/runtime/lib/db/typeInference/utils.d.ts +59 -9
package/dist/runtime/lib/links.d.ts +21 -7
package/dist/runtime/lib/links.js +82 -24
package/dist/runtime/lib/links.test.js +20 -0
package/dist/runtime/lib/manifest.d.ts +1 -1
package/dist/runtime/lib/manifest.js +7 -4
package/dist/runtime/lib/realtime/client.js +8 -2
package/dist/runtime/lib/realtime/worker.d.ts +1 -1
package/dist/runtime/lib/router.d.ts +153 -36
package/dist/runtime/lib/router.js +169 -20
package/dist/runtime/lib/router.test.js +241 -0
package/dist/runtime/lib/stitchDocumentAndAppStreams.d.ts +66 -0
package/dist/runtime/lib/stitchDocumentAndAppStreams.js +302 -35
package/dist/runtime/lib/stitchDocumentAndAppStreams.test.d.ts +1 -0
package/dist/runtime/lib/stitchDocumentAndAppStreams.test.js +418 -0
package/dist/runtime/lib/{rwContext.d.ts → types.d.ts} +1 -0
package/dist/runtime/lib/types.js +1 -0
package/dist/runtime/render/renderDocumentHtmlStream.d.ts +1 -1
package/dist/runtime/render/renderToStream.d.ts +4 -2
package/dist/runtime/render/renderToStream.js +53 -24
package/dist/runtime/render/renderToString.d.ts +3 -6
package/dist/runtime/requestInfo/types.d.ts +4 -1
package/dist/runtime/requestInfo/utils.d.ts +9 -0
package/dist/runtime/requestInfo/utils.js +44 -0
package/dist/runtime/requestInfo/worker.d.ts +0 -1
package/dist/runtime/requestInfo/worker.js +3 -10
package/dist/runtime/script.d.ts +1 -3
package/dist/runtime/script.js +1 -10
package/dist/runtime/state.d.ts +3 -0
package/dist/runtime/state.js +13 -0
package/dist/runtime/worker.d.ts +3 -1
package/dist/runtime/worker.js +32 -0
package/dist/scripts/debug-sync.mjs +18 -20
package/dist/scripts/worker-run.d.mts +1 -1
package/dist/scripts/worker-run.mjs +59 -113
package/dist/use-synced-state/SyncedStateServer.d.mts +21 -0
package/dist/use-synced-state/SyncedStateServer.mjs +128 -0
package/dist/use-synced-state/__tests__/SyncStateServer.test.d.mts +1 -0
package/dist/use-synced-state/__tests__/SyncStateServer.test.mjs +109 -0
package/dist/use-synced-state/__tests__/useSyncState.test.d.ts +1 -0
package/dist/use-synced-state/__tests__/useSyncState.test.js +115 -0
package/dist/use-synced-state/__tests__/useSyncedState.test.d.ts +1 -0
package/dist/use-synced-state/__tests__/useSyncedState.test.js +115 -0
package/dist/use-synced-state/__tests__/worker.test.d.mts +1 -0
package/dist/use-synced-state/__tests__/worker.test.mjs +69 -0
package/dist/use-synced-state/client-core.d.ts +26 -0
package/dist/use-synced-state/client-core.js +39 -0
package/dist/use-synced-state/client.d.ts +3 -0
package/dist/use-synced-state/client.js +4 -0
package/dist/use-synced-state/constants.d.mts +1 -0
package/dist/use-synced-state/constants.mjs +1 -0
package/dist/use-synced-state/useSyncedState.d.ts +20 -0
package/dist/use-synced-state/useSyncedState.js +58 -0
package/dist/use-synced-state/worker.d.mts +13 -0
package/dist/use-synced-state/worker.mjs +69 -0
package/dist/vite/buildApp.mjs +34 -2
package/dist/vite/cloudflarePreInitPlugin.d.mts +11 -0
package/dist/vite/cloudflarePreInitPlugin.mjs +40 -0
package/dist/vite/configPlugin.mjs +9 -14
package/dist/vite/constants.d.mts +1 -0
package/dist/vite/constants.mjs +1 -0
package/dist/vite/createDirectiveLookupPlugin.mjs +10 -7
package/dist/vite/devServerTimingPlugin.mjs +4 -0
package/dist/vite/diagnosticAssetGraphPlugin.d.mts +4 -0
package/dist/vite/diagnosticAssetGraphPlugin.mjs +41 -0
package/dist/vite/directiveModulesDevPlugin.mjs +9 -1
package/dist/vite/directivesPlugin.mjs +4 -4
package/dist/vite/envResolvers.d.mts +11 -0
package/dist/vite/envResolvers.mjs +20 -0
package/dist/vite/getViteEsbuild.mjs +2 -1
package/dist/vite/hmrStabilityPlugin.d.mts +2 -0
package/dist/vite/hmrStabilityPlugin.mjs +73 -0
package/dist/vite/injectVitePreamblePlugin.mjs +0 -4
package/dist/vite/knownDepsResolverPlugin.d.mts +0 -6
package/dist/vite/knownDepsResolverPlugin.mjs +25 -17
package/dist/vite/linkerPlugin.d.mts +2 -1
package/dist/vite/linkerPlugin.mjs +11 -3
package/dist/vite/linkerPlugin.test.mjs +15 -0
package/dist/vite/miniflareHMRPlugin.mjs +6 -38
package/dist/vite/moveStaticAssetsPlugin.mjs +35 -4
package/dist/vite/redwoodPlugin.mjs +8 -10
package/dist/vite/runDirectivesScan.mjs +72 -18
package/dist/vite/ssrBridgePlugin.mjs +132 -40
package/dist/vite/ssrBridgeWrapPlugin.d.mts +2 -0
package/dist/vite/ssrBridgeWrapPlugin.mjs +85 -0
package/dist/vite/staleDepRetryPlugin.d.mts +2 -0
package/dist/vite/staleDepRetryPlugin.mjs +74 -0
package/dist/vite/statePlugin.d.mts +4 -0
package/dist/vite/statePlugin.mjs +62 -0
package/dist/vite/transformJsxScriptTagsPlugin.mjs +0 -5
package/dist/vite/virtualPlugin.mjs +6 -7
package/package.json +27 -10
package/dist/vite/manifestPlugin.d.mts +0 -4
package/dist/vite/manifestPlugin.mjs +0 -63
/package/dist/runtime/lib/{rwContext.js → links.test.d.ts} +0 -0

package/dist/runtime/lib/stitchDocumentAndAppStreams.test.js ADDED Viewed

@@ -0,0 +1,418 @@
+import { describe, expect, it } from "vitest";
+import { stitchDocumentAndAppStreams } from "./stitchDocumentAndAppStreams.js";
+function stringToStream(str) {
+    const encoder = new TextEncoder();
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue(encoder.encode(str));
+            controller.close();
+        },
+    });
+}
+function streamToString(stream) {
+    const decoder = new TextDecoder();
+    const reader = stream.getReader();
+    let result = "";
+    return new Promise((resolve, reject) => {
+        function pump() {
+            return reader
+                .read()
+                .then(({ done, value }) => {
+                if (done) {
+                    resolve(result);
+                    return;
+                }
+                result += decoder.decode(value, { stream: true });
+                return pump();
+            })
+                .catch(reject);
+        }
+        return pump();
+    });
+}
+function createChunkedStream(chunks) {
+    const encoder = new TextEncoder();
+    return new ReadableStream({
+        start(controller) {
+            for (let i = 0; i < chunks.length; i++) {
+                controller.enqueue(encoder.encode(chunks[i]));
+            }
+            controller.close();
+        },
+    });
+}
+describe("stitchDocumentAndAppStreams", () => {
+    const startMarker = '<div id="rwsdk-app-start" />';
+    const endMarker = '<div id="rwsdk-app-end"></div>';
+    describe("meta tag hoisting", () => {
+        it("places hoisted tags inside head, after existing head content", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+</head>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtml = `<title>Page Title</title><div>App content</div>${endMarker}`;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result).toContain(`<title>Page Title</title>`);
+            expect(result).toMatch(/<head>[\s\S]*<meta charset="utf-8" \/>[\s\S]*<title>Page Title<\/title>[\s\S]*<\/head>/);
+            expect(result).toContain(`<div>App content</div>`);
+            const doctypeIndex = result.indexOf(`<!DOCTYPE html>`);
+            const headIndex = result.indexOf(`<head>`);
+            const charsetIndex = result.indexOf(`<meta charset="utf-8" />`);
+            const titleIndex = result.indexOf(`<title>Page Title</title>`);
+            const headCloseIndex = result.indexOf(`</head>`);
+            expect(doctypeIndex).toBe(0);
+            expect(doctypeIndex).toBeLessThan(headIndex);
+            expect(charsetIndex).toBeLessThan(titleIndex);
+            expect(titleIndex).toBeLessThan(headCloseIndex);
+        });
+        it("places multiple hoisted tags inside head, after existing head content", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+</head>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtml = `<title>Page Title</title><meta name="description" content="Test" /><link rel="stylesheet" href="/styles.css" /><div>App content</div>${endMarker}`;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result).toContain(`<title>Page Title</title>`);
+            expect(result).toContain(`<meta name="description" content="Test" />`);
+            expect(result).toContain(`<link rel="stylesheet" href="/styles.css" />`);
+            expect(result).toMatch(/<head>[\s\S]*<meta charset="utf-8" \/>[\s\S]*<title>Page Title<\/title>[\s\S]*<meta name="description" content="Test" \/>[\s\S]*<link rel="stylesheet" href="\/styles.css" \/>[\s\S]*<\/head>/);
+            const doctypeIndex = result.indexOf(`<!DOCTYPE html>`);
+            const charsetIndex = result.indexOf(`<meta charset="utf-8" />`);
+            const titleIndex = result.indexOf(`<title>Page Title</title>`);
+            const headCloseIndex = result.indexOf(`</head>`);
+            expect(doctypeIndex).toBe(0);
+            expect(charsetIndex).toBeLessThan(titleIndex);
+            expect(titleIndex).toBeLessThan(headCloseIndex);
+        });
+        it("handles app stream with no hoisted tags", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+</head>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtml = `<div>App content</div>${endMarker}`;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result).toContain(`<div>App content</div>`);
+            expect(result).not.toContain(`<title>`);
+        });
+        it("handles hoisted tags split across chunks", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+</head>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtmlChunks = [
+                `<title>Page `,
+                `Title</title><meta name="description" `,
+                `content="Test" /><div>App content</div>${endMarker}`,
+            ];
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), createChunkedStream(innerHtmlChunks), startMarker, endMarker));
+            expect(result).toContain(`<title>Page Title</title>`);
+            expect(result).toContain(`<meta name="description" content="Test" />`);
+            expect(result).toMatch(/<head>[\s\S]*<meta charset="utf-8" \/>[\s\S]*<title>Page Title<\/title>[\s\S]*<\/head>/);
+            const doctypeIndex = result.indexOf(`<!DOCTYPE html>`);
+            const charsetIndex = result.indexOf(`<meta charset="utf-8" />`);
+            const titleIndex = result.indexOf(`<title>Page Title</title>`);
+            const headCloseIndex = result.indexOf(`</head>`);
+            expect(doctypeIndex).toBe(0);
+            expect(charsetIndex).toBeLessThan(titleIndex);
+            expect(titleIndex).toBeLessThan(headCloseIndex);
+        });
+        it("ensures doctype is always first", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+</head>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtml = `<title>Page Title</title><div>App content</div>${endMarker}`;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result.trim().startsWith(`<!DOCTYPE html>`)).toBe(true);
+        });
+    });
+    describe("basic stitching flow", () => {
+        it("stitches document head, app shell, and document tail", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+</head>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtml = `<div>App content</div>${endMarker}`;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result).toContain(`<!DOCTYPE html>`);
+            expect(result).toContain(`<head>`);
+            expect(result).toContain(`<meta charset="utf-8" />`);
+            expect(result).toContain(`<div>App content</div>`);
+            expect(result).toContain(`<script src="/client.js"></script>`);
+            expect(result).toContain(`</body>`);
+            expect(result).toContain(`</html>`);
+            const doctypeIndex = result.indexOf(`<!DOCTYPE html>`);
+            const appContentIndex = result.indexOf(`<div>App content</div>`);
+            const scriptIndex = result.indexOf(`<script src="/client.js"></script>`);
+            const bodyCloseIndex = result.indexOf(`</body>`);
+            expect(doctypeIndex).toBeLessThan(appContentIndex);
+            expect(appContentIndex).toBeLessThan(scriptIndex);
+            expect(scriptIndex).toBeLessThan(bodyCloseIndex);
+        });
+        it("removes start marker from output", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtml = `<div>App content</div>${endMarker}`;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result).not.toContain(startMarker);
+        });
+        it("preserves end marker in output", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtml = `<div>App content</div>${endMarker}`;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result).toContain(endMarker);
+        });
+    });
+    describe("suspense boundaries (suspended content)", () => {
+        it("streams suspended content after script tag", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+</head>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtml = `<div>Initial content</div>${endMarker}<div>Suspended content</div>`;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result).toContain(`<div>Initial content</div>`);
+            expect(result).toContain(`<script src="/client.js"></script>`);
+            expect(result).toContain(`<div>Suspended content</div>`);
+            const initialIndex = result.indexOf(`<div>Initial content</div>`);
+            const scriptIndex = result.indexOf(`<script src="/client.js"></script>`);
+            const suspendedIndex = result.indexOf(`<div>Suspended content</div>`);
+            const bodyCloseIndex = result.indexOf(`</body>`);
+            expect(initialIndex).toBeLessThan(scriptIndex);
+            expect(scriptIndex).toBeLessThan(suspendedIndex);
+            expect(suspendedIndex).toBeLessThan(bodyCloseIndex);
+        });
+        it("handles multiple suspended content chunks", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtml = `<div>Initial</div>${endMarker}<div>Suspended 1</div><div>Suspended 2</div>`;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result).toContain(`<div>Initial</div>`);
+            expect(result).toContain(`<div>Suspended 1</div>`);
+            expect(result).toContain(`<div>Suspended 2</div>`);
+            const scriptIndex = result.indexOf(`<script src="/client.js"></script>`);
+            const suspended1Index = result.indexOf(`<div>Suspended 1</div>`);
+            const suspended2Index = result.indexOf(`<div>Suspended 2</div>`);
+            expect(scriptIndex).toBeLessThan(suspended1Index);
+            expect(suspended1Index).toBeLessThan(suspended2Index);
+        });
+        it("handles app stream with no suspended content", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtml = `<div>Initial content</div>${endMarker}`;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result).toContain(`<div>Initial content</div>`);
+            expect(result).toContain(`<script src="/client.js"></script>`);
+            expect(result).not.toContain(`Suspended`);
+        });
+    });
+    describe("chunked streams", () => {
+        it("handles document stream split across chunks", async () => {
+            const outerHtmlChunks = [
+                `<!DOCTYPE html>\n<html>\n<head>\n`,
+                `  <meta charset="utf-8" />\n</head>\n<body>\n`,
+                `  ${startMarker}\n  <script src="/client.js"></script>\n</body>\n</html>`,
+            ];
+            const innerHtml = `<div>App content</div>${endMarker}`;
+            const result = await streamToString(stitchDocumentAndAppStreams(createChunkedStream(outerHtmlChunks), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result).toContain(`<!DOCTYPE html>`);
+            expect(result).toContain(`<div>App content</div>`);
+            expect(result).toContain(`<script src="/client.js"></script>`);
+        });
+        it("handles app stream split across chunks", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtmlChunks = [
+                `<div>Initial `,
+                `content</div>${endMarker}`,
+                `<div>Suspended content</div>`,
+            ];
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), createChunkedStream(innerHtmlChunks), startMarker, endMarker));
+            expect(result).toContain(`<div>Initial content</div>`);
+            expect(result).toContain(`<div>Suspended content</div>`);
+        });
+        it("handles markers split across chunks", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtmlChunks = [
+                `<div>App content</div><div id="rwsdk-app-end`,
+                `"></div>`,
+            ];
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), createChunkedStream(innerHtmlChunks), startMarker, endMarker));
+            expect(result).toContain(`<div>App content</div>`);
+            expect(result).toContain(endMarker);
+        });
+    });
+    describe("edge cases", () => {
+        it("handles empty app stream", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtml = ``;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result).toContain(`<!DOCTYPE html>`);
+            expect(result).toContain(`<script src="/client.js"></script>`);
+            expect(result).toContain(`</body>`);
+        });
+        it("handles empty outer stream", async () => {
+            const outerHtml = ``;
+            const innerHtml = `<div>App content</div>${endMarker}`;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result).toBe(`<div>App content</div>${endMarker}`);
+        });
+        it("handles app stream ending before end marker", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtml = `<div>App content</div>`;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result).toContain(`<div>App content</div>`);
+            expect(result).toContain(`<script src="/client.js"></script>`);
+        });
+        it("handles outer stream ending before start marker", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+</head>`;
+            const innerHtml = `<div>App content</div>${endMarker}`;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result).toContain(`<!DOCTYPE html>`);
+            expect(result).toContain(`<meta charset="utf-8" />`);
+            expect(result).toContain(`<div>App content</div>`);
+        });
+    });
+    describe("complete flow verification", () => {
+        it("correctly orders all phases: head -> shell -> script -> suspended -> close", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>Test Page</title>
+</head>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtml = `<div>Initial content</div>${endMarker}<div>Suspended content</div>`;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            const doctypeIndex = result.indexOf(`<!DOCTYPE html>`);
+            const headIndex = result.indexOf(`<head>`);
+            const titleIndex = result.indexOf(`<title>Test Page</title>`);
+            const initialIndex = result.indexOf(`<div>Initial content</div>`);
+            const scriptIndex = result.indexOf(`<script src="/client.js"></script>`);
+            const suspendedIndex = result.indexOf(`<div>Suspended content</div>`);
+            const bodyCloseIndex = result.indexOf(`</body>`);
+            const htmlCloseIndex = result.indexOf(`</html>`);
+            expect(doctypeIndex).toBeLessThan(headIndex);
+            expect(headIndex).toBeLessThan(titleIndex);
+            expect(titleIndex).toBeLessThan(initialIndex);
+            expect(initialIndex).toBeLessThan(scriptIndex);
+            expect(scriptIndex).toBeLessThan(suspendedIndex);
+            expect(suspendedIndex).toBeLessThan(bodyCloseIndex);
+            expect(bodyCloseIndex).toBeLessThan(htmlCloseIndex);
+        });
+        it("preserves content structure and markers", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            const innerHtml = `<div id="app">
+    <h1>Hello</h1>
+    <p>World</p>
+  </div>${endMarker}<div>More content</div>`;
+            const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
+            expect(result).toContain(`<div id="app">`);
+            expect(result).toContain(`<h1>Hello</h1>`);
+            expect(result).toContain(`<p>World</p>`);
+            expect(result).toContain(endMarker);
+            expect(result).toContain(`<div>More content</div>`);
+            expect(result).not.toContain(startMarker);
+        });
+    });
+});

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

@@ -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/lib/types.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

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

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -1,34 +1,63 @@
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { injectRSCPayload } from "rsc-html-stream/server";
-import { requestInfo } from "../requestInfo/worker";
+import { ssrWebpackRequire } from "../imports/worker.js";
+import { constructWithDefaultRequestInfo } from "../requestInfo/utils";
+import { getRequestInfo, runWithRequestInfo } 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({
-        input: {
-            node: element,
-            actionResult: undefined,
+export const renderToStream = async (element, { ssr: shouldSSR = true, Document = IdentityDocument, injectRSCPayload: shouldInjectRSCPayload = true, requestInfo: givenRequestInfo, onError = () => { }, } = {}) => {
+    if (!globalThis.__webpack_require__) {
+        globalThis.__webpack_require__ = ssrWebpackRequire;
+    }
+    // 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,
         },
-        onError,
     });
-    let injectRSCStream;
-    if (shouldInjectRSCPayload) {
-        const [rscPayloadStream1, rscPayloadStream2] = rscStream.tee();
-        rscStream = rscPayloadStream1;
-        injectRSCStream = injectRSCPayload(rscPayloadStream2, {
-            nonce: requestInfo.rw.nonce,
+    // context(gching, 2025-10-29): We wrap the following with context to the requestInfo
+    // due to `ssrWebpackRequire` needing to reference the `requestInfo` in context.
+    // Therefore, we need to wrap + also pass in the requestInfo in their independent
+    // function calls
+    return runWithRequestInfo(requestInfo, async () => {
+        let rscStream = renderToRscStream({
+            input: {
+                node: element,
+                actionResult: undefined,
+            },
+            onError,
         });
-    }
-    let htmlStream = await renderDocumentHtmlStream({
-        rscPayloadStream: rscStream,
-        Document,
-        requestInfo,
-        shouldSSR,
-        onError,
+        let injectRSCStream;
+        if (shouldInjectRSCPayload) {
+            const [rscPayloadStream1, rscPayloadStream2] = rscStream.tee();
+            rscStream = rscPayloadStream1;
+            injectRSCStream = injectRSCPayload(rscPayloadStream2, {
+                nonce: requestInfo.rw.nonce,
+            });
+        }
+        let htmlStream = await renderDocumentHtmlStream({
+            rscPayloadStream: rscStream,
+            Document,
+            requestInfo,
+            shouldSSR,
+            onError,
+        });
+        if (injectRSCStream) {
+            htmlStream = htmlStream.pipeThrough(injectRSCStream);
+        }
+        return htmlStream;
     });
-    if (injectRSCStream) {
-        htmlStream = htmlStream.pipeThrough(injectRSCStream);
-    }
-    return htmlStream;
 };

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

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

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

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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.d.ts CHANGED Viewed

@@ -2,7 +2,6 @@ import { DefaultAppContext, RequestInfo } from "./types";
 type DefaultRequestInfo = RequestInfo<DefaultAppContext>;
 export declare const requestInfo: DefaultRequestInfo;
 export declare function getRequestInfo(): RequestInfo;
-export declare function waitForRequestInfo(): Promise<DefaultRequestInfo>;
 export declare function runWithRequestInfo<Result>(nextRequestInfo: DefaultRequestInfo, fn: () => Result): Result;
 export declare function runWithRequestInfoOverrides<Result>(overrides: Partial<DefaultRequestInfo>, fn: () => Result): Result;
 export {};

package/dist/runtime/requestInfo/worker.js CHANGED Viewed

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from "async_hooks";
-const requestInfoDeferred = Promise.withResolvers();
-const requestInfoStore = new AsyncLocalStorage();
+import { defineRwState } from "rwsdk/__state";
+const requestInfoStore = defineRwState("requestInfoStore", () => new AsyncLocalStorage());
 const requestInfoBase = {};
 const REQUEST_INFO_KEYS = ["request", "params", "ctx", "rw", "cf", "response"];
 REQUEST_INFO_KEYS.forEach((key) => {
@@ -21,15 +21,8 @@ export function getRequestInfo() {
     }
     return store;
 }
-export function waitForRequestInfo() {
-    return requestInfoDeferred.promise;
-}
 export function runWithRequestInfo(nextRequestInfo, fn) {
-    const runWithRequestInfoFn = () => {
-        requestInfoDeferred.resolve(nextRequestInfo);
-        return fn();
-    };
-    return requestInfoStore.run(nextRequestInfo, runWithRequestInfoFn);
+    return requestInfoStore.run(nextRequestInfo, fn);
 }
 export function runWithRequestInfoOverrides(overrides, fn) {
     const requestInfo = requestInfoStore.getStore();

package/dist/runtime/script.d.ts CHANGED Viewed

@@ -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>;