rwsdk 1.0.0-beta.27-test.20251115092208 → 1.0.0-beta.27-test.20251116215153

package/dist/runtime/lib/stitchDocumentAndAppStreams.js

@@ -15,37 +15,149 @@
  * @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.
  */
+function splitStreamOnFirstNonHoistedTag(sourceStream) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    const nonHoistedTagPattern = /<(?!(?:\/)?(?:title|meta|link|style|base)[\s>\/])(?![!?])/i;
+    let sourceReader;
+    let appBodyController = null;
+    let buffer = "";
+    let hoistedTagsDone = false;
+    const hoistedTagsStream = new ReadableStream({
+        start(controller) {
+            sourceReader = sourceStream.getReader();
+            const pump = async () => {
+                try {
+                    if (hoistedTagsDone) {
+                        controller.close();
+                        return;
+                    }
+                    const { done, value } = await sourceReader.read();
+                    if (done) {
+                        if (buffer) {
+                            const match = buffer.match(nonHoistedTagPattern);
+                            if (match && typeof match.index === "number") {
+                                const hoistedPart = buffer.slice(0, match.index);
+                                controller.enqueue(encoder.encode(hoistedPart));
+                            }
+                            else {
+                                controller.enqueue(encoder.encode(buffer));
+                            }
+                        }
+                        controller.close();
+                        hoistedTagsDone = true;
+                        if (appBodyController) {
+                            appBodyController.close();
+                        }
+                        return;
+                    }
+                    buffer += decoder.decode(value, { stream: true });
+                    const match = buffer.match(nonHoistedTagPattern);
+                    if (match && typeof match.index === "number") {
+                        const hoistedPart = buffer.slice(0, match.index);
+                        const appPart = buffer.slice(match.index);
+                        buffer = "";
+                        controller.enqueue(encoder.encode(hoistedPart));
+                        controller.close();
+                        hoistedTagsDone = true;
+                        if (appBodyController) {
+                            if (appPart) {
+                                appBodyController.enqueue(encoder.encode(appPart));
+                            }
+                            while (true) {
+                                const { done, value } = await sourceReader.read();
+                                if (done) {
+                                    appBodyController.close();
+                                    return;
+                                }
+                                appBodyController.enqueue(value);
+                            }
+                        }
+                    }
+                    else {
+                        const flushIndex = buffer.lastIndexOf("\n");
+                        if (flushIndex !== -1) {
+                            controller.enqueue(encoder.encode(buffer.slice(0, flushIndex + 1)));
+                            buffer = buffer.slice(flushIndex + 1);
+                        }
+                        await pump();
+                    }
+                }
+                catch (e) {
+                    controller.error(e);
+                    if (appBodyController) {
+                        appBodyController.error(e);
+                    }
+                }
+            };
+            pump().catch((e) => {
+                controller.error(e);
+                if (appBodyController) {
+                    appBodyController.error(e);
+                }
+            });
+        },
+    });
+    const appBodyStream = new ReadableStream({
+        start(controller) {
+            appBodyController = controller;
+        },
+    });
+    return [hoistedTagsStream, appBodyStream];
+}
 export function stitchDocumentAndAppStreams(outerHtml, innerHtml, startMarker, endMarker) {
+    const [hoistedTagsStream, appBodyStream] = splitStreamOnFirstNonHoistedTag(innerHtml);
     const decoder = new TextDecoder();
     const encoder = new TextEncoder();
     let outerReader;
     let innerReader;
+    let hoistedTagsReader;
     let buffer = "";
     let outerBufferRemains = "";
-    let phase = "outer-head";
+    let innerSuspendedRemains = "";
+    let phase = "enqueue-hoisted";
     const pump = async (controller) => {
         try {
-            if (phase === "outer-head") {
-                const { done, value } = await outerReader.read();
+            if (phase === "enqueue-hoisted") {
+                const { done, value } = await hoistedTagsReader.read();
                 if (done) {
-                    if (buffer)
-                        controller.enqueue(encoder.encode(buffer));
-                    controller.close();
-                    return;
+                    phase = "outer-head";
                 }
-                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 = "";
+                else {
+                    controller.enqueue(value);
+                }
+            }
+            else if (phase === "outer-head") {
+                const { done, value } = await outerReader.read();
+                if (done) {
+                    if (buffer) {
+                        const markerIndex = buffer.indexOf(startMarker);
+                        if (markerIndex !== -1) {
+                            controller.enqueue(encoder.encode(buffer.slice(0, markerIndex)));
+                            outerBufferRemains = buffer.slice(markerIndex + startMarker.length);
+                        }
+                        else {
+                            controller.enqueue(encoder.encode(buffer));
+                        }
+                        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);
+                    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);
+                        }
                     }
                 }
             }
@@ -62,7 +174,8 @@ export function stitchDocumentAndAppStreams(outerHtml, innerHtml, startMarker, e
                     if (markerIndex !== -1) {
                         const endOfMarkerIndex = markerIndex + endMarker.length;
                         controller.enqueue(encoder.encode(buffer.slice(0, endOfMarkerIndex)));
-                        buffer = buffer.slice(endOfMarkerIndex);
+                        innerSuspendedRemains = buffer.slice(endOfMarkerIndex);
+                        buffer = "";
                         phase = "outer-tail";
                     }
                     else {
@@ -81,8 +194,17 @@ export function stitchDocumentAndAppStreams(outerHtml, innerHtml, startMarker, e
                 }
                 const { done, value } = await outerReader.read();
                 if (done) {
-                    if (buffer)
-                        controller.enqueue(encoder.encode(buffer));
+                    if (buffer) {
+                        const markerIndex = buffer.indexOf("</body>");
+                        if (markerIndex !== -1) {
+                            controller.enqueue(encoder.encode(buffer.slice(0, markerIndex)));
+                            buffer = buffer.slice(markerIndex);
+                        }
+                        else {
+                            controller.enqueue(encoder.encode(buffer));
+                            buffer = "";
+                        }
+                    }
                     phase = "inner-suspended";
                 }
                 else {
@@ -103,6 +225,10 @@ export function stitchDocumentAndAppStreams(outerHtml, innerHtml, startMarker, e
                 }
             }
             else if (phase === "inner-suspended") {
+                if (innerSuspendedRemains) {
+                    controller.enqueue(encoder.encode(innerSuspendedRemains));
+                    innerSuspendedRemains = "";
+                }
                 const { done, value } = await innerReader.read();
                 if (done) {
                     phase = "outer-end";
@@ -132,12 +258,14 @@ export function stitchDocumentAndAppStreams(outerHtml, innerHtml, startMarker, e
     return new ReadableStream({
         start(controller) {
             outerReader = outerHtml.getReader();
-            innerReader = innerHtml.getReader();
+            innerReader = appBodyStream.getReader();
+            hoistedTagsReader = hoistedTagsStream.getReader();
             pump(controller).catch((e) => controller.error(e));
         },
         cancel(reason) {
             outerReader?.cancel(reason);
             innerReader?.cancel(reason);
+            hoistedTagsReader?.cancel(reason);
         },
     });
 }

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

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

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

@@ -0,0 +1,384 @@
+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("extracts and prepends single title tag", 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.indexOf(`<title>Page Title</title>`)).toBeLessThan(result.indexOf(`<!DOCTYPE html>`));
+            expect(result).toContain(`<div>App content</div>`);
+        });
+        it("extracts and prepends multiple 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 = `<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" />`);
+            const hoistedStart = result.indexOf(`<title>Page Title</title>`);
+            const doctypeStart = result.indexOf(`<!DOCTYPE html>`);
+            expect(hoistedStart).toBeLessThan(doctypeStart);
+        });
+        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" />`);
+            const hoistedStart = result.indexOf(`<title>Page Title</title>`);
+            const doctypeStart = result.indexOf(`<!DOCTYPE html>`);
+            expect(hoistedStart).toBeLessThan(doctypeStart);
+        });
+    });
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.0-beta.27-test.20251115092208",
+  "version": "1.0.0-beta.27-test.20251116215153",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {