rwsdk 0.1.10 → 0.1.12

package/dist/runtime/render/renderRscThenableToHtmlStream.js

@@ -23,10 +23,13 @@ export const renderRscThenableToHtmlStream = async ({ thenable, Document, reques
         nonce: requestInfo.rw.nonce,
         onError(error, { componentStack }) {
             try {
+                if (!error) {
+                    error = new Error(`A falsy value was thrown during rendering: ${String(error)}.`);
+                }
                 const message = error
                     ? (error.stack ?? error.message ?? error)
                     : error;
-                const wrappedMessage = `Error rendering RSC to HTML stream: ${message}\n\nComponent stack:\n${componentStack}`;
+                const wrappedMessage = `${message}\n\nComponent stack:${componentStack}`;
                 if (error instanceof Error) {
                     const wrappedError = new Error(wrappedMessage);
                     wrappedError.stack = error.stack;

package/dist/scripts/debug-sync.mjs

@@ -136,7 +136,15 @@ export const debugSync = async (opts) => {
         throw e;
     }
     // Initial sync for watch mode. We do it *after* acquiring the lock.
-    await performSync(sdkDir, targetDir);
+    let initialSyncOk = false;
+    try {
+        await performSync(sdkDir, targetDir);
+        initialSyncOk = true;
+    }
+    catch (error) {
+        console.error("❌ Initial sync failed:", error);
+        console.log("   Still watching for changes...");
+    }
     const filesToWatch = [
         path.join(sdkDir, "src"),
         path.join(sdkDir, "types"),
@@ -169,8 +177,14 @@ export const debugSync = async (opts) => {
                 /* ignore kill errors */
             });
         }
-        await performSync(sdkDir, targetDir);
-        runWatchedCommand();
+        try {
+            await performSync(sdkDir, targetDir);
+            runWatchedCommand();
+        }
+        catch (error) {
+            console.error("❌ Sync failed:", error);
+            console.log("   Still watching for changes...");
+        }
     });
     const cleanup = async () => {
         console.log("\nCleaning up...");
@@ -182,7 +196,9 @@ export const debugSync = async (opts) => {
     };
     process.on("SIGINT", cleanup);
     process.on("SIGTERM", cleanup);
-    runWatchedCommand();
+    if (initialSyncOk) {
+        runWatchedCommand();
+    }
 };
 if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
     const args = process.argv.slice(2);

package/dist/vite/directivesPlugin.mjs

@@ -4,7 +4,6 @@ import debug from "debug";
 import { transformClientComponents } from "./transformClientComponents.mjs";
 import { transformServerFunctions } from "./transformServerFunctions.mjs";
 import { normalizeModulePath } from "./normalizeModulePath.mjs";
-import { invalidateModule } from "./invalidateModule.mjs";
 const log = debug("rwsdk:vite:rsc-directives-plugin");
 const verboseLog = debug("verbose:rwsdk:vite:rsc-directives-plugin");
 const getLoader = (filePath) => {
@@ -48,7 +47,7 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
             devServer.environments[environment].depsOptimizer?.registerMissingImport(resolvedId, fullPath);
             if (isAfterFirstResponse && !hadFile) {
                 log("Invalidating cache for lookup module %s after adding module id=%s", lookupModule, id);
-                invalidateModule(devServer, environment, `virtual:use-${kind}-lookup`);
+                //invalidateModule(devServer, environment, `virtual:use-${kind}-lookup`);
             }
         }
     };

package/dist/vite/findSsrSpecifiers.d.mts

@@ -0,0 +1,11 @@
+/**
+ * Finds __vite_ssr_import__ and __vite_ssr_dynamic_import__ specifiers in the code.
+ * @param id The file identifier for language detection.
+ * @param code The code to search for SSR imports.
+ * @param log Optional logger function for debug output.
+ * @returns Object with arrays of static and dynamic import specifiers.
+ */
+export declare function findSsrImportSpecifiers(id: string, code: string, log?: (...args: any[]) => void): {
+    imports: string[];
+    dynamicImports: string[];
+};

package/dist/vite/findSsrSpecifiers.mjs

@@ -0,0 +1,51 @@
+import { parse as sgParse, Lang as SgLang, Lang } from "@ast-grep/napi";
+import path from "path";
+/**
+ * Finds __vite_ssr_import__ and __vite_ssr_dynamic_import__ specifiers in the code.
+ * @param id The file identifier for language detection.
+ * @param code The code to search for SSR imports.
+ * @param log Optional logger function for debug output.
+ * @returns Object with arrays of static and dynamic import specifiers.
+ */
+export function findSsrImportSpecifiers(id, code, log) {
+    const ext = path.extname(id).toLowerCase();
+    const lang = ext === ".tsx" || ext === ".jsx" ? Lang.Tsx : SgLang.TypeScript;
+    const logger = log ?? (() => { });
+    const imports = [];
+    const dynamicImports = [];
+    try {
+        const root = sgParse(lang, code);
+        const patterns = [
+            {
+                pattern: `__vite_ssr_import__("$SPECIFIER")`,
+                list: imports,
+            },
+            {
+                pattern: `__vite_ssr_import__('$SPECIFIER')`,
+                list: imports,
+            },
+            {
+                pattern: `__vite_ssr_dynamic_import__("$SPECIFIER")`,
+                list: dynamicImports,
+            },
+            {
+                pattern: `__vite_ssr_dynamic_import__('$SPECIFIER')`,
+                list: dynamicImports,
+            },
+        ];
+        for (const { pattern, list } of patterns) {
+            const matches = root.root().findAll(pattern);
+            for (const match of matches) {
+                const specifier = match.getMatch("SPECIFIER")?.text();
+                if (specifier) {
+                    list.push(specifier);
+                    logger(`Found SSR import specifier: %s in pattern: %s`, specifier, pattern);
+                }
+            }
+        }
+    }
+    catch (err) {
+        logger("Error parsing code for SSR imports: %O", err);
+    }
+    return { imports, dynamicImports };
+}

package/dist/vite/invalidateClientModule.d.mts

@@ -0,0 +1,2 @@
+import type { ViteDevServer } from "vite";
+export declare const invalidateClientModule: (devServer: ViteDevServer, filePath: string) => void;

package/dist/vite/invalidateClientModule.mjs

@@ -0,0 +1,8 @@
+import { invalidateModule } from "./invalidateModule.mjs";
+import { normalizeModulePath } from "./normalizeModulePath.mjs";
+import { VIRTUAL_SSR_PREFIX } from "./ssrBridgePlugin.mjs";
+export const invalidateClientModule = (devServer, filePath) => {
+    invalidateModule(devServer, "ssr", filePath);
+    invalidateModule(devServer, "client", filePath);
+    invalidateModule(devServer, "worker", VIRTUAL_SSR_PREFIX + normalizeModulePath(devServer.config.root, filePath));
+};

package/dist/vite/invalidateModule copy.d.mts

@@ -0,0 +1,2 @@
+import type { ViteDevServer } from "vite";
+export declare const invalidateModule: (devServer: ViteDevServer, environment: string, id: string) => void;

package/dist/vite/invalidateModule copy.mjs

@@ -0,0 +1,14 @@
+import debug from "debug";
+const log = debug("rwsdk:vite:invalidate-module");
+const verboseLog = debug("verbose:rwsdk:vite:invalidate-module");
+export const invalidateModule = (devServer, environment, id) => {
+    const [rawId, _query] = id.split("?");
+    log("Invalidating module: id=%s, environment=%s", id, environment);
+    const moduleNode = devServer?.environments[environment]?.moduleGraph.idToModuleMap.get(rawId);
+    if (moduleNode) {
+        devServer?.environments[environment]?.moduleGraph.invalidateModule(moduleNode);
+    }
+    else {
+        verboseLog("Module not found: id=%s, environment=%s", id, environment);
+    }
+};

package/dist/vite/invalidateSSRModule.d.mts

@@ -0,0 +1,2 @@
+import type { ViteDevServer } from "vite";
+export declare const invalidateSSRModule: (devServer: ViteDevServer, filePath: string) => void;

package/dist/vite/invalidateSSRModule.mjs

@@ -0,0 +1,7 @@
+import { invalidateModule } from "./invalidateModule.mjs";
+import { normalizeModulePath } from "./normalizeModulePath.mjs";
+import { VIRTUAL_SSR_PREFIX } from "./ssrBridgePlugin.mjs";
+export const invalidateSSRModule = (devServer, filePath) => {
+    invalidateModule(devServer, "ssr", filePath);
+    invalidateModule(devServer, "worker", VIRTUAL_SSR_PREFIX + normalizeModulePath(devServer.config.root, filePath));
+};

package/dist/vite/miniflareHMRPlugin.mjs

@@ -1,8 +1,12 @@
 import { resolve } from "node:path";
 import colors from "picocolors";
 import { readFile } from "node:fs/promises";
+import debug from "debug";
+import { VIRTUAL_SSR_PREFIX } from "./ssrBridgePlugin.mjs";
+import { normalizeModulePath } from "./normalizeModulePath.mjs";
 import { getShortName } from "../lib/getShortName.mjs";
 import { pathExists } from "fs-extra";
+const verboseLog = debug("verbose:rwsdk:vite:hmr-plugin");
 const hasEntryAsAncestor = (module, entryFile, seen = new Set()) => {
     // Prevent infinite recursion
     if (seen.has(module))
@@ -68,10 +72,11 @@ export const miniflareHMRPlugin = (givenOptions) => [
     {
         name: "rwsdk:miniflare-hmr",
         async hotUpdate(ctx) {
+            verboseLog("Hot update: (env=%s) %s\nModule graph:\n\n%s", this.environment.name, ctx.file, dumpFullModuleGraph(ctx.server, this.environment.name));
             const environment = givenOptions.viteEnvironment.name;
             const entry = givenOptions.workerEntryPathname;
             if (!["client", environment].includes(this.environment.name)) {
-                return;
+                return [];
             }
             // todo(justinvdm, 12 Dec 2024): Skip client references
             const modules = Array.from(ctx.server.environments[environment].moduleGraph.getModulesByFile(ctx.file) ?? []);
@@ -119,6 +124,11 @@ export const miniflareHMRPlugin = (givenOptions) => [
                 if (m) {
                     ctx.server.environments.client.moduleGraph.invalidateModule(m, new Set(), ctx.timestamp, true);
                 }
+                const virtualSSRModule = ctx.server.environments[environment].moduleGraph.idToModuleMap.get(VIRTUAL_SSR_PREFIX +
+                    normalizeModulePath(givenOptions.rootDir, ctx.file));
+                if (virtualSSRModule) {
+                    ctx.server.environments.client.moduleGraph.invalidateModule(virtualSSRModule, new Set(), ctx.timestamp, true);
+                }
                 ctx.server.environments.client.hot.send({
                     type: "custom",
                     event: "rsc:update",
@@ -131,3 +141,35 @@ export const miniflareHMRPlugin = (givenOptions) => [
         },
     },
 ];
+function dumpFullModuleGraph(server, environment, { includeDisconnected = true } = {}) {
+    const moduleGraph = server.environments[environment].moduleGraph;
+    const seen = new Set();
+    const output = [];
+    function walk(node, depth = 0) {
+        const id = node.id || node.url;
+        if (!id || seen.has(id))
+            return;
+        seen.add(id);
+        const pad = "  ".repeat(depth);
+        const suffix = node.id?.startsWith("virtual:") ? " [virtual]" : "";
+        output.push(`${pad}- ${id}${suffix}`);
+        for (const dep of node.importedModules) {
+            walk(dep, depth + 1);
+        }
+    }
+    // Start with all modules with no importers (roots)
+    const roots = Array.from(moduleGraph.urlToModuleMap.values()).filter((mod) => mod.importers.size === 0);
+    for (const root of roots) {
+        walk(root);
+    }
+    // If requested, show disconnected modules too
+    if (includeDisconnected) {
+        for (const mod of moduleGraph.urlToModuleMap.values()) {
+            const id = mod.id || mod.url;
+            if (!seen.has(id)) {
+                output.push(`- ${id} [disconnected]`);
+            }
+        }
+    }
+    return output.join("\n");
+}

package/dist/vite/ssrBridgePlugin.mjs

@@ -1,6 +1,6 @@
 import debug from "debug";
 import { SSR_BRIDGE_PATH } from "../lib/constants.mjs";
-import { invalidateModule } from "./invalidateModule.mjs";
+import { findSsrImportSpecifiers } from "./findSsrSpecifiers.mjs";
 const log = debug("rwsdk:vite:ssr-bridge-plugin");
 const verboseLog = debug("verbose:rwsdk:vite:ssr-bridge-plugin");
 export const VIRTUAL_SSR_PREFIX = "virtual:rwsdk:ssr:";
@@ -54,7 +54,6 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                 // SSR modules, so we return the virtual id so that the dynamic loading
                 // can happen in load()
                 if (id.startsWith(VIRTUAL_SSR_PREFIX)) {
-                    invalidateModule(devServer, "worker", id);
                     log("Returning virtual SSR id for dev: %s", id);
                     return id;
                 }
@@ -65,7 +64,6 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                 if (id === "rwsdk/__ssr_bridge" && this.environment.name === "worker") {
                     const virtualId = `${VIRTUAL_SSR_PREFIX}${id}`;
                     log("Bridge module case (dev): id=%s matches rwsdk/__ssr_bridge in worker environment, returning virtual id=%s", id, virtualId);
-                    invalidateModule(devServer, "worker", virtualId);
                     return virtualId;
                 }
             }
@@ -96,9 +94,28 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                     }
                     const code = "code" in result ? result.code : undefined;
                     log("Fetched SSR module code length: %d", code?.length || 0);
-                    // context(justinvdm, 27 May 2025): Prefix all imports in SSR modules so that they're separate in module graph from non-SSR
+                    if (!code) {
+                        return;
+                    }
+                    const { imports, dynamicImports } = findSsrImportSpecifiers(realId, code, verboseLog);
+                    const allSpecifiers = [...new Set([...imports, ...dynamicImports])];
+                    const switchCases = allSpecifiers
+                        .map((specifier) => `    case "${specifier}": return import("${VIRTUAL_SSR_PREFIX}${specifier}");`)
+                        .join("\n");
                     const transformedCode = `
-await (async function(__vite_ssr_import__, __vite_ssr_dynamic_import__) {${code}})((id) => __vite_ssr_import__('/@id/${VIRTUAL_SSR_PREFIX}'+id), (id) => __vite_ssr_dynamic_import__('/@id/${VIRTUAL_SSR_PREFIX}'+id));
+await (async function(__vite_ssr_import__, __vite_ssr_dynamic_import__) {${code}})(
+  (id, ...args) => ssrImport(id, false, ...args),
+  (id, ...args) => ssrImport(id, true, ...args)
+);
+
+function ssrImport(id, isDynamic, ...args) {
+  switch (id) {
+${switchCases}
+  }
+
+  const virtualId = '/@id/${VIRTUAL_SSR_PREFIX}' + id;
+  return isDynamic ? __vite_ssr_dynamic_import__(virtualId, ...args) : __vite_ssr_import__(virtualId, ...args);
+}
 `;
                     log("Transformed SSR module code length: %d", transformedCode.length);
                     verboseLog("Transformed SSR module code for realId=%s: %s", realId, transformedCode);

package/package.json

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