rwsdk 0.1.28 → 0.2.0-alpha.1

package/dist/lib/smokeTests/templates/SmokeTestClient.template.js

@@ -3,6 +3,7 @@ export function getSmokeTestClientTemplate() {
 
 import React, { useState } from "react";
 import { smokeTestAction } from "./__smokeTestFunctions";
+import clientStyles from "./smokeTestClientStyles.module.css";
 
 interface SmokeTestStatus {
   status: string;
@@ -80,8 +81,22 @@ export const SmokeTestClient: React.FC = () => {
         {loading ? "Checking..." : "Run Smoke Test"}
       </button>
 
+      {/* Client Stylesheet Marker */}
+      <div
+        className="smoke-test-url-styles"
+        data-testid="smoke-test-url-styles"
+      >
+        <p>A red box should appear above this text (from URL import)</p>
+      </div>
+      <div
+        className={clientStyles.smokeTestClientStyles}
+        data-testid="smoke-test-client-styles"
+      >
+        <p>A blue box should appear above this text (from CSS module)</p>
+      </div>
+
       {/* HMR Testing Marker - Do not modify this comment */}
-      <div 
+      <div
         id="client-hmr-marker"
         data-testid="client-hmr-marker"
         data-hmr-text="original"
@@ -146,7 +161,7 @@ export const SmokeTestClient: React.FC = () => {
         </div>
       )}
 
-      <div 
+      <div
         id="smoke-test-client-timestamp"
         data-client-timestamp={lastCheck?.timestamp ?? ""}
         data-status={lastCheck?.status ?? ""}

package/dist/lib/smokeTests/templates/smokeTestClientStyles.module.css.template.d.ts

@@ -0,0 +1 @@
+export declare const template = "\n.smokeTestClientStyles {\n  /* This is a comment to test HMR */\n  background-color: rgb(0, 0, 255);\n  width: 100px;\n  height: 100px;\n}\n";

package/dist/lib/smokeTests/templates/smokeTestClientStyles.module.css.template.js

@@ -0,0 +1,9 @@
+/* eslint-disable quotes */
+export const template = `
+.smokeTestClientStyles {
+  /* This is a comment to test HMR */
+  background-color: rgb(0, 0, 255);
+  width: 100px;
+  height: 100px;
+}
+`;

package/dist/lib/smokeTests/templates/smokeTestUrlStyles.css.template.d.ts

@@ -0,0 +1 @@
+export declare const template = "\n.smoke-test-url-styles {\n  /* This is a comment to test HMR */\n  background-color: rgb(255, 0, 0);\n  width: 100px;\n  height: 100px;\n}\n";

package/dist/lib/smokeTests/templates/smokeTestUrlStyles.css.template.js

@@ -0,0 +1,9 @@
+/* eslint-disable quotes */
+export const template = `
+.smoke-test-url-styles {
+  /* This is a comment to test HMR */
+  background-color: rgb(255, 0, 0);
+  width: 100px;
+  height: 100px;
+}
+`;

package/dist/lib/smokeTests/types.d.mts

@@ -23,6 +23,7 @@ export interface SmokeTestOptions {
     copyProject?: boolean;
     realtime?: boolean;
     skipHmr?: boolean;
+    skipStyleTests?: boolean;
 }
 export interface TestResources {
     tempDirCleanup?: () => Promise<void>;

package/dist/runtime/lib/manifest.d.ts

@@ -0,0 +1,2 @@
+import { type RequestInfo } from "../requestInfo/types";
+export declare const getManifest: (requestInfo: RequestInfo) => Promise<Record<string, any>>;

package/dist/runtime/lib/manifest.js

@@ -0,0 +1,17 @@
+let manifest;
+export const getManifest = async (requestInfo) => {
+    if (manifest) {
+        return manifest;
+    }
+    if (import.meta.env.VITE_IS_DEV_SERVER) {
+        const url = new URL(requestInfo.request.url);
+        url.searchParams.set("scripts", JSON.stringify(Array.from(requestInfo.rw.scriptsToBeLoaded)));
+        url.pathname = "/__rwsdk_manifest";
+        manifest = await fetch(url.toString()).then((res) => res.json());
+    }
+    else {
+        const { default: prodManifest } = await import("virtual:rwsdk:manifest.js");
+        manifest = prodManifest;
+    }
+    return manifest;
+};

package/dist/runtime/lib/router.d.ts

@@ -15,6 +15,7 @@ export type RwContext = {
     ssr: boolean;
     layouts?: React.FC<LayoutProps<any>>[];
     databases: Map<string, Kysely<any>>;
+    scriptsToBeLoaded: Set<string>;
     pageRouteResolved: PromiseWithResolvers<void> | undefined;
 };
 export type RouteMiddleware<T extends RequestInfo = RequestInfo> = (requestInfo: T) => Response | Promise<Response> | void | Promise<void> | Promise<Response | void>;

package/dist/runtime/register/worker.js

@@ -1,5 +1,6 @@
 import { registerServerReference as baseRegisterServerReference, registerClientReference as baseRegisterClientReference, decodeReply, } from "react-server-dom-webpack/server.edge";
 import { getServerModuleExport } from "../imports/worker.js";
+import { requestInfo } from "../requestInfo/worker.js";
 export function registerServerReference(action, id, name) {
     if (typeof action !== "function") {
         return action;
@@ -12,11 +13,22 @@ export function registerClientReference(id, exportName, value) {
         ? value
         : () => null;
     const reference = baseRegisterClientReference({}, id, exportName);
-    return Object.defineProperties(wrappedValue, {
-        ...Object.getOwnPropertyDescriptors(reference),
-        $$async: { value: true },
-        $$isClientReference: { value: true },
-    });
+    const finalDescriptors = Object.getOwnPropertyDescriptors(reference);
+    const idDescriptor = finalDescriptors.$$id;
+    if (idDescriptor && idDescriptor.hasOwnProperty("value")) {
+        const originalValue = idDescriptor.value;
+        finalDescriptors.$$id = {
+            configurable: idDescriptor.configurable,
+            enumerable: idDescriptor.enumerable,
+            get() {
+                requestInfo.rw.scriptsToBeLoaded.add(id);
+                return originalValue;
+            },
+        };
+    }
+    finalDescriptors.$$async = { value: true };
+    finalDescriptors.$$isClientReference = { value: true };
+    return Object.defineProperties(wrappedValue, finalDescriptors);
 }
 export async function __smokeTestActionHandler(timestamp) {
     await new Promise((resolve) => setTimeout(resolve, 0));

package/dist/runtime/render/renderRscThenableToHtmlStream.d.ts

@@ -1,9 +1,9 @@
-import { type DocumentProps } from "../lib/router";
-import { type RequestInfo } from "../requestInfo/types";
+import { type DocumentProps } from "../lib/router.js";
+import { type RequestInfo } from "../requestInfo/types.js";
 export declare const renderRscThenableToHtmlStream: ({ thenable, Document, requestInfo, shouldSSR, onError, }: {
     thenable: any;
     Document: React.FC<DocumentProps>;
     requestInfo: RequestInfo;
     shouldSSR: boolean;
     onError: (error: unknown) => void;
-}) => Promise<import("react-dom/server").ReactDOMServerReadableStream>;
+}) => Promise<import("react-dom/server.js").ReactDOMServerReadableStream>;

package/dist/runtime/render/renderRscThenableToHtmlStream.js

@@ -1,9 +1,13 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { use } from "react";
 import { renderToReadableStream } from "react-dom/server.edge";
+import { Stylesheets } from "./stylesheets.js";
 export const renderRscThenableToHtmlStream = async ({ thenable, Document, requestInfo, shouldSSR, onError, }) => {
     const Component = () => {
-        const node = use(thenable).node;
+        const RscApp = () => {
+            const node = use(thenable).node;
+            return (_jsxs(_Fragment, { children: [_jsx(Stylesheets, { requestInfo: requestInfo }), _jsx("div", { id: "hydrate-root", children: node })] }));
+        };
         // todo(justinvdm, 18 Jun 2025): We can build on this later to allow users
         // surface context. e.g:
         // * we assign `user: requestInfo.clientCtx` here
@@ -17,7 +21,7 @@ export const renderRscThenableToHtmlStream = async ({ thenable, Document, reques
         };
         return (_jsxs(Document, { ...requestInfo, children: [_jsx("script", { nonce: requestInfo.rw.nonce, dangerouslySetInnerHTML: {
                         __html: `globalThis.__RWSDK_CONTEXT = ${JSON.stringify(clientContext)}`,
-                    } }), _jsx("div", { id: "hydrate-root", children: node })] }));
+                    } }), _jsx(RscApp, {})] }));
     };
     return await renderToReadableStream(_jsx(Component, {}), {
         nonce: requestInfo.rw.nonce,

package/dist/runtime/render/stylesheets.d.ts

@@ -0,0 +1,9 @@
+import { type RequestInfo } from "../requestInfo/types.js";
+export type CssEntry = {
+    url: string;
+    content: string;
+    absolutePath: string;
+};
+export declare const Stylesheets: ({ requestInfo }: {
+    requestInfo: RequestInfo;
+}) => import("react/jsx-runtime.js").JSX.Element;

package/dist/runtime/render/stylesheets.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { use } from "react";
+import { getManifest } from "../lib/manifest.js";
+const findCssForModule = (scriptId, manifest) => {
+    const css = new Set();
+    const visited = new Set();
+    const inner = (id) => {
+        if (visited.has(id)) {
+            return;
+        }
+        visited.add(id);
+        const entry = manifest[id];
+        if (!entry) {
+            return;
+        }
+        if (entry.css) {
+            for (const href of entry.css) {
+                css.add(href);
+            }
+        }
+    };
+    inner(scriptId);
+    return Array.from(css);
+};
+export const Stylesheets = ({ requestInfo }) => {
+    const manifest = use(getManifest(requestInfo));
+    const allStylesheets = new Set();
+    for (const scriptId of requestInfo.rw.scriptsToBeLoaded) {
+        const css = findCssForModule(scriptId, manifest);
+        for (const entry of css) {
+            allStylesheets.add(entry);
+        }
+    }
+    return (_jsx(_Fragment, { children: Array.from(allStylesheets).map((entry) => {
+            if (typeof entry === "string") {
+                return (_jsx("link", { rel: "stylesheet", href: entry, precedence: "first" }, entry));
+            }
+            if (import.meta.env.VITE_IS_DEV_SERVER) {
+                return (_jsx("style", { "data-vite-dev-id": entry.absolutePath, dangerouslySetInnerHTML: { __html: entry.content } }, entry.url));
+            }
+            else {
+                return (_jsx("link", { rel: "stylesheet", href: entry.url, precedence: "first" }, entry.url));
+            }
+        }) }));
+};

package/dist/runtime/worker.js

@@ -41,6 +41,7 @@ export const defineApp = (routes) => {
                     rscPayload: true,
                     ssr: true,
                     databases: new Map(),
+                    scriptsToBeLoaded: new Set(),
                     pageRouteResolved: undefined,
                 };
                 const outerRequestInfo = {

package/dist/scripts/debug-sync.mjs

@@ -24,6 +24,93 @@ const getPackageManagerInfo = (targetDir) => {
     }
     return pnpmResult;
 };
+/**
+ * @summary Workaround for pnpm's local tarball dependency resolution.
+ *
+ * @description
+ * When installing a new version of the SDK from a local tarball (e.g., during
+ * development with `rwsync`), pnpm creates a new, uniquely-named directory in
+ * the `.pnpm` store (e.g., `rwsdk@file+...`).
+ *
+ * A challenge arises when other packages list `rwsdk` as a peer dependency.
+ * pnpm may not consistently update the symlinks for these peer dependencies
+ * to point to the newest `rwsdk` instance. This can result in a state where
+ * multiple versions of `rwsdk` coexist in `node_modules`, with some parts of
+ * the application using a stale version.
+ *
+ * This function addresses the issue by:
+ * 1. Identifying the most recently installed `rwsdk` instance in the `.pnpm`
+ *    store after a `pnpm install` run.
+ * 2. Forcefully updating the top-level `node_modules/rwsdk` symlink to point
+ *    to this new instance.
+ * 3. Traversing all other `rwsdk`-related directories in the `.pnpm` store
+ *    and updating their internal `rwsdk` symlinks to also point to the correct
+ *    new instance.
+ *
+ * I am sorry for this ugly hack, I am sure there is a better way, and that it is me
+ * doing something wrong. The aim is not to go down this rabbit hole right now
+ * -- @justinvdm
+ */
+const hackyPnpmSymlinkFix = async (targetDir) => {
+    console.log("💣 Performing pnpm symlink fix...");
+    const pnpmDir = path.join(targetDir, "node_modules", ".pnpm");
+    if (!existsSync(pnpmDir)) {
+        console.log("   🤔 No .pnpm directory found.");
+        return;
+    }
+    try {
+        const entries = await fs.readdir(pnpmDir);
+        // Find ALL rwsdk directories, not just file-based ones, to handle
+        // all kinds of stale peer dependencies.
+        const rwsdkDirs = entries.filter((e) => e.startsWith("rwsdk@"));
+        console.log("   Found rwsdk directories:", rwsdkDirs);
+        if (rwsdkDirs.length === 0) {
+            console.log("   🤔 No rwsdk directories found to hack.");
+            return;
+        }
+        let latestDir = "";
+        let latestMtime = new Date(0);
+        for (const dir of rwsdkDirs) {
+            const fullPath = path.join(pnpmDir, dir);
+            const stats = await fs.stat(fullPath);
+            if (stats.mtime > latestMtime) {
+                latestMtime = stats.mtime;
+                latestDir = dir;
+            }
+        }
+        console.log("   Latest rwsdk directory:", latestDir);
+        if (!latestDir) {
+            console.log("   🤔 Could not determine the latest rwsdk directory.");
+            return;
+        }
+        const goldenSourcePath = path.join(pnpmDir, latestDir, "node_modules", "rwsdk");
+        if (!existsSync(goldenSourcePath)) {
+            console.error(`   ❌ Golden source path does not exist: ${goldenSourcePath}`);
+            return;
+        }
+        console.log(`   🎯 Golden rwsdk path is: ${goldenSourcePath}`);
+        // 1. Fix top-level symlink
+        const topLevelSymlink = path.join(targetDir, "node_modules", "rwsdk");
+        await fs.rm(topLevelSymlink, { recursive: true, force: true });
+        await fs.symlink(goldenSourcePath, topLevelSymlink, "dir");
+        console.log(`   ✅ Symlinked ${topLevelSymlink} -> ${goldenSourcePath}`);
+        // 2. Fix peer dependency symlinks
+        const allPnpmDirs = await fs.readdir(pnpmDir);
+        for (const dir of allPnpmDirs) {
+            if (dir === latestDir || !dir.includes("rwsdk"))
+                continue;
+            const peerSymlink = path.join(pnpmDir, dir, "node_modules", "rwsdk");
+            if (existsSync(peerSymlink)) {
+                await fs.rm(peerSymlink, { recursive: true, force: true });
+                await fs.symlink(goldenSourcePath, peerSymlink, "dir");
+                console.log(`   ✅ Hijacked symlink in ${dir}`);
+            }
+        }
+    }
+    catch (error) {
+        console.error("   ❌ Failed during hacky pnpm symlink fix:", error);
+    }
+};
 const performFullSync = async (sdkDir, targetDir, cacheBust = false) => {
     const sdkPackageJsonPath = path.join(sdkDir, "package.json");
     let originalSdkPackageJson = null;
@@ -58,25 +145,47 @@ const performFullSync = async (sdkDir, targetDir, cacheBust = false) => {
             .readFile(lockfilePath, "utf-8")
             .catch(() => null);
         try {
-            const cmd = pm.name;
-            const args = [pm.command];
-            if (pm.name === "yarn") {
-                args.push(`file:${tarballPath}`);
+            if (pm.name === "pnpm") {
+                console.log("🛠️  Using pnpm overrides to install SDK...");
+                if (originalPackageJson) {
+                    const targetPackageJson = JSON.parse(originalPackageJson);
+                    targetPackageJson.pnpm = targetPackageJson.pnpm || {};
+                    targetPackageJson.pnpm.overrides =
+                        targetPackageJson.pnpm.overrides || {};
+                    targetPackageJson.pnpm.overrides.rwsdk = `file:${tarballPath}`;
+                    await fs.writeFile(packageJsonPath, JSON.stringify(targetPackageJson, null, 2));
+                }
+                // We use install here, which respects the overrides.
+                // We also don't want to fail if the lockfile is out of date.
+                await $("pnpm", ["install", "--no-frozen-lockfile"], {
+                    cwd: targetDir,
+                    stdio: "inherit",
+                });
+                if (process.env.RWSDK_PNPM_SYMLINK_FIX) {
+                    await hackyPnpmSymlinkFix(targetDir);
+                }
             }
             else {
-                args.push(tarballPath);
+                const cmd = pm.name;
+                const args = [pm.command];
+                if (pm.name === "yarn") {
+                    args.push(`file:${tarballPath}`);
+                }
+                else {
+                    args.push(tarballPath);
+                }
+                await $(cmd, args, {
+                    cwd: targetDir,
+                    stdio: "inherit",
+                });
             }
-            await $(cmd, args, {
-                cwd: targetDir,
-                stdio: "inherit",
-            });
         }
         finally {
             if (originalPackageJson) {
                 console.log("Restoring package.json...");
                 await fs.writeFile(packageJsonPath, originalPackageJson);
             }
-            if (originalLockfile) {
+            if (originalLockfile && pm.name !== "pnpm") {
                 console.log(`Restoring ${pm.lockFile}...`);
                 await fs.writeFile(lockfilePath, originalLockfile);
             }
@@ -131,7 +240,9 @@ const performSync = async (sdkDir, targetDir) => {
     }
     if (packageJsonChanged) {
         console.log("📦 package.json changed, performing full sync...");
-        await performFullSync(sdkDir, targetDir);
+        // We always cache-bust on a full sync now to ensure pnpm's overrides
+        // see a new version and the hacky symlink fix runs on a clean slate.
+        await performFullSync(sdkDir, targetDir, true);
     }
     else {
         await performFastSync(sdkDir, targetDir);
@@ -150,7 +261,8 @@ export const debugSync = async (opts) => {
         return;
     }
     // --- Watch Mode Logic ---
-    const lockfilePath = path.join(targetDir, "node_modules", ".rwsync.lock");
+    // Use global lock based on SDK directory since all instances sync from the same source
+    const lockfilePath = path.join(sdkDir, ".rwsync.lock");
     let release;
     // Ensure the directory for the lockfile exists
     await fs.mkdir(path.dirname(lockfilePath), { recursive: true });
@@ -161,7 +273,7 @@ export const debugSync = async (opts) => {
     }
     catch (e) {
         if (e.code === "ELOCKED") {
-            console.error(`❌ Another rwsync process is already watching ${targetDir}.`);
+            console.error(`❌ Another rwsync process is already running for this SDK.`);
             console.error(`   If this is not correct, please remove the lockfile at ${lockfilePath}`);
             process.exit(1);
         }

package/dist/scripts/smoke-test.mjs

@@ -30,6 +30,8 @@ if (fileURLToPath(import.meta.url) === process.argv[1]) {
         copyProject: false, // Default to false - don't copy project to artifacts
         realtime: false, // Default to false - don't just test realtime
         skipHmr: false, // Default to false - run HMR tests
+        // todo(justinvdm, 2025-07-31): Remove this once style tests working with headless
+        skipStyleTests: true, // Default to true - skip style tests
         // sync: will be set below
     };
     // Log if we're in CI
@@ -53,6 +55,9 @@ if (fileURLToPath(import.meta.url) === process.argv[1]) {
         else if (arg === "--skip-hmr") {
             options.skipHmr = true;
         }
+        else if (arg === "--run-style-tests") {
+            options.skipStyleTests = false;
+        }
         else if (arg === "--keep") {
             options.keep = true;
         }
@@ -89,6 +94,7 @@ Options:
   --skip-release          Skip testing the release/production deployment
   --skip-client           Skip client-side tests, only run server-side checks
   --skip-hmr              Skip hot module replacement (HMR) tests
+  --run-style-tests       Enable stylesheet-related tests (disabled by default)
   --path=PATH             Project directory to test
   --artifact-dir=DIR      Directory to store test artifacts (default: .artifacts)
   --keep                  Keep temporary test directory after tests complete

package/dist/vite/manifestPlugin.d.mts

@@ -0,0 +1,4 @@
+import { type Plugin } from "vite";
+export declare const manifestPlugin: ({ manifestPath, }: {
+    manifestPath: string;
+}) => Plugin;

package/dist/vite/manifestPlugin.mjs

@@ -0,0 +1,151 @@
+import { readFile } from "node:fs/promises";
+import debug from "debug";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+const log = debug("rwsdk:vite:manifest-plugin");
+const virtualModuleId = "virtual:rwsdk:manifest.js";
+const resolvedVirtualModuleId = "\0" + virtualModuleId;
+const getCssForModule = (server, moduleId, css) => {
+    const stack = [moduleId];
+    const visited = new Set();
+    while (stack.length > 0) {
+        const currentModuleId = stack.pop();
+        if (visited.has(currentModuleId)) {
+            continue;
+        }
+        visited.add(currentModuleId);
+        const moduleNode = server.environments.client.moduleGraph.getModuleById(currentModuleId);
+        if (!moduleNode) {
+            continue;
+        }
+        for (const importedModule of moduleNode.importedModules) {
+            if (importedModule.url.endsWith(".css")) {
+                const absolutePath = importedModule.file;
+                css.add({
+                    url: importedModule.url,
+                    // The `ssrTransformResult` has the CSS content, because the default
+                    // transform for CSS is to a string of the CSS content.
+                    content: importedModule.ssrTransformResult?.code ?? "",
+                    absolutePath,
+                });
+            }
+            if (importedModule.id) {
+                stack.push(importedModule.id);
+            }
+        }
+    }
+};
+export const manifestPlugin = ({ manifestPath, }) => {
+    let isBuild = false;
+    let root;
+    return {
+        name: "rwsdk:manifest",
+        configResolved(config) {
+            log("Config resolved, command=%s", config.command);
+            isBuild = config.command === "build";
+            root = config.root;
+        },
+        resolveId(id) {
+            if (id === virtualModuleId) {
+                process.env.VERBOSE && log("Resolving virtual module id=%s", id);
+                return resolvedVirtualModuleId;
+            }
+        },
+        async load(id) {
+            if (id === resolvedVirtualModuleId) {
+                process.env.VERBOSE && log("Loading virtual module id=%s", id);
+                if (!isBuild) {
+                    process.env.VERBOSE && log("Not a build, returning empty manifest");
+                    return `export default {}`;
+                }
+                log("Reading manifest from %s", manifestPath);
+                const manifestContent = await readFile(manifestPath, "utf-8");
+                const manifest = JSON.parse(manifestContent);
+                const normalizedManifest = {};
+                for (const key in manifest) {
+                    const normalizedKey = normalizeModulePath(key, root, {
+                        isViteStyle: false,
+                    });
+                    const entry = manifest[key];
+                    delete manifest[key];
+                    normalizedManifest[normalizedKey] = entry;
+                    entry.file = normalizeModulePath(entry.file, root, {
+                        isViteStyle: false,
+                    });
+                    const normalizedCss = [];
+                    if (entry.css) {
+                        for (const css of entry.css) {
+                            normalizedCss.push(normalizeModulePath(css, root, {
+                                isViteStyle: false,
+                            }));
+                        }
+                        entry.css = normalizedCss;
+                    }
+                }
+                return `export default ${JSON.stringify(normalizedManifest)}`;
+            }
+        },
+        configEnvironment(name, config) {
+            if (name !== "worker" && name !== "ssr") {
+                return;
+            }
+            log("Configuring environment: name=%s", name);
+            config.optimizeDeps ??= {};
+            config.optimizeDeps.esbuildOptions ??= {};
+            config.optimizeDeps.esbuildOptions.plugins ??= [];
+            config.optimizeDeps.esbuildOptions.plugins.push({
+                name: "rwsdk:manifest:esbuild",
+                setup(build) {
+                    log("Setting up esbuild plugin for environment: %s", name);
+                    build.onResolve({ filter: /^virtual:rwsdk:manifest\.js$/ }, () => {
+                        log("Resolving virtual manifest module in esbuild");
+                        return {
+                            path: "virtual:rwsdk:manifest.js",
+                            external: true,
+                        };
+                    });
+                },
+            });
+        },
+        configureServer(server) {
+            log("Configuring server middleware for manifest");
+            server.middlewares.use("/__rwsdk_manifest", async (req, res, next) => {
+                log("Manifest request received: %s", req.url);
+                try {
+                    const url = new URL(req.url, `http://${req.headers.host}`);
+                    const scripts = JSON.parse(url.searchParams.get("scripts") || "[]");
+                    process.env.VERBOSE && log("Transforming scripts: %o", scripts);
+                    for (const script of scripts) {
+                        await server.environments.client.transformRequest(script);
+                    }
+                    const manifest = {};
+                    log("Building manifest from module graph");
+                    for (const file of server.environments.client.moduleGraph.fileToModulesMap.keys()) {
+                        const modules = server.environments.client.moduleGraph.getModulesByFile(file);
+                        if (!modules) {
+                            continue;
+                        }
+                        for (const module of modules) {
+                            if (module.file) {
+                                const css = new Set();
+                                getCssForModule(server, module.id, css);
+                                manifest[normalizeModulePath(module.file, server.config.root)] =
+                                    {
+                                        file: module.url,
+                                        css: Array.from(css),
+                                    };
+                            }
+                        }
+                    }
+                    log("Manifest built successfully");
+                    process.env.VERBOSE && log("Manifest: %o", manifest);
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify(manifest));
+                }
+                catch (e) {
+                    log("Error building manifest: %o", e);
+                    next(e);
+                }
+            });
+        },
+    };
+};

package/dist/vite/redwoodPlugin.mjs

@@ -22,6 +22,7 @@ import { prismaPlugin } from "./prismaPlugin.mjs";
 import { ssrBridgePlugin } from "./ssrBridgePlugin.mjs";
 import { hasPkgScript } from "../lib/hasPkgScript.mjs";
 import { devServerTimingPlugin } from "./devServerTimingPlugin.mjs";
+import { manifestPlugin } from "./manifestPlugin.mjs";
 const determineWorkerEntryPathname = async (projectRootDir, workerConfigPath, options) => {
     if (options.entry?.worker) {
         return resolve(projectRootDir, options.entry.worker);
@@ -101,6 +102,9 @@ export const redwoodPlugin = async (options = {}) => {
         transformJsxScriptTagsPlugin({
             manifestPath: resolve(projectRootDir, "dist", "client", ".vite", "manifest.json"),
         }),
+        manifestPlugin({
+            manifestPath: resolve(projectRootDir, "dist", "client", ".vite", "manifest.json"),
+        }),
         moveStaticAssetsPlugin({ rootDir: projectRootDir }),
         prismaPlugin({ projectRootDir }),
     ];