rwsdk 1.5.3 → 1.5.5

package/dist/runtime/lib/stitchDocumentAndAppStreams.js

@@ -19,6 +19,24 @@ function splitStreamOnFirstNonHoistedTag(sourceStream) {
     const decoder = new TextDecoder();
     const encoder = new TextEncoder();
     const nonHoistedTagPattern = /<(?!(?:\/)?(?:title|meta|link|style|base)[\s>\/])(?![!?])/i;
+    // Longest hoistable name is 5 chars (title/style); a match candidate at
+    // index i needs buffer[i..] to have at least 1 (optional "/") + 5 (name)
+    // + 1 (terminating char) = 7 chars of context past "<" before it can be
+    // trusted as final. Otherwise the tag name may be mid-stream-truncated,
+    // causing a false-positive match on e.g. "<t" and severing <title>.
+    const MIN_TRAILING_CONTEXT = 7;
+    function findTrustedMatch(buf, streamDone) {
+        const match = buf.match(nonHoistedTagPattern);
+        if (!match || typeof match.index !== "number")
+            return null;
+        if (streamDone)
+            return match; // no more data coming; trust it
+        // buf.length - match.index counts the "<" itself, so subtract 1 to
+        // get the number of confirmed characters *after* it.
+        if (buf.length - match.index - 1 < MIN_TRAILING_CONTEXT)
+            return null; // ambiguous, wait for more data
+        return match;
+    }
     let sourceReader;
     let appBodyController = null;
     let buffer = "";
@@ -35,7 +53,7 @@ function splitStreamOnFirstNonHoistedTag(sourceStream) {
                     const { done, value } = await sourceReader.read();
                     if (done) {
                         if (buffer) {
-                            const match = buffer.match(nonHoistedTagPattern);
+                            const match = findTrustedMatch(buffer, true);
                             if (match && typeof match.index === "number") {
                                 const hoistedPart = buffer.slice(0, match.index);
                                 controller.enqueue(encoder.encode(hoistedPart));
@@ -52,7 +70,7 @@ function splitStreamOnFirstNonHoistedTag(sourceStream) {
                         return;
                     }
                     buffer += decoder.decode(value, { stream: true });
-                    const match = buffer.match(nonHoistedTagPattern);
+                    const match = findTrustedMatch(buffer, false);
                     if (match && typeof match.index === "number") {
                         const hoistedPart = buffer.slice(0, match.index);
                         const appPart = buffer.slice(match.index);
@@ -76,9 +94,17 @@ function splitStreamOnFirstNonHoistedTag(sourceStream) {
                     }
                     else {
                         const flushIndex = buffer.lastIndexOf("\n");
-                        if (flushIndex !== -1) {
-                            controller.enqueue(encoder.encode(buffer.slice(0, flushIndex + 1)));
-                            buffer = buffer.slice(flushIndex + 1);
+                        // Never flush past a point that could still be part of
+                        // an ambiguous, not-yet-trusted candidate tag. Only
+                        // flush content strictly before the last unresolved
+                        // "<" in the buffer, so a truncated tag name can never
+                        // be split across a flush boundary.
+                        const earliestOpenBracket = buffer.lastIndexOf("<");
+                        const safeFlushLimit = earliestOpenBracket === -1 ? buffer.length : earliestOpenBracket;
+                        const effectiveFlushIndex = Math.min(flushIndex, safeFlushLimit - 1);
+                        if (flushIndex !== -1 && effectiveFlushIndex >= 0) {
+                            controller.enqueue(encoder.encode(buffer.slice(0, effectiveFlushIndex + 1)));
+                            buffer = buffer.slice(effectiveFlushIndex + 1);
                         }
                         await pump();
                     }

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

@@ -155,6 +155,60 @@ describe("stitchDocumentAndAppStreams", () => {
             const result = await streamToString(stitchDocumentAndAppStreams(stringToStream(outerHtml), stringToStream(innerHtml), startMarker, endMarker));
             expect(result.trim().startsWith(`<!DOCTYPE html>`)).toBe(true);
         });
+        it("does not split an unclosed title tag across a chunk boundary", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+</head>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            // The ">" of the closing </title> arrives in the next chunk. A naive
+            // regex scan of the first chunk can falsely treat the "</title" as a
+            // non-hoisted tag boundary, leaving the <title> unclosed in <head>.
+            const innerHtmlChunks = [
+                `<title>Page Title</title`,
+                `><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).toMatch(/<head>[\s\S]*<title>Page Title<\/title>[\s\S]*<\/head>/);
+            expect(result).toContain(`<div>App content</div>`);
+            const titleIndex = result.indexOf(`<title>Page Title</title>`);
+            const headCloseIndex = result.indexOf(`</head>`);
+            const bodyIndex = result.indexOf(`<body>`);
+            expect(titleIndex).toBeLessThan(headCloseIndex);
+            expect(titleIndex).toBeLessThan(bodyIndex);
+        });
+        it("does not truncate a hoisted tag name across a chunk boundary", async () => {
+            const outerHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+</head>
+<body>
+  ${startMarker}
+  <script src="/client.js"></script>
+</body>
+</html>`;
+            // The "<title" tag name is split between chunks. A naive regex scan of
+            // the first chunk (ending at "<t") can falsely treat that "<" as a
+            // non-hoisted tag boundary and fail to hoist the title.
+            const innerHtmlChunks = [
+                `<t`,
+                `itle>Page Title</title><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).toMatch(/<head>[\s\S]*<title>Page Title<\/title>[\s\S]*<\/head>/);
+            expect(result).toContain(`<div>App content</div>`);
+            const titleIndex = result.indexOf(`<title>Page Title</title>`);
+            const headCloseIndex = result.indexOf(`</head>`);
+            expect(titleIndex).toBeLessThan(headCloseIndex);
+        });
     });
     describe("basic stitching flow", () => {
         it("stitches document head, app shell, and document tail", async () => {

package/dist/vite/configPlugin.d.mts

@@ -1,5 +1,8 @@
 import { Plugin } from "vite";
 import { ConfigurableEsbuildOptions } from "./runDirectivesScan.mjs";
+export declare const SSR_BRIDGE_ROLLDOWN_EXPERIMENTAL: {
+    lazyBarrel: boolean;
+};
 export declare const configPlugin: ({ silent, projectRootDir, workerEntryPathname, clientFiles, serverFiles, clientEntryPoints, esbuildOptions, }: {
     silent: boolean;
     projectRootDir: string;

package/dist/vite/configPlugin.mjs

@@ -4,6 +4,16 @@ import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
 import { buildApp } from "./buildApp.mjs";
 import { externalModules } from "./constants.mjs";
 import { ssrBridgeWrapPlugin } from "./ssrBridgeWrapPlugin.mjs";
+export const SSR_BRIDGE_ROLLDOWN_EXPERIMENTAL = {
+    // Rolldown's lazy barrel optimization can keep code that references imports it
+    // already pruned when `codeSplitting` is false. The SSR bridge intentionally
+    // disables code splitting, so keep lazy barrel off for this build until the
+    // upstream issue is fixed.
+    // See:
+    // - https://github.com/rolldown/rolldown/issues/9691#issuecomment-4666238497
+    // - https://github.com/rolldown/rolldown/issues/9964
+    lazyBarrel: false,
+};
 export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clientFiles, serverFiles, clientEntryPoints, esbuildOptions, }) => ({
     name: "rwsdk:config",
     enforce: "pre",
@@ -173,6 +183,7 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                         },
                         outDir: path.dirname(INTERMEDIATE_SSR_BRIDGE_PATH),
                         rolldownOptions: {
+                            experimental: SSR_BRIDGE_ROLLDOWN_EXPERIMENTAL,
                             output: {
                                 // context(justinvdm, 15 Sep 2025): The SSR bundle is a
                                 // pre-compiled artifact. When the linker pass bundles it into

package/dist/vite/configPlugin.test.d.mts

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

package/dist/vite/configPlugin.test.mjs

@@ -0,0 +1,73 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { build } from "vite";
+import { describe, expect, it } from "vitest";
+import { SSR_BRIDGE_ROLLDOWN_EXPERIMENTAL } from "./configPlugin.mjs";
+describe("SSR bridge Rolldown options", () => {
+    it("keeps side-effect-free barrels valid when code splitting is disabled", async () => {
+        const root = await mkdtemp(path.join(tmpdir(), "rwsdk-ssr-bridge-lazy-barrel-"));
+        try {
+            await mkdir(path.join(root, "src", "lib"), { recursive: true });
+            await writeFile(path.join(root, "package.json"), JSON.stringify({ type: "module", private: true, sideEffects: false }));
+            await writeFile(path.join(root, "src", "lib", "eg.js"), `const primitives = { string: { tag: "s" }, number: { tag: "n" } };
+const higher = { object: (shape) => ({ tag: "o", shape, parse: () => true }) };
+export const eg = { ...primitives, ...higher };
+`);
+            await writeFile(path.join(root, "src", "lib", "account.js"), `import { eg } from "./eg.js";
+export const AccountSettings = eg.object({ a: eg.string, n: eg.number });
+export const AccountMeta = eg.object({ b: eg.string });
+`);
+            await writeFile(path.join(root, "src", "lib", "index.js"), `export * from "./account.js";
+export const objectKeys = (o) => Object.keys(o);
+`);
+            await writeFile(path.join(root, "src", "story.js"), `import { objectKeys } from "./lib/index.js";
+export const run = () => (objectKeys ? "ok" : "no");
+`);
+            await writeFile(path.join(root, "src", "entry.cjs"), `const { run } = require("./story.js");
+console.log(run());
+`);
+            await build({
+                configFile: false,
+                root,
+                logLevel: "silent",
+                build: {
+                    ssr: true,
+                    minify: true,
+                    outDir: path.join(root, "dist"),
+                    emptyOutDir: true,
+                    lib: {
+                        entry: {
+                            index: path.join(root, "src", "entry.cjs"),
+                        },
+                        formats: ["es"],
+                        fileName: () => "index.js",
+                    },
+                    rolldownOptions: {
+                        experimental: SSR_BRIDGE_ROLLDOWN_EXPERIMENTAL,
+                        output: {
+                            codeSplitting: false,
+                        },
+                    },
+                },
+            });
+            const outputPath = path.join(root, "dist", "index.js");
+            const logs = [];
+            const originalLog = console.log;
+            console.log = (...args) => {
+                logs.push(args.join(" "));
+            };
+            try {
+                await import(pathToFileURL(outputPath).href);
+            }
+            finally {
+                console.log = originalLog;
+            }
+            expect(logs).toContain("ok");
+        }
+        finally {
+            await rm(root, { recursive: true, force: true });
+        }
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.5.3",
+  "version": "1.5.5",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {