npm - rwsdk - Versions diffs - 1.0.0-beta.27-test.20251116215153 → 1.0.0-beta.29 - Mend

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

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 (30) hide show

package/dist/lib/e2e/environment.mjs +6 -1
package/dist/lib/e2e/release.d.mts +1 -0
package/dist/lib/e2e/release.mjs +16 -3
package/dist/lib/e2e/tarball.mjs +3 -10
package/dist/lib/e2e/testHarness.mjs +6 -3
package/dist/runtime/lib/db/typeInference/builders/alterTable.d.ts +13 -3
package/dist/runtime/lib/db/typeInference/builders/columnDefinition.d.ts +34 -20
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 +102 -1
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 +18 -25
package/dist/runtime/lib/links.js +70 -42
package/dist/runtime/lib/links.test.d.ts +1 -0
package/dist/runtime/lib/links.test.js +20 -0
package/dist/runtime/lib/realtime/worker.d.ts +1 -1
package/dist/runtime/lib/router.d.ts +23 -9
package/dist/runtime/lib/router.js +14 -36
package/dist/runtime/lib/stitchDocumentAndAppStreams.d.ts +66 -0
package/dist/runtime/lib/stitchDocumentAndAppStreams.js +167 -28
package/dist/runtime/lib/stitchDocumentAndAppStreams.test.js +43 -9
package/dist/runtime/worker.d.ts +3 -1
package/dist/runtime/worker.js +1 -0
package/dist/use-synced-state/worker.d.mts +1 -1
package/dist/vite/constants.d.mts +1 -0
package/dist/vite/constants.mjs +1 -0
package/dist/vite/ssrBridgePlugin.mjs +9 -0
package/package.json +2 -2

package/dist/runtime/lib/stitchDocumentAndAppStreams.js CHANGED Viewed

@@ -105,6 +105,72 @@ function splitStreamOnFirstNonHoistedTag(sourceStream) {
     });
     return [hoistedTagsStream, appBodyStream];
 }
+/**
+ * A utility that orchestrates and interleaves three ReadableStreams to produce a
+ * single, valid HTML response stream. It uses two special markers:
+ *
+ * - `startMarker`: Placed in the `outerHtml` stream (the document shell) to
+ *   designate where the application's content should be injected.
+ * - `endMarker`: Injected into the `innerHtml` stream's RSC payload to signal
+ *   the end of the initial, non-suspended render. This marker is needed for
+ *   non-blocking hydration, as it allows the stitching process to send the
+ *   client `<script>` tags before all suspended content has resolved.
+ *
+ * It manages three main stream readers:
+ *
+ * - `hoistedTagsReader`: Reads from the `hoistedTagsStream`, which contains only
+ *   the hoisted meta tags (e.g., `<title>`, `<meta>`).
+ * - `outerReader`: Reads from the `outerHtml` stream, which is the server-rendered
+ *   document shell (containing `<html>`, `<head>`, etc.).
+ * - `innerReader`: Reads from the `appBodyStream`, which contains the main
+ *   application content, stripped of its hoisted tags.
+ *
+ * The function proceeds through a multi-phase state machine, managed by the
+ * `pump` function, to correctly interleave these streams.
+ *
+ * The state machine moves through the following phases:
+ *
+ * 1. `read-hoisted`:
+ *    - **Goal:** Buffer all hoisted tags from the `hoistedTagsStream`.
+ *    - **Action:** Reads from `hoistedTagsReader` and appends all content into
+ *      the `hoistedTagsBuffer`. Does not enqueue anything yet.
+ *    - **Transition:** Moves to `outer-head` when the stream is exhausted.
+ *
+ * 2. `outer-head`:
+ *    - **Goal:** Stream the document up to the closing `</head>` tag, inject the
+ *      hoisted tags, and then continue until the app `startMarker`.
+ *    - **Action:** Reads from `outerReader`. When it finds `</head>`, it enqueues
+ *      the content before it, then enqueues the `hoistedTagsBuffer`, and finally
+ *      enqueues the `</head>` tag itself. It then continues reading from
+ *      `outerReader` until it finds the `startMarker`.
+ *    - **Transition:** Moves to `inner-shell` after finding and discarding the
+ *      `startMarker`.
+ *
+ * 3. `inner-shell`:
+ *    - **Goal:** Stream the initial, non-suspended part of the application.
+ *    - **Action:** Switches to `innerReader`. It enqueues chunks until it finds
+ *      the `endMarker`. Any content after the marker is stored in
+ *      `innerSuspendedRemains`.
+ *    - **Transition:** Moves to `outer-tail` after finding the `endMarker`.
+ *
+ * 4. `outer-tail`:
+ *    - **Goal:** Stream the rest of the document's `<body>`, including client
+ *      `<script>` tags.
+ *    - **Action:** Switches back to `outerReader` and enqueues chunks until it
+ *      finds the `</body>` tag.
+ *    - **Transition:** Moves to `inner-suspended` after finding `</body>`.
+ *
+ * 5. `inner-suspended`:
+ *    - **Goal:** Stream any suspended content from the React app.
+ *    - **Action:** First enqueues any content from `innerSuspendedRemains`, then
+ *      continues reading from `innerReader` until the stream is exhausted.
+ *    - **Transition:** Moves to `outer-end` when the stream is exhausted.
+ *
+ * 6. `outer-end`:
+ *    - **Goal:** Finish the document.
+ *    - **Action:** Switches back to `outerReader` for the last time to send the
+ *      closing `</body>` and `</html>` tags.
+ */
 export function stitchDocumentAndAppStreams(outerHtml, innerHtml, startMarker, endMarker) {
     const [hoistedTagsStream, appBodyStream] = splitStreamOnFirstNonHoistedTag(innerHtml);
     const decoder = new TextDecoder();
@@ -115,138 +181,211 @@ export function stitchDocumentAndAppStreams(outerHtml, innerHtml, startMarker, e
     let buffer = "";
     let outerBufferRemains = "";
     let innerSuspendedRemains = "";
-    let phase = "enqueue-hoisted";
+    let hoistedTagsBuffer = "";
+    let hoistedTagsReady = false;
+    let phase = "read-hoisted";
     const pump = async (controller) => {
+        const enqueue = (text) => {
+            if (text) {
+                controller.enqueue(encoder.encode(text));
+            }
+        };
+        const flush = () => {
+            const flushIndex = buffer.lastIndexOf("\n");
+            if (flushIndex !== -1) {
+                enqueue(buffer.slice(0, flushIndex + 1));
+                buffer = buffer.slice(flushIndex + 1);
+            }
+        };
         try {
-            if (phase === "enqueue-hoisted") {
+            if (phase === "read-hoisted") {
+                // Continuously read from the hoisted tags stream and buffer the
+                // content. Once the stream is finished, transition to the next phase.
                 const { done, value } = await hoistedTagsReader.read();
+                // When the stream is done, we're ready to process the document head.
                 if (done) {
+                    hoistedTagsReady = true;
                     phase = "outer-head";
                 }
                 else {
-                    controller.enqueue(value);
+                    // Otherwise, keep appending to the buffer.
+                    hoistedTagsBuffer += decoder.decode(value, { stream: true });
                 }
             }
             else if (phase === "outer-head") {
+                // Read from the document stream. Search for the closing `</head>` tag
+                // to inject the buffered hoisted tags. Then, search for the
+                // `startMarker` to know when to start injecting the app shell. Once
+                // the marker is found, transition to the next phase.
                 const { done, value } = await outerReader.read();
+                // Handle the case where the document stream ends.
                 if (done) {
+                    // If there's content left in the buffer, process it for markers.
                     if (buffer) {
+                        const headCloseIndex = buffer.indexOf("</head>");
+                        if (headCloseIndex !== -1 &&
+                            hoistedTagsReady &&
+                            hoistedTagsBuffer) {
+                            enqueue(buffer.slice(0, headCloseIndex));
+                            enqueue(hoistedTagsBuffer);
+                            hoistedTagsBuffer = "";
+                            enqueue("</head>");
+                            buffer = buffer.slice(headCloseIndex + "</head>".length);
+                        }
                         const markerIndex = buffer.indexOf(startMarker);
                         if (markerIndex !== -1) {
-                            controller.enqueue(encoder.encode(buffer.slice(0, markerIndex)));
+                            enqueue(buffer.slice(0, markerIndex));
                             outerBufferRemains = buffer.slice(markerIndex + startMarker.length);
                         }
                         else {
-                            controller.enqueue(encoder.encode(buffer));
+                            enqueue(buffer);
                         }
                         buffer = "";
                     }
+                    else if (hoistedTagsReady && hoistedTagsBuffer) {
+                        enqueue(hoistedTagsBuffer);
+                        hoistedTagsBuffer = "";
+                    }
+                    // Even if the stream ends, we must proceed to the app shell phase.
                     phase = "inner-shell";
                 }
                 else {
+                    // As chunks arrive, append them to the buffer.
                     buffer += decoder.decode(value, { stream: true });
+                    // Search for the closing head tag to inject hoisted tags.
+                    const headCloseIndex = buffer.indexOf("</head>");
+                    if (headCloseIndex !== -1 && hoistedTagsReady && hoistedTagsBuffer) {
+                        enqueue(buffer.slice(0, headCloseIndex));
+                        enqueue(hoistedTagsBuffer);
+                        hoistedTagsBuffer = "";
+                        enqueue("</head>");
+                        buffer = buffer.slice(headCloseIndex + "</head>".length);
+                    }
+                    // Search for the start marker to switch to the app stream.
                     const markerIndex = buffer.indexOf(startMarker);
                     if (markerIndex !== -1) {
-                        controller.enqueue(encoder.encode(buffer.slice(0, markerIndex)));
+                        enqueue(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);
-                        }
+                        // If no marker is found yet, flush the buffer up to the last
+                        // newline to keep the stream flowing.
+                        flush();
                     }
                 }
             }
             else if (phase === "inner-shell") {
+                // Now read from the app stream. We send the initial part of the app
+                // content until we find the `endMarker`. This marker tells us that the
+                // non-suspended part of the app is rendered. Any content after this
+                // marker is considered suspended and is buffered. Then, transition.
                 const { done, value } = await innerReader.read();
+                // Handle the case where the app stream ends.
                 if (done) {
                     if (buffer)
-                        controller.enqueue(encoder.encode(buffer));
+                        enqueue(buffer);
                     phase = "outer-tail";
                 }
                 else {
+                    // As chunks arrive, append them to the buffer.
                     buffer += decoder.decode(value, { stream: true });
                     const markerIndex = buffer.indexOf(endMarker);
+                    // If the end marker is found, enqueue content up to the marker,
+                    // buffer the rest, and switch to the document tail phase.
                     if (markerIndex !== -1) {
                         const endOfMarkerIndex = markerIndex + endMarker.length;
-                        controller.enqueue(encoder.encode(buffer.slice(0, endOfMarkerIndex)));
+                        enqueue(buffer.slice(0, endOfMarkerIndex));
                         innerSuspendedRemains = buffer.slice(endOfMarkerIndex);
                         buffer = "";
                         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);
-                        }
+                        // If no marker is found yet, flush the buffer.
+                        flush();
                     }
                 }
             }
             else if (phase === "outer-tail") {
+                // Switch back to the document stream. The goal is to send the rest of
+                // the document's body, which critically includes the client-side
+                // `<script>` tags for hydration. We stream until we find the closing
+                // `</body>` tag and then transition.
+                // First, process any leftover buffer from the `outer-head` phase.
                 if (outerBufferRemains) {
                     buffer = outerBufferRemains;
                     outerBufferRemains = "";
                 }
                 const { done, value } = await outerReader.read();
+                // Handle the case where the document stream ends.
                 if (done) {
                     if (buffer) {
+                        // Search the remaining buffer for the closing body tag.
                         const markerIndex = buffer.indexOf("</body>");
                         if (markerIndex !== -1) {
-                            controller.enqueue(encoder.encode(buffer.slice(0, markerIndex)));
+                            enqueue(buffer.slice(0, markerIndex));
                             buffer = buffer.slice(markerIndex);
                         }
                         else {
-                            controller.enqueue(encoder.encode(buffer));
+                            enqueue(buffer);
                             buffer = "";
                         }
                     }
+                    // Proceed to the suspended content phase.
                     phase = "inner-suspended";
                 }
                 else {
+                    // As chunks arrive, append them to the buffer.
                     buffer += decoder.decode(value, { stream: true });
+                    // Search for the closing body tag to switch to suspended content.
                     const markerIndex = buffer.indexOf("</body>");
                     if (markerIndex !== -1) {
-                        controller.enqueue(encoder.encode(buffer.slice(0, markerIndex)));
+                        enqueue(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);
-                        }
+                        // If no marker is found yet, flush the buffer.
+                        flush();
                     }
                 }
             }
             else if (phase === "inner-suspended") {
+                // Switch back to the app stream. First, send any buffered suspended
+                // content from the `inner-shell` phase. Then, stream the rest of the
+                // app content until it's finished. This is all the content that was
+                // behind a `<Suspense>` boundary.
+                // First, send any buffered suspended content from the `inner-shell` phase.
                 if (innerSuspendedRemains) {
-                    controller.enqueue(encoder.encode(innerSuspendedRemains));
+                    enqueue(innerSuspendedRemains);
                     innerSuspendedRemains = "";
                 }
                 const { done, value } = await innerReader.read();
+                // When the app stream is done, transition to the final phase.
                 if (done) {
                     phase = "outer-end";
                 }
                 else {
+                    // Otherwise, pass through the remaining app content directly.
                     controller.enqueue(value);
                 }
             }
             else if (phase === "outer-end") {
+                // Finally, switch back to the document stream one last time to send
+                // the closing `</body>` and `</html>` tags and finish the response.
+                // First, send any leftover buffer from the `outer-tail` phase.
                 if (buffer) {
-                    controller.enqueue(encoder.encode(buffer));
+                    enqueue(buffer);
                     buffer = "";
                 }
                 const { done, value } = await outerReader.read();
+                // When the document stream is done, we're finished.
                 if (done) {
                     controller.close();
                     return;
                 }
+                // Otherwise, pass through the final document content.
                 controller.enqueue(value);
             }
             await pump(controller);

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

@@ -45,7 +45,7 @@ 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 () => {
+        it("places hoisted tags inside head, after existing head content", async () => {
             const outerHtml = `<!DOCTYPE html>
 <html>
 <head>
@@ -59,10 +59,19 @@ describe("stitchDocumentAndAppStreams", () => {
             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).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("extracts and prepends multiple hoisted tags", async () => {
+        it("places multiple hoisted tags inside head, after existing head content", async () => {
             const outerHtml = `<!DOCTYPE html>
 <html>
 <head>
@@ -78,9 +87,14 @@ describe("stitchDocumentAndAppStreams", () => {
             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);
+            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>
@@ -117,9 +131,29 @@ describe("stitchDocumentAndAppStreams", () => {
             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);
+            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", () => {

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

@@ -8,9 +8,11 @@ declare global {
         DB: D1Database;
     };
 }
-export declare const defineApp: <T extends RequestInfo = RequestInfo<any, DefaultAppContext>>(routes: Route<T>[]) => {
+export type AppDefinition<Routes extends readonly Route<any>[], T extends RequestInfo> = {
     fetch: (request: Request, env: Env, cf: ExecutionContext) => Promise<Response>;
+    __rwRoutes: Routes;
 };
+export declare const defineApp: <T extends RequestInfo = RequestInfo<any, DefaultAppContext>, Routes extends readonly Route<T>[] = readonly Route<T>[]>(routes: Routes) => AppDefinition<Routes, T>;
 export declare const DefaultDocument: React.FC<{
     children: React.ReactNode;
 }>;

package/dist/runtime/worker.js CHANGED Viewed

@@ -12,6 +12,7 @@ import { generateNonce } from "./lib/utils";
 export * from "./requestInfo/types";
 export const defineApp = (routes) => {
     return {
+        __rwRoutes: routes,
         fetch: async (request, env, cf) => {
             globalThis.__webpack_require__ = ssrWebpackRequire;
             const router = defineRoutes(routes);

package/dist/use-synced-state/worker.d.mts CHANGED Viewed

@@ -11,4 +11,4 @@ export type SyncStateRouteOptions = {
  * @param options Optional overrides for base path, reset path, and object name.
  * @returns Router entries for the sync state API and reset endpoint.
  */
-export declare const syncStateRoutes: (getNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<SyncStateServer>, options?: SyncStateRouteOptions) => import("../runtime/lib/router.js").RouteDefinition<import("../runtime/worker.js").RequestInfo<any, import("../runtime/worker.js").DefaultAppContext>>[];
+export declare const syncStateRoutes: (getNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<SyncStateServer>, options?: SyncStateRouteOptions) => import("../runtime/lib/router.js").RouteDefinition<`/${string}`, import("../runtime/worker.js").RequestInfo<any, import("../runtime/worker.js").DefaultAppContext>>[];

package/dist/vite/constants.d.mts CHANGED Viewed

@@ -1,2 +1,3 @@
 export declare const cloudflareBuiltInModules: string[];
 export declare const externalModules: string[];
+export declare const externalModulesSet: Set<string>;

package/dist/vite/constants.mjs CHANGED Viewed

@@ -10,3 +10,4 @@ export const externalModules = [
     ...builtinModules,
     ...builtinModules.map((m) => `node:${m}`),
 ];
+export const externalModulesSet = new Set(externalModules);

package/dist/vite/ssrBridgePlugin.mjs CHANGED Viewed

@@ -1,6 +1,7 @@
 import debug from "debug";
 import MagicString from "magic-string";
 import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
+import { externalModulesSet } from "./constants.mjs";
 import { findSsrImportCallSites } from "./findSsrSpecifiers.mjs";
 const log = debug("rwsdk:vite:ssr-bridge-plugin");
 export const VIRTUAL_SSR_PREFIX = "virtual:rwsdk:ssr:";
@@ -184,6 +185,14 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                                 const normalized = site.specifier.startsWith("/@id/")
                                     ? site.specifier.slice("/@id/".length)
                                     : site.specifier;
+                                // If the import is for a known external module, we must leave it
+                                // as a bare specifier. Rewriting it with any prefix (`/@id/` or
+                                // our virtual one) will break Vite's default externalization.
+                                if (externalModulesSet.has(normalized)) {
+                                    const replacement = `import("${normalized}")`;
+                                    s.overwrite(site.start, site.end, replacement);
+                                    continue;
+                                }
                                 // context(justinvdm, 11 Aug 2025):
                                 // - We replace __vite_ssr_import__ and __vite_ssr_dynamic_import__
                                 //   with import() calls so that the module graph can be built

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.0-beta.27-test.20251116215153",
+  "version": "1.0.0-beta.29",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -167,7 +167,7 @@
     "find-up": "~8.0.0",
     "fs-extra": "~11.3.0",
     "get-port": "^7.1.0",
-    "glob": "~11.0.1",
+    "glob": "~11.1.0",
     "ignore": "~7.0.4",
     "jsonc-parser": "~3.3.1",
     "kysely": "~0.28.2",