rwsdk 0.1.15 → 0.1.17

package/dist/lib/compileTsModule.d.mts

@@ -0,0 +1 @@
+export declare const compileTsModule: (tsCode: string) => string;

package/dist/lib/compileTsModule.mjs

@@ -0,0 +1,27 @@
+import ts from "typescript";
+import path from "path";
+export const compileTsModule = (tsCode) => {
+    const tsConfigPath = "./tsconfig.json";
+    // Find the nearest tsconfig.json
+    const configPath = ts.findConfigFile(path.dirname(tsConfigPath), ts.sys.fileExists, path.basename(tsConfigPath));
+    if (!configPath) {
+        throw new Error(`Could not find a valid tsconfig.json at path: ${tsConfigPath}`);
+    }
+    // Read and parse tsconfig.json
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (configFile.error) {
+        throw new Error(`Error reading tsconfig.json: ${ts.formatDiagnostic(configFile.error, ts.createCompilerHost({}))}`);
+    }
+    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath));
+    const compilerOptions = parsedConfig.options;
+    // Transpile the TypeScript code using the compiler options
+    const output = ts.transpileModule(tsCode, {
+        compilerOptions,
+        reportDiagnostics: true,
+    });
+    if (output.diagnostics && output.diagnostics.length) {
+        const diagnosticMessages = output.diagnostics.map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+        throw new Error(`TypeScript Compilation Errors:\n${diagnosticMessages.join("\n")}`);
+    }
+    return output.outputText; // Compiled JavaScript code
+};

package/dist/runtime/entries/navigation.d.ts

@@ -0,0 +1 @@
+export * from "../clientNavigation";

package/dist/runtime/entries/navigation.js

@@ -0,0 +1 @@
+export * from "../clientNavigation";

package/dist/runtime/imports/client.js

@@ -5,7 +5,7 @@ export const loadModule = memoize(async (id) => {
         return await import(/* @vite-ignore */ id);
     }
     else {
-        const { useClientLookup } = await import("virtual:use-client-lookup");
+        const { useClientLookup } = await import("virtual:use-client-lookup.js");
         const moduleFn = useClientLookup[id];
         if (!moduleFn) {
             throw new Error(`(client) No module found for '${id}' in module lookup for "use client" directive`);

package/dist/runtime/imports/ssr.js

@@ -1,6 +1,6 @@
 import memoize from "lodash/memoize";
 export const ssrLoadModule = memoize(async (id) => {
-    const { useClientLookup } = await import("virtual:use-client-lookup");
+    const { useClientLookup } = await import("virtual:use-client-lookup.js");
     const moduleFn = useClientLookup[id];
     if (!moduleFn) {
         throw new Error(`(ssr) No module found for '${id}' in module lookup for "use client" directive`);

package/dist/runtime/imports/worker.js

@@ -2,7 +2,7 @@ import memoize from "lodash/memoize";
 import { requestInfo } from "../requestInfo/worker";
 import { ssrWebpackRequire as baseSsrWebpackRequire } from "rwsdk/__ssr_bridge";
 export const loadServerModule = memoize(async (id) => {
-    const { useServerLookup } = await import("virtual:use-server-lookup");
+    const { useServerLookup } = await import("virtual:use-server-lookup.js");
     const moduleFn = useServerLookup[id];
     if (!moduleFn) {
         throw new Error(`(worker) No module found for '${id}' in module lookup for "use server" directive`);

package/dist/runtime/register/ssr.js

@@ -1,7 +1,7 @@
 import memoize from "lodash/memoize";
 import { createServerReference as baseCreateServerReference } from "react-server-dom-webpack/client.edge";
 export const loadServerModule = memoize(async (id) => {
-    const { useServerLookup } = await import("virtual:use-server-lookup");
+    const { useServerLookup } = await import("virtual:use-server-lookup.js");
     const moduleFn = useServerLookup[id];
     if (!moduleFn) {
         throw new Error(`(worker) No module found for '${id}' in module lookup for "use server" directive`);

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

@@ -0,0 +1,3 @@
+export declare function injectRSCPayload(rscStream: ReadableStream, { nonce }: {
+    nonce: string;
+}): TransformStream<any, any>;

package/dist/runtime/render/injectRSCPayload.js

@@ -0,0 +1,79 @@
+// port(justinvdm, 10 Mar 2025): This is a modified version of https://github.com/devongovett/rsc-html-stream/blob/main/server.js
+// Modification: We needed to add a nonce attribute to the script tag for CSP
+const encoder = new TextEncoder();
+const trailer = "</body></html>";
+export function injectRSCPayload(rscStream, { nonce }) {
+    let decoder = new TextDecoder();
+    let resolveFlightDataPromise;
+    let flightDataPromise = new Promise((resolve) => (resolveFlightDataPromise = resolve));
+    let startedRSC = false;
+    // Buffer all HTML chunks enqueued during the current tick of the event loop (roughly)
+    // and write them to the output stream all at once. This ensures that we don't generate
+    // invalid HTML by injecting RSC in between two partial chunks of HTML.
+    let buffered = [];
+    let timeout = null;
+    function flushBufferedChunks(controller) {
+        for (let chunk of buffered) {
+            let buf = decoder.decode(chunk);
+            if (buf.endsWith(trailer)) {
+                buf = buf.slice(0, -trailer.length);
+            }
+            controller.enqueue(encoder.encode(buf));
+        }
+        buffered.length = 0;
+        timeout = null;
+    }
+    return new TransformStream({
+        transform(chunk, controller) {
+            buffered.push(chunk);
+            if (timeout) {
+                return;
+            }
+            timeout = setTimeout(async () => {
+                flushBufferedChunks(controller);
+                if (!startedRSC) {
+                    startedRSC = true;
+                    writeRSCStream(rscStream, controller, { nonce })
+                        .catch((err) => controller.error(err))
+                        .then(resolveFlightDataPromise);
+                }
+            }, 0);
+        },
+        async flush(controller) {
+            await flightDataPromise;
+            if (timeout) {
+                clearTimeout(timeout);
+                flushBufferedChunks(controller);
+            }
+            controller.enqueue(encoder.encode("</body></html>"));
+        },
+    });
+}
+async function writeRSCStream(rscStream, controller, { nonce }) {
+    let decoder = new TextDecoder("utf-8", { fatal: true });
+    for await (let chunk of rscStream) {
+        // Try decoding the chunk to send as a string.
+        // If that fails (e.g. binary data that is invalid unicode), write as base64.
+        try {
+            writeChunk(JSON.stringify(decoder.decode(chunk, { stream: true })), controller, { nonce });
+        }
+        catch (err) {
+            let base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
+            writeChunk(`Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`, controller, { nonce });
+        }
+    }
+    let remaining = decoder.decode();
+    if (remaining.length) {
+        writeChunk(JSON.stringify(remaining), controller, { nonce });
+    }
+}
+function writeChunk(chunk, controller, { nonce }) {
+    controller.enqueue(encoder.encode(`<script nonce="${nonce}">${escapeScript(`(self.__FLIGHT_DATA||=[]).push(${chunk})`)}</script>`));
+}
+// Escape closing script tags and HTML comments in JS content.
+// https://www.w3.org/TR/html52/semantics-scripting.html#restrictions-for-contents-of-script-elements
+// Avoid replacing </script with <\/script as it would break the following valid JS: 0</script/ (i.e. regexp literal).
+// Instead, escape the s character.
+function escapeScript(script) {
+    return script.replace(/<!--/g, "<\\!--").replace(/<\/(script)/gi, "</\\$1");
+}

package/dist/scripts/build-vendor-bundles.d.mts

@@ -0,0 +1 @@
+export declare const buildVendorBundles: () => Promise<void>;

package/dist/scripts/build-vendor-bundles.mjs

@@ -0,0 +1,92 @@
+import { resolve } from "node:path";
+import { build, mergeConfig } from "vite";
+import { $ } from "../lib/$.mjs";
+import { VENDOR_DIST_DIR, VENDOR_SRC_DIR } from "../lib/constants.mjs";
+import { unlink } from "fs/promises";
+import { pathExists } from "fs-extra";
+const createConfig = (mode) => ({
+    mode,
+    plugins: [],
+    logLevel: process.env.VERBOSE ? "info" : "error",
+    build: {
+        emptyOutDir: false,
+        sourcemap: true,
+        minify: mode === "production",
+    },
+    define: {
+        "process.env.NODE_ENV": JSON.stringify(mode),
+    },
+});
+const configs = {
+    // Build react internals with server conditions
+    reactServerInternals: (mode) => mergeConfig(createConfig(mode), {
+        build: {
+            outDir: VENDOR_DIST_DIR,
+            lib: {
+                entry: resolve(VENDOR_SRC_DIR, "react-server-internals.js"),
+                name: "react-server-internals",
+                formats: ["es"],
+                fileName: () => `react-server-internals.${mode}.js`,
+            },
+        },
+        resolve: {
+            conditions: ["react-server"],
+        },
+    }),
+    // Build custom React implementation (for both development and production)
+    react: (mode) => mergeConfig(createConfig(mode), {
+        build: {
+            outDir: VENDOR_DIST_DIR,
+            lib: {
+                entry: resolve(VENDOR_SRC_DIR, "react.js"),
+                name: "react",
+                formats: ["es"],
+                fileName: () => `react.${mode}.js`,
+            },
+        },
+        resolve: {
+            alias: {
+                "react-server-internals": resolve(VENDOR_DIST_DIR, `react-server-internals.${mode}.js`),
+            },
+        },
+    }),
+};
+export const buildVendorBundles = async () => {
+    console.log("Cleaning vendor directory...");
+    await $ `pnpm clean:vendor`;
+    // Build for both development and production modes
+    const modes = ["development", "production"];
+    // Build the temporary server internals files first
+    console.log("Building react-server-internals...");
+    for (const mode of modes) {
+        await build(configs.reactServerInternals(mode));
+    }
+    // Build React using the server internals
+    console.log("Building React custom builds...");
+    for (const mode of modes) {
+        await build(configs.react(mode));
+    }
+    // Clean up temporary server internals files
+    console.log("Cleaning up temporary server internals files...");
+    for (const mode of modes) {
+        const serverInternalsFile = resolve(VENDOR_DIST_DIR, `react-server-internals.${mode}.js`);
+        const serverInternalsMapFile = `${serverInternalsFile}.map`;
+        try {
+            // Delete the server internals JavaScript file
+            if (await pathExists(serverInternalsFile)) {
+                await unlink(serverInternalsFile);
+            }
+            // Delete the source map file if it exists
+            if (await pathExists(serverInternalsMapFile)) {
+                await unlink(serverInternalsMapFile);
+            }
+        }
+        catch (error) {
+            console.warn(`Warning: Failed to delete ${serverInternalsFile}`, error);
+        }
+    }
+    console.log("Done building vendor bundles");
+};
+if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
+    buildVendorBundles();
+}

package/dist/vite/aliasByEnvPlugin.d.mts

@@ -0,0 +1,2 @@
+import { Plugin } from "vite";
+export declare const aliasByEnvPlugin: (aliasesByEnv: Record<string, Record<string, string>>) => Plugin;

package/dist/vite/aliasByEnvPlugin.mjs

@@ -0,0 +1,11 @@
+export const aliasByEnvPlugin = (aliasesByEnv) => ({
+    name: "rw-sdk-env-alias",
+    enforce: "pre",
+    resolveId(id, importer) {
+        const aliases = aliasesByEnv[this.environment.name] ?? {};
+        const alias = aliases[id];
+        if (alias) {
+            return alias;
+        }
+    },
+});

package/dist/vite/asyncSetupPlugin.d.mts

@@ -0,0 +1,6 @@
+import { Plugin } from "vite";
+export declare const asyncSetupPlugin: ({ setup, }: {
+    setup: ({ command }: {
+        command: "serve" | "build";
+    }) => Promise<unknown>;
+}) => Plugin[];

package/dist/vite/asyncSetupPlugin.mjs

@@ -0,0 +1,23 @@
+export const asyncSetupPlugin = ({ setup, }) => {
+    let taskPromise = Promise.resolve(null);
+    return [
+        {
+            name: "rw-sdk-async-setup:serve",
+            apply: "serve",
+            configureServer(server) {
+                taskPromise = setup({ command: "serve" });
+                server.middlewares.use(async (_req, _res, next) => {
+                    await taskPromise;
+                    next();
+                });
+            },
+        },
+        {
+            name: "rw-sdk-async-setup:build",
+            apply: "build",
+            async buildStart() {
+                await setup({ command: "build" });
+            },
+        },
+    ];
+};

package/dist/vite/copyPrismaWasmPlugin.d.mts

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

package/dist/vite/copyPrismaWasmPlugin.mjs

@@ -0,0 +1,32 @@
+import { copy, pathExists } from "fs-extra";
+import { resolve } from "node:path";
+import MagicString from "magic-string";
+import path from "path";
+export const copyPrismaWasmPlugin = ({ rootDir, }) => ({
+    name: "rwsdk:copy-prisma-wasm",
+    enforce: "post",
+    apply: "build",
+    async writeBundle() {
+        const wasmFilePath = resolve(rootDir, "node_modules/.prisma/client/query_engine_bg.wasm");
+        const fileName = path.basename(wasmFilePath);
+        const outputPath = path.resolve(rootDir, "dist", "worker", fileName);
+        if (await pathExists(wasmFilePath)) {
+            await copy(wasmFilePath, outputPath);
+            console.log(`✅ Copied ${fileName} from ${wasmFilePath} to ${outputPath}`);
+        }
+    },
+    renderChunk(code) {
+        if (!code.includes(".wasm")) {
+            return;
+        }
+        const s = new MagicString(code);
+        s.replace(/import\(["'](.+?\.wasm)["']\)/g, (_, filePath) => {
+            const fileName = path.basename(filePath);
+            return `import("./${fileName}")`;
+        });
+        return {
+            code: s.toString(),
+            map: s.generateMap(),
+        };
+    },
+});

package/dist/vite/createDirectiveLookupPlugin.mjs

@@ -150,12 +150,12 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
                     const escapedVirtualModuleName = config.virtualModuleName.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
                     const escapedPrefixedModuleName = `/@id/${config.virtualModuleName}`.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
                     build.onResolve({
-                        filter: new RegExp(`^(${escapedVirtualModuleName}|${escapedPrefixedModuleName})$`),
+                        filter: new RegExp(`^(${escapedVirtualModuleName}|${escapedPrefixedModuleName})\.js$`),
                     }, () => {
                         process.env.VERBOSE &&
                             log("Esbuild onResolve: marking %s as external", config.virtualModuleName);
                         return {
-                            path: config.virtualModuleName,
+                            path: `${config.virtualModuleName}.js`,
                             external: true,
                         };
                     });
@@ -184,13 +184,11 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
         },
         resolveId(source) {
             process.env.VERBOSE && log("Resolving id=%s", source);
-            if (source === config.virtualModuleName ||
-                source === `/@id/${config.virtualModuleName}` ||
-                source === `/@id/${config.virtualModuleName}.js`) {
+            if (source === `${config.virtualModuleName}.js`) {
                 log("Resolving %s module", config.virtualModuleName);
                 // context(justinvdm, 16 Jun 2025): Include .js extension
                 // so it goes through vite processing chain
-                return `${config.virtualModuleName}.js`;
+                return source;
             }
             process.env.VERBOSE && log("No resolution for id=%s", source);
         },

package/dist/vite/customReactBuildPlugin.d.mts

@@ -0,0 +1,4 @@
+import { Plugin } from "vite";
+export declare const customReactBuildPlugin: ({ projectRootDir, }: {
+    projectRootDir: string;
+}) => Promise<Plugin>;

package/dist/vite/customReactBuildPlugin.mjs

@@ -0,0 +1,61 @@
+import { resolve } from "path";
+import { mkdirp, copy } from "fs-extra";
+import { VENDOR_DIST_DIR } from "../lib/constants.mjs";
+const copyReactFiles = async (viteDistDir) => {
+    await mkdirp(viteDistDir);
+    await copy(resolve(VENDOR_DIST_DIR, "react.js"), resolve(viteDistDir, "react.js"));
+    await copy(resolve(VENDOR_DIST_DIR, "react.js.map"), resolve(viteDistDir, "react.js.map"));
+    await copy(resolve(VENDOR_DIST_DIR, "react-dom-server-edge.js"), resolve(viteDistDir, "react-dom-server-edge.js"));
+    await copy(resolve(VENDOR_DIST_DIR, "react-dom-server-edge.js.map"), resolve(viteDistDir, "react-dom-server-edge.js.map"));
+};
+export const customReactBuildPlugin = async ({ projectRootDir, }) => {
+    const viteDistDir = resolve(projectRootDir, "node_modules", ".vite_@redwoodjs/sdk");
+    await copyReactFiles(viteDistDir);
+    return {
+        name: "custom-react-build-plugin",
+        enforce: "pre",
+        applyToEnvironment: (environment) => {
+            return environment.name === "worker";
+        },
+        async configureServer() {
+            await mkdirp(viteDistDir);
+            await copy(resolve(VENDOR_DIST_DIR, "react.js"), resolve(viteDistDir, "react.js"));
+            await copy(resolve(VENDOR_DIST_DIR, "react.js.map"), resolve(viteDistDir, "react.js.map"));
+            await copy(resolve(VENDOR_DIST_DIR, "react-dom-server-edge.js"), resolve(viteDistDir, "react-dom-server-edge.js"));
+            await copy(resolve(VENDOR_DIST_DIR, "react-dom-server-edge.js.map"), resolve(viteDistDir, "react-dom-server-edge.js.map"));
+        },
+        resolveId(id) {
+            if (id === "react") {
+                return resolve(viteDistDir, "react.js");
+            }
+            if (id === "react-dom/server.edge" || id === "react-dom/server") {
+                return resolve(viteDistDir, "react-dom-server-edge.js");
+            }
+        },
+        config: () => ({
+            environments: {
+                worker: {
+                    optimizeDeps: {
+                        esbuildOptions: {
+                            plugins: [
+                                {
+                                    name: "rewrite-react-imports",
+                                    setup(build) {
+                                        build.onResolve({ filter: /^react$/ }, (args) => {
+                                            return { path: resolve(viteDistDir, "react.js") };
+                                        });
+                                        build.onResolve({ filter: /^react-dom\/server\.edge$/ }, (args) => {
+                                            return {
+                                                path: resolve(viteDistDir, "react-dom-server-edge.js"),
+                                            };
+                                        });
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                },
+            },
+        }),
+    };
+};

package/dist/vite/findSsrSpecifiers.mjs

@@ -32,6 +32,22 @@ export function findSsrImportSpecifiers(id, code, log) {
                 pattern: `__vite_ssr_dynamic_import__('$SPECIFIER')`,
                 list: dynamicImports,
             },
+            {
+                pattern: `__vite_ssr_import__("$SPECIFIER", $$$REST)`,
+                list: imports,
+            },
+            {
+                pattern: `__vite_ssr_import__('$SPECIFIER', $$$REST)`,
+                list: imports,
+            },
+            {
+                pattern: `__vite_ssr_dynamic_import__("$SPECIFIER", $$$REST)`,
+                list: dynamicImports,
+            },
+            {
+                pattern: `__vite_ssr_dynamic_import__('$SPECIFIER', $$$REST)`,
+                list: dynamicImports,
+            },
         ];
         for (const { pattern, list } of patterns) {
             const matches = root.root().findAll(pattern);

package/dist/vite/injectHmrPreambleJsxPlugin.d.mts

@@ -0,0 +1,2 @@
+import { type Plugin } from "vite";
+export declare const injectHmrPreambleJsxPlugin: () => Plugin;

package/dist/vite/injectHmrPreambleJsxPlugin.mjs

@@ -0,0 +1,22 @@
+import MagicString from "magic-string";
+export const injectHmrPreambleJsxPlugin = () => ({
+    name: "rw-sdk-inject-hmr-preamble",
+    apply: "serve",
+    async transform(code, id) {
+        const htmlHeadRE = /jsxDEV\("html",[^]*?jsxDEV\("head",[^]*?\[(.*?)\]/s;
+        const match = code.match(htmlHeadRE);
+        if (!match) {
+            return;
+        }
+        const s = new MagicString(code);
+        const headContentStart = match.index + match[0].lastIndexOf("[");
+        s.appendLeft(headContentStart + 1, `jsxDEV("script", { 
+        type: "module",
+        src: "/__vite_preamble__",
+      }),`);
+        return {
+            code: s.toString(),
+            map: s.generateMap(),
+        };
+    },
+});

package/dist/vite/miniflareHMRPlugin.mjs

@@ -32,13 +32,50 @@ const hasEntryAsAncestor = (module, entryFile, seen = new Set()) => {
     }
     return false;
 };
+const isInUseClientGraph = ({ file, clientFiles, server, }) => {
+    const id = normalizeModulePath(server.config.root, file);
+    if (clientFiles.has(id)) {
+        return true;
+    }
+    const modules = server.environments.client.moduleGraph.getModulesByFile(file);
+    if (!modules) {
+        return false;
+    }
+    for (const m of modules) {
+        for (const importer of m.importers) {
+            if (importer.file &&
+                isInUseClientGraph({ file: importer.file, clientFiles, server })) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
 export const miniflareHMRPlugin = (givenOptions) => [
     {
         name: "rwsdk:miniflare-hmr",
         async hotUpdate(ctx) {
             const { clientFiles, serverFiles, viteEnvironment: { name: environment }, workerEntryPathname: entry, } = givenOptions;
             if (process.env.VERBOSE) {
-                this.environment.logger.info(`Hot update: (env=${this.environment.name}) ${ctx.file}\nModule graph:\n\n${dumpFullModuleGraph(ctx.server, this.environment.name)}`);
+                log(`Hot update: (env=${this.environment.name}) ${ctx.file}\nModule graph:\n\n${dumpFullModuleGraph(ctx.server, this.environment.name)}`);
+            }
+            if (!isJsFile(ctx.file) && !ctx.file.endsWith(".css")) {
+                return;
+            }
+            if (this.environment.name === "ssr") {
+                log("SSR update, invalidating recursively", ctx.file);
+                const isUseClientUpdate = isInUseClientGraph({
+                    file: ctx.file,
+                    clientFiles,
+                    server: ctx.server,
+                });
+                if (!isUseClientUpdate) {
+                    return [];
+                }
+                invalidateModule(ctx.server, "ssr", ctx.file);
+                invalidateModule(ctx.server, environment, VIRTUAL_SSR_PREFIX +
+                    normalizeModulePath(givenOptions.rootDir, ctx.file));
+                return [];
             }
             if (!["client", environment].includes(this.environment.name)) {
                 return [];
@@ -77,33 +114,34 @@ export const miniflareHMRPlugin = (givenOptions) => [
             }
             // todo(justinvdm, 12 Dec 2024): Skip client references
             const modules = Array.from(ctx.server.environments[environment].moduleGraph.getModulesByFile(ctx.file) ?? []);
-            const isWorkerUpdate = ctx.file === entry ||
-                modules.some((module) => hasEntryAsAncestor(module, entry));
-            // The worker doesnt need an update
-            // => Short circuit HMR
-            if (!isWorkerUpdate) {
-                return [];
-            }
+            const isWorkerUpdate = Boolean(modules);
             // The worker needs an update, but this is the client environment
             // => Notify for HMR update of any css files imported by in worker, that are also in the client module graph
             // Why: There may have been changes to css classes referenced, which might css modules to change
             if (this.environment.name === "client") {
-                for (const [_, module] of ctx.server.environments[environment]
-                    .moduleGraph.idToModuleMap) {
-                    // todo(justinvdm, 13 Dec 2024): We check+update _all_ css files in worker module graph,
-                    // but it could just be a subset of css files that are actually affected, depending
-                    // on the importers and imports of the changed file. We should be smarter about this.
-                    if (module.file && module.file.endsWith(".css")) {
-                        const clientModules = ctx.server.environments.client.moduleGraph.getModulesByFile(module.file);
-                        for (const clientModule of clientModules ?? []) {
-                            invalidateModule(ctx.server, "client", clientModule);
+                if (isWorkerUpdate) {
+                    for (const [_, module] of ctx.server.environments[environment]
+                        .moduleGraph.idToModuleMap) {
+                        // todo(justinvdm, 13 Dec 2024): We check+update _all_ css files in worker module graph,
+                        // but it could just be a subset of css files that are actually affected, depending
+                        // on the importers and imports of the changed file. We should be smarter about this.
+                        if (module.file && module.file.endsWith(".css")) {
+                            const clientModules = ctx.server.environments.client.moduleGraph.getModulesByFile(module.file);
+                            for (const clientModule of clientModules ?? []) {
+                                invalidateModule(ctx.server, "client", clientModule);
+                            }
                         }
                     }
                 }
-                // context(justinvdm, 10 Jul 2025): If this isn't a file with a client
-                // directive or a css file, we shouldn't invalidate anything else to
-                // avoid full page reload
-                return hasClientDirective || ctx.file.endsWith(".css") ? undefined : [];
+                const isUseClientUpdate = isInUseClientGraph({
+                    file: ctx.file,
+                    clientFiles,
+                    server: ctx.server,
+                });
+                if (!isUseClientUpdate && !ctx.file.endsWith(".css")) {
+                    return [];
+                }
+                return ctx.modules;
             }
             // The worker needs an update, and the hot check is for the worker environment
             // => Notify for custom RSC-based HMR update, then short circuit HMR

package/dist/vite/miniflarePlugin.d.mts

@@ -0,0 +1,9 @@
+import { Plugin } from "vite";
+import { cloudflare } from "@cloudflare/vite-plugin";
+type BasePluginOptions = Parameters<typeof cloudflare>[0];
+type MiniflarePluginOptions = BasePluginOptions & {};
+export declare const miniflarePlugin: (givenOptions: MiniflarePluginOptions & {
+    rootDir: string;
+    workerEntryPathname: string;
+}) => (Plugin | Plugin[])[];
+export {};